gogol-digitalassetlinks 0.5.0 → 1.0.0

raw patch · 16 files changed

+1435/−1340 lines, 16 filesdep −basedep ~gogol-coresetup-changed

Dependencies removed: base

Dependency ranges changed: gogol-core

Files

• README.md +1/−1
• Setup.hs +2/−1
• gen/Gogol/DigitalAssetLinks.hs +110/−0
• gen/Gogol/DigitalAssetLinks/Assetlinks/BulkCheck.hs +110/−0
• gen/Gogol/DigitalAssetLinks/Assetlinks/Check.hs +144/−0
• gen/Gogol/DigitalAssetLinks/Internal/Product.hs +471/−0
• gen/Gogol/DigitalAssetLinks/Internal/Sum.hs +325/−0
• gen/Gogol/DigitalAssetLinks/Statements/List.hs +124/−0
• gen/Gogol/DigitalAssetLinks/Types.hs +95/−0
• gen/Network/Google/DigitalAssetLinks.hs +0/−98
• gen/Network/Google/DigitalAssetLinks/Types.hs +0/−79
• gen/Network/Google/DigitalAssetLinks/Types/Product.hs +0/−471
• gen/Network/Google/DigitalAssetLinks/Types/Sum.hs +0/−48
• gen/Network/Google/Resource/DigitalAssetLinks/Assetlinks/Check.hs +0/−347
• gen/Network/Google/Resource/DigitalAssetLinks/Statements/List.hs +0/−257
• gogol-digitalassetlinks.cabal +53/−38

@@ -8,7 +8,7 @@  ## Version -`0.5.0`+`1.0.0`   ## Description

@@ -1,2 +1,3 @@-import           Distribution.Simple+import Distribution.Simple+ main = defaultMain

@@ -0,0 +1,110 @@+{-# 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.DigitalAssetLinks+-- 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)+--+-- Discovers relationships between online assets such as websites or mobile apps.+--+-- /See:/ <https://developers.google.com/digital-asset-links/ Digital Asset Links API Reference>+module Gogol.DigitalAssetLinks+  ( -- * Configuration+    digitalAssetLinksService,++    -- * Resources++    -- ** digitalassetlinks.assetlinks.bulkCheck+    DigitalAssetLinksAssetlinksBulkCheckResource,+    DigitalAssetLinksAssetlinksBulkCheck (..),+    newDigitalAssetLinksAssetlinksBulkCheck,++    -- ** digitalassetlinks.assetlinks.check+    DigitalAssetLinksAssetlinksCheckResource,+    DigitalAssetLinksAssetlinksCheck (..),+    newDigitalAssetLinksAssetlinksCheck,++    -- ** digitalassetlinks.statements.list+    DigitalAssetLinksStatementsListResource,+    DigitalAssetLinksStatementsList (..),+    newDigitalAssetLinksStatementsList,++    -- * Types++    -- ** Xgafv+    Xgafv (..),++    -- ** AndroidAppAsset+    AndroidAppAsset (..),+    newAndroidAppAsset,++    -- ** Asset+    Asset (..),+    newAsset,++    -- ** BulkCheckRequest+    BulkCheckRequest (..),+    newBulkCheckRequest,++    -- ** BulkCheckResponse+    BulkCheckResponse (..),+    newBulkCheckResponse,++    -- ** BulkCheckResponse_BulkErrorCode+    BulkCheckResponse_BulkErrorCode (..),++    -- ** CertificateInfo+    CertificateInfo (..),+    newCertificateInfo,++    -- ** CheckResponse+    CheckResponse (..),+    newCheckResponse,++    -- ** CheckResponse_ErrorCodeItem+    CheckResponse_ErrorCodeItem (..),++    -- ** ListResponse+    ListResponse (..),+    newListResponse,++    -- ** ListResponse_ErrorCodeItem+    ListResponse_ErrorCodeItem (..),++    -- ** Statement+    Statement (..),+    newStatement,++    -- ** StatementTemplate+    StatementTemplate (..),+    newStatementTemplate,++    -- ** WebAsset+    WebAsset (..),+    newWebAsset,+  )+where++import Gogol.DigitalAssetLinks.Assetlinks.BulkCheck+import Gogol.DigitalAssetLinks.Assetlinks.Check+import Gogol.DigitalAssetLinks.Statements.List+import Gogol.DigitalAssetLinks.Types

@@ -0,0 +1,110 @@+{-# 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.DigitalAssetLinks.Assetlinks.BulkCheck+-- 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)+--+-- Send a bundle of statement checks in a single RPC to minimize latency and service load. Statements need not be all for the same source and\/or target. We recommend using this method when you need to check more than one statement in a short period of time.+--+-- /See:/ <https://developers.google.com/digital-asset-links/ Digital Asset Links API Reference> for @digitalassetlinks.assetlinks.bulkCheck@.+module Gogol.DigitalAssetLinks.Assetlinks.BulkCheck+  ( -- * Resource+    DigitalAssetLinksAssetlinksBulkCheckResource,++    -- ** Constructing a Request+    DigitalAssetLinksAssetlinksBulkCheck (..),+    newDigitalAssetLinksAssetlinksBulkCheck,+  )+where++import Gogol.DigitalAssetLinks.Types+import Gogol.Prelude qualified as Core++-- | A resource alias for @digitalassetlinks.assetlinks.bulkCheck@ method which the+-- 'DigitalAssetLinksAssetlinksBulkCheck' request conforms to.+type DigitalAssetLinksAssetlinksBulkCheckResource =+  "v1"+    Core.:> "assetlinks:bulkCheck"+    Core.:> Core.QueryParam "$.xgafv" Xgafv+    Core.:> Core.QueryParam "access_token" Core.Text+    Core.:> Core.QueryParam "callback" Core.Text+    Core.:> Core.QueryParam "uploadType" Core.Text+    Core.:> Core.QueryParam "upload_protocol" Core.Text+    Core.:> Core.QueryParam "alt" Core.AltJSON+    Core.:> Core.ReqBody '[Core.JSON] BulkCheckRequest+    Core.:> Core.Post '[Core.JSON] BulkCheckResponse++-- | Send a bundle of statement checks in a single RPC to minimize latency and service load. Statements need not be all for the same source and\/or target. We recommend using this method when you need to check more than one statement in a short period of time.+--+-- /See:/ 'newDigitalAssetLinksAssetlinksBulkCheck' smart constructor.+data DigitalAssetLinksAssetlinksBulkCheck = DigitalAssetLinksAssetlinksBulkCheck+  { -- | V1 error format.+    xgafv :: (Core.Maybe Xgafv),+    -- | OAuth access token.+    accessToken :: (Core.Maybe Core.Text),+    -- | JSONP+    callback :: (Core.Maybe Core.Text),+    -- | Multipart request metadata.+    payload :: BulkCheckRequest,+    -- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").+    uploadType :: (Core.Maybe Core.Text),+    -- | Upload protocol for media (e.g. \"raw\", \"multipart\").+    uploadProtocol :: (Core.Maybe Core.Text)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'DigitalAssetLinksAssetlinksBulkCheck' with the minimum fields required to make a request.+newDigitalAssetLinksAssetlinksBulkCheck ::+  -- |  Multipart request metadata. See 'payload'.+  BulkCheckRequest ->+  DigitalAssetLinksAssetlinksBulkCheck+newDigitalAssetLinksAssetlinksBulkCheck payload =+  DigitalAssetLinksAssetlinksBulkCheck+    { xgafv = Core.Nothing,+      accessToken = Core.Nothing,+      callback = Core.Nothing,+      payload = payload,+      uploadType = Core.Nothing,+      uploadProtocol = Core.Nothing+    }++instance Core.GoogleRequest DigitalAssetLinksAssetlinksBulkCheck where+  type Rs DigitalAssetLinksAssetlinksBulkCheck = BulkCheckResponse+  type Scopes DigitalAssetLinksAssetlinksBulkCheck = '[]+  requestClient DigitalAssetLinksAssetlinksBulkCheck {..} =+    go+      xgafv+      accessToken+      callback+      uploadType+      uploadProtocol+      (Core.Just Core.AltJSON)+      payload+      digitalAssetLinksService+    where+      go =+        Core.buildClient+          ( Core.Proxy ::+              Core.Proxy DigitalAssetLinksAssetlinksBulkCheckResource+          )+          Core.mempty

@@ -0,0 +1,144 @@+{-# 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.DigitalAssetLinks.Assetlinks.Check+-- 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)+--+-- Determines whether the specified (directional) relationship exists between the specified source and target assets. The relation describes the intent of the link between the two assets as claimed by the source asset. An example for such relationships is the delegation of privileges or permissions. This command is most often used by infrastructure systems to check preconditions for an action. For example, a client may want to know if it is OK to send a web URL to a particular mobile app instead. The client can check for the relevant asset link from the website to the mobile app to decide if the operation should be allowed. A note about security: if you specify a secure asset as the source, such as an HTTPS website or an Android app, the API will ensure that any statements used to generate the response have been made in a secure way by the owner of that asset. Conversely, if the source asset is an insecure HTTP website (that is, the URL starts with @http:\/\/@ instead of @https:\/\/@), the API cannot verify its+-- statements securely, and it is not possible to ensure that the website\'s statements have not been altered by a third party. For more information, see the <https://github.com/google/digitalassetlinks/blob/master/well-known/details.md Digital Asset Links technical design specification>.+--+-- /See:/ <https://developers.google.com/digital-asset-links/ Digital Asset Links API Reference> for @digitalassetlinks.assetlinks.check@.+module Gogol.DigitalAssetLinks.Assetlinks.Check+  ( -- * Resource+    DigitalAssetLinksAssetlinksCheckResource,++    -- ** Constructing a Request+    DigitalAssetLinksAssetlinksCheck (..),+    newDigitalAssetLinksAssetlinksCheck,+  )+where++import Gogol.DigitalAssetLinks.Types+import Gogol.Prelude qualified as Core++-- | A resource alias for @digitalassetlinks.assetlinks.check@ method which the+-- 'DigitalAssetLinksAssetlinksCheck' request conforms to.+type DigitalAssetLinksAssetlinksCheckResource =+  "v1"+    Core.:> "assetlinks:check"+    Core.:> Core.QueryParam "$.xgafv" Xgafv+    Core.:> Core.QueryParam "access_token" Core.Text+    Core.:> Core.QueryParam "callback" Core.Text+    Core.:> Core.QueryParam "relation" Core.Text+    Core.:> Core.QueryParam+              "source.androidApp.certificate.sha256Fingerprint"+              Core.Text+    Core.:> Core.QueryParam "source.androidApp.packageName" Core.Text+    Core.:> Core.QueryParam "source.web.site" Core.Text+    Core.:> Core.QueryParam+              "target.androidApp.certificate.sha256Fingerprint"+              Core.Text+    Core.:> Core.QueryParam "target.androidApp.packageName" Core.Text+    Core.:> Core.QueryParam "target.web.site" Core.Text+    Core.:> Core.QueryParam "uploadType" Core.Text+    Core.:> Core.QueryParam "upload_protocol" Core.Text+    Core.:> Core.QueryParam "alt" Core.AltJSON+    Core.:> Core.Get '[Core.JSON] CheckResponse++-- | Determines whether the specified (directional) relationship exists between the specified source and target assets. The relation describes the intent of the link between the two assets as claimed by the source asset. An example for such relationships is the delegation of privileges or permissions. This command is most often used by infrastructure systems to check preconditions for an action. For example, a client may want to know if it is OK to send a web URL to a particular mobile app instead. The client can check for the relevant asset link from the website to the mobile app to decide if the operation should be allowed. A note about security: if you specify a secure asset as the source, such as an HTTPS website or an Android app, the API will ensure that any statements used to generate the response have been made in a secure way by the owner of that asset. Conversely, if the source asset is an insecure HTTP website (that is, the URL starts with @http:\/\/@ instead of @https:\/\/@), the API cannot verify its+-- statements securely, and it is not possible to ensure that the website\'s statements have not been altered by a third party. For more information, see the <https://github.com/google/digitalassetlinks/blob/master/well-known/details.md Digital Asset Links technical design specification>.+--+-- /See:/ 'newDigitalAssetLinksAssetlinksCheck' smart constructor.+data DigitalAssetLinksAssetlinksCheck = DigitalAssetLinksAssetlinksCheck+  { -- | V1 error format.+    xgafv :: (Core.Maybe Xgafv),+    -- | OAuth access token.+    accessToken :: (Core.Maybe Core.Text),+    -- | JSONP+    callback :: (Core.Maybe Core.Text),+    -- | Query string for the relation. We identify relations with strings of the format @\/@, where @must be one of a set of pre-defined purpose categories, and@ is a free-form lowercase alphanumeric string that describes the specific use case of the statement. Refer to </digital-asset-links/v1/relation-strings our API documentation> for the current list of supported relations. For a query to match an asset link, both the query\'s and the asset link\'s relation strings must match exactly. Example: A query with relation @delegate_permission\/common.handle_all_urls@ matches an asset link with relation @delegate_permission\/common.handle_all_urls@.+    relation :: (Core.Maybe Core.Text),+    -- | The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be @14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5@. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).+    sourceAndroidAppCertificateSha256Fingerprint :: (Core.Maybe Core.Text),+    -- | Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name @com.google.android.apps.maps@. REQUIRED+    sourceAndroidAppPackageName :: (Core.Maybe Core.Text),+    -- | Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be fully qualified: they must end in a single period (\"@.@\"). Only the schemes \"http\" and \"https\" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the \"site\". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site @https:\/\/www.google.com@ contains all these URLs: * @https:\/\/www.google.com\/@ * @https:\/\/www.google.com:443\/@ * @https:\/\/www.google.com\/foo@ * @https:\/\/www.google.com\/foo?bar@ * @https:\/\/www.google.com\/foo#bar@ * @https:\/\/user\@password:www.google.com\/@ But it does not contain these URLs: * @http:\/\/www.google.com\/@ (wrong scheme) * @https:\/\/google.com\/@ (hostname does not match) *+    -- @https:\/\/www.google.com:444\/@ (port does not match) REQUIRED+    sourceWebSite :: (Core.Maybe Core.Text),+    -- | The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be @14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5@. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).+    targetAndroidAppCertificateSha256Fingerprint :: (Core.Maybe Core.Text),+    -- | Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name @com.google.android.apps.maps@. REQUIRED+    targetAndroidAppPackageName :: (Core.Maybe Core.Text),+    -- | Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be fully qualified: they must end in a single period (\"@.@\"). Only the schemes \"http\" and \"https\" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the \"site\". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site @https:\/\/www.google.com@ contains all these URLs: * @https:\/\/www.google.com\/@ * @https:\/\/www.google.com:443\/@ * @https:\/\/www.google.com\/foo@ * @https:\/\/www.google.com\/foo?bar@ * @https:\/\/www.google.com\/foo#bar@ * @https:\/\/user\@password:www.google.com\/@ But it does not contain these URLs: * @http:\/\/www.google.com\/@ (wrong scheme) * @https:\/\/google.com\/@ (hostname does not match) *+    -- @https:\/\/www.google.com:444\/@ (port does not match) REQUIRED+    targetWebSite :: (Core.Maybe Core.Text),+    -- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").+    uploadType :: (Core.Maybe Core.Text),+    -- | Upload protocol for media (e.g. \"raw\", \"multipart\").+    uploadProtocol :: (Core.Maybe Core.Text)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'DigitalAssetLinksAssetlinksCheck' with the minimum fields required to make a request.+newDigitalAssetLinksAssetlinksCheck ::+  DigitalAssetLinksAssetlinksCheck+newDigitalAssetLinksAssetlinksCheck =+  DigitalAssetLinksAssetlinksCheck+    { xgafv = Core.Nothing,+      accessToken = Core.Nothing,+      callback = Core.Nothing,+      relation = Core.Nothing,+      sourceAndroidAppCertificateSha256Fingerprint = Core.Nothing,+      sourceAndroidAppPackageName = Core.Nothing,+      sourceWebSite = Core.Nothing,+      targetAndroidAppCertificateSha256Fingerprint = Core.Nothing,+      targetAndroidAppPackageName = Core.Nothing,+      targetWebSite = Core.Nothing,+      uploadType = Core.Nothing,+      uploadProtocol = Core.Nothing+    }++instance Core.GoogleRequest DigitalAssetLinksAssetlinksCheck where+  type Rs DigitalAssetLinksAssetlinksCheck = CheckResponse+  type Scopes DigitalAssetLinksAssetlinksCheck = '[]+  requestClient DigitalAssetLinksAssetlinksCheck {..} =+    go+      xgafv+      accessToken+      callback+      relation+      sourceAndroidAppCertificateSha256Fingerprint+      sourceAndroidAppPackageName+      sourceWebSite+      targetAndroidAppCertificateSha256Fingerprint+      targetAndroidAppPackageName+      targetWebSite+      uploadType+      uploadProtocol+      (Core.Just Core.AltJSON)+      digitalAssetLinksService+    where+      go =+        Core.buildClient+          (Core.Proxy :: Core.Proxy DigitalAssetLinksAssetlinksCheckResource)+          Core.mempty

@@ -0,0 +1,471 @@+{-# 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.DigitalAssetLinks.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.DigitalAssetLinks.Internal.Product+  ( -- * AndroidAppAsset+    AndroidAppAsset (..),+    newAndroidAppAsset,++    -- * Asset+    Asset (..),+    newAsset,++    -- * BulkCheckRequest+    BulkCheckRequest (..),+    newBulkCheckRequest,++    -- * BulkCheckResponse+    BulkCheckResponse (..),+    newBulkCheckResponse,++    -- * CertificateInfo+    CertificateInfo (..),+    newCertificateInfo,++    -- * CheckResponse+    CheckResponse (..),+    newCheckResponse,++    -- * ListResponse+    ListResponse (..),+    newListResponse,++    -- * Statement+    Statement (..),+    newStatement,++    -- * StatementTemplate+    StatementTemplate (..),+    newStatementTemplate,++    -- * WebAsset+    WebAsset (..),+    newWebAsset,+  )+where++import Gogol.DigitalAssetLinks.Internal.Sum+import Gogol.Prelude qualified as Core++-- | Describes an android app asset.+--+-- /See:/ 'newAndroidAppAsset' smart constructor.+data AndroidAppAsset = AndroidAppAsset+  { -- | Because there is no global enforcement of package name uniqueness, we also require a signing certificate, which in combination with the package name uniquely identifies an app. Some apps\' signing keys are rotated, so they may be signed by different keys over time. We treat these as distinct assets, since we use (package name, cert) as the unique ID. This should not normally pose any problems as both versions of the app will make the same or similar statements. Other assets making statements about the app will have to be updated when a key is rotated, however. (Note that the syntaxes for publishing and querying for statements contain syntactic sugar to easily let you specify apps that are known by multiple certificates.) REQUIRED+    certificate :: (Core.Maybe CertificateInfo),+    -- | Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name @com.google.android.apps.maps@. REQUIRED+    packageName :: (Core.Maybe Core.Text)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'AndroidAppAsset' with the minimum fields required to make a request.+newAndroidAppAsset ::+  AndroidAppAsset+newAndroidAppAsset =+  AndroidAppAsset+    { certificate = Core.Nothing,+      packageName = Core.Nothing+    }++instance Core.FromJSON AndroidAppAsset where+  parseJSON =+    Core.withObject+      "AndroidAppAsset"+      ( \o ->+          AndroidAppAsset+            Core.<$> (o Core..:? "certificate")+            Core.<*> (o Core..:? "packageName")+      )++instance Core.ToJSON AndroidAppAsset where+  toJSON AndroidAppAsset {..} =+    Core.object+      ( Core.catMaybes+          [ ("certificate" Core..=) Core.<$> certificate,+            ("packageName" Core..=) Core.<$> packageName+          ]+      )++-- | Uniquely identifies an asset. A digital asset is an identifiable and addressable online entity that typically provides some service or content. Examples of assets are websites, Android apps, Twitter feeds, and Plus Pages.+--+-- /See:/ 'newAsset' smart constructor.+data Asset = Asset+  { -- | Set if this is an Android App asset.+    androidApp :: (Core.Maybe AndroidAppAsset),+    -- | Set if this is a web asset.+    web :: (Core.Maybe WebAsset)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'Asset' with the minimum fields required to make a request.+newAsset ::+  Asset+newAsset = Asset {androidApp = Core.Nothing, web = Core.Nothing}++instance Core.FromJSON Asset where+  parseJSON =+    Core.withObject+      "Asset"+      ( \o ->+          Asset+            Core.<$> (o Core..:? "androidApp")+            Core.<*> (o Core..:? "web")+      )++instance Core.ToJSON Asset where+  toJSON Asset {..} =+    Core.object+      ( Core.catMaybes+          [ ("androidApp" Core..=) Core.<$> androidApp,+            ("web" Core..=) Core.<$> web+          ]+      )++-- | Message used to check for the existence of multiple digital asset links within a single RPC.+--+-- /See:/ 'newBulkCheckRequest' smart constructor.+data BulkCheckRequest = BulkCheckRequest+  { -- | If specified, will be used in any given template statement that doesn’t specify a relation.+    defaultRelation :: (Core.Maybe Core.Text),+    -- | If specified, will be used in any given template statement that doesn’t specify a source.+    defaultSource :: (Core.Maybe Asset),+    -- | If specified, will be used in any given template statement that doesn’t specify a target.+    defaultTarget :: (Core.Maybe Asset),+    -- | List of statements to check. For each statement, you can omit a field if the corresponding default_* field below was supplied. Minimum 1 statement; maximum 1,000 statements. Any additional statements will be ignored.+    statements :: (Core.Maybe [StatementTemplate])+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'BulkCheckRequest' with the minimum fields required to make a request.+newBulkCheckRequest ::+  BulkCheckRequest+newBulkCheckRequest =+  BulkCheckRequest+    { defaultRelation = Core.Nothing,+      defaultSource = Core.Nothing,+      defaultTarget = Core.Nothing,+      statements = Core.Nothing+    }++instance Core.FromJSON BulkCheckRequest where+  parseJSON =+    Core.withObject+      "BulkCheckRequest"+      ( \o ->+          BulkCheckRequest+            Core.<$> (o Core..:? "defaultRelation")+            Core.<*> (o Core..:? "defaultSource")+            Core.<*> (o Core..:? "defaultTarget")+            Core.<*> (o Core..:? "statements")+      )++instance Core.ToJSON BulkCheckRequest where+  toJSON BulkCheckRequest {..} =+    Core.object+      ( Core.catMaybes+          [ ("defaultRelation" Core..=) Core.<$> defaultRelation,+            ("defaultSource" Core..=) Core.<$> defaultSource,+            ("defaultTarget" Core..=) Core.<$> defaultTarget,+            ("statements" Core..=) Core.<$> statements+          ]+      )++-- | Response for BulkCheck call. Results are sent in a list in the same order in which they were sent. Individual check errors are described in the appropriate check/results entry. If the entire call fails, the response will include a bulk/error_code field describing the error.+--+-- /See:/ 'newBulkCheckResponse' smart constructor.+data BulkCheckResponse = BulkCheckResponse+  { -- | Error code for the entire request. Present only if the entire request failed. Individual check errors will not trigger the presence of this field.+    bulkErrorCode :: (Core.Maybe BulkCheckResponse_BulkErrorCode),+    -- | List of results for each check request. Results are returned in the same order in which they were sent in the request.+    checkResults :: (Core.Maybe [CheckResponse])+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'BulkCheckResponse' with the minimum fields required to make a request.+newBulkCheckResponse ::+  BulkCheckResponse+newBulkCheckResponse =+  BulkCheckResponse+    { bulkErrorCode = Core.Nothing,+      checkResults = Core.Nothing+    }++instance Core.FromJSON BulkCheckResponse where+  parseJSON =+    Core.withObject+      "BulkCheckResponse"+      ( \o ->+          BulkCheckResponse+            Core.<$> (o Core..:? "bulkErrorCode")+            Core.<*> (o Core..:? "checkResults")+      )++instance Core.ToJSON BulkCheckResponse where+  toJSON BulkCheckResponse {..} =+    Core.object+      ( Core.catMaybes+          [ ("bulkErrorCode" Core..=) Core.<$> bulkErrorCode,+            ("checkResults" Core..=) Core.<$> checkResults+          ]+      )++-- | Describes an X509 certificate.+--+-- /See:/ 'newCertificateInfo' smart constructor.+newtype CertificateInfo = CertificateInfo+  { -- | The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be @14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5@. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).+    sha256Fingerprint :: (Core.Maybe Core.Text)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'CertificateInfo' with the minimum fields required to make a request.+newCertificateInfo ::+  CertificateInfo+newCertificateInfo =+  CertificateInfo {sha256Fingerprint = Core.Nothing}++instance Core.FromJSON CertificateInfo where+  parseJSON =+    Core.withObject+      "CertificateInfo"+      (\o -> CertificateInfo Core.<$> (o Core..:? "sha256Fingerprint"))++instance Core.ToJSON CertificateInfo where+  toJSON CertificateInfo {..} =+    Core.object+      ( Core.catMaybes+          [("sha256Fingerprint" Core..=) Core.<$> sha256Fingerprint]+      )++-- | Response message for the CheckAssetLinks call.+--+-- /See:/ 'newCheckResponse' smart constructor.+data CheckResponse = CheckResponse+  { -- | Human-readable message containing information intended to help end users understand, reproduce and debug the result. The message will be in English and we are currently not planning to offer any translations. Please note that no guarantees are made about the contents or format of this string. Any aspect of it may be subject to change without notice. You should not attempt to programmatically parse this data. For programmatic access, use the error_code field below.+    debugString :: (Core.Maybe Core.Text),+    -- | Error codes that describe the result of the Check operation.+    errorCode :: (Core.Maybe [CheckResponse_ErrorCodeItem]),+    -- | Set to true if the assets specified in the request are linked by the relation specified in the request.+    linked :: (Core.Maybe Core.Bool),+    -- | From serving time, how much longer the response should be considered valid barring further updates. REQUIRED+    maxAge :: (Core.Maybe Core.Duration)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'CheckResponse' with the minimum fields required to make a request.+newCheckResponse ::+  CheckResponse+newCheckResponse =+  CheckResponse+    { debugString = Core.Nothing,+      errorCode = Core.Nothing,+      linked = Core.Nothing,+      maxAge = Core.Nothing+    }++instance Core.FromJSON CheckResponse where+  parseJSON =+    Core.withObject+      "CheckResponse"+      ( \o ->+          CheckResponse+            Core.<$> (o Core..:? "debugString")+            Core.<*> (o Core..:? "errorCode")+            Core.<*> (o Core..:? "linked")+            Core.<*> (o Core..:? "maxAge")+      )++instance Core.ToJSON CheckResponse where+  toJSON CheckResponse {..} =+    Core.object+      ( Core.catMaybes+          [ ("debugString" Core..=) Core.<$> debugString,+            ("errorCode" Core..=) Core.<$> errorCode,+            ("linked" Core..=) Core.<$> linked,+            ("maxAge" Core..=) Core.<$> maxAge+          ]+      )++-- | Response message for the List call.+--+-- /See:/ 'newListResponse' smart constructor.+data ListResponse = ListResponse+  { -- | Human-readable message containing information intended to help end users understand, reproduce and debug the result. The message will be in English and we are currently not planning to offer any translations. Please note that no guarantees are made about the contents or format of this string. Any aspect of it may be subject to change without notice. You should not attempt to programmatically parse this data. For programmatic access, use the error_code field below.+    debugString :: (Core.Maybe Core.Text),+    -- | Error codes that describe the result of the List operation.+    errorCode :: (Core.Maybe [ListResponse_ErrorCodeItem]),+    -- | From serving time, how much longer the response should be considered valid barring further updates. REQUIRED+    maxAge :: (Core.Maybe Core.Duration),+    -- | A list of all the matching statements that have been found.+    statements :: (Core.Maybe [Statement])+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'ListResponse' with the minimum fields required to make a request.+newListResponse ::+  ListResponse+newListResponse =+  ListResponse+    { debugString = Core.Nothing,+      errorCode = Core.Nothing,+      maxAge = Core.Nothing,+      statements = Core.Nothing+    }++instance Core.FromJSON ListResponse where+  parseJSON =+    Core.withObject+      "ListResponse"+      ( \o ->+          ListResponse+            Core.<$> (o Core..:? "debugString")+            Core.<*> (o Core..:? "errorCode")+            Core.<*> (o Core..:? "maxAge")+            Core.<*> (o Core..:? "statements")+      )++instance Core.ToJSON ListResponse where+  toJSON ListResponse {..} =+    Core.object+      ( Core.catMaybes+          [ ("debugString" Core..=) Core.<$> debugString,+            ("errorCode" Core..=) Core.<$> errorCode,+            ("maxAge" Core..=) Core.<$> maxAge,+            ("statements" Core..=) Core.<$> statements+          ]+      )++-- | Describes a reliable statement that has been made about the relationship between a source asset and a target asset. Statements are always made by the source asset, either directly or by delegating to a statement list that is stored elsewhere. For more detailed definitions of statements and assets, please refer to our </digital-asset-links/v1/getting-started API documentation landing page>.+--+-- /See:/ 'newStatement' smart constructor.+data Statement = Statement+  { -- | The relation identifies the use of the statement as intended by the source asset\'s owner (that is, the person or entity who issued the statement). Every complete statement has a relation. We identify relations with strings of the format @\/@, where @must be one of a set of pre-defined purpose categories, and@ is a free-form lowercase alphanumeric string that describes the specific use case of the statement. Refer to </digital-asset-links/v1/relation-strings our API documentation> for the current list of supported relations. Example: @delegate_permission\/common.handle_all_urls@ REQUIRED+    relation :: (Core.Maybe Core.Text),+    -- | Every statement has a source asset. REQUIRED+    source :: (Core.Maybe Asset),+    -- | Every statement has a target asset. REQUIRED+    target :: (Core.Maybe Asset)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'Statement' with the minimum fields required to make a request.+newStatement ::+  Statement+newStatement =+  Statement+    { relation = Core.Nothing,+      source = Core.Nothing,+      target = Core.Nothing+    }++instance Core.FromJSON Statement where+  parseJSON =+    Core.withObject+      "Statement"+      ( \o ->+          Statement+            Core.<$> (o Core..:? "relation")+            Core.<*> (o Core..:? "source")+            Core.<*> (o Core..:? "target")+      )++instance Core.ToJSON Statement where+  toJSON Statement {..} =+    Core.object+      ( Core.catMaybes+          [ ("relation" Core..=) Core.<$> relation,+            ("source" Core..=) Core.<$> source,+            ("target" Core..=) Core.<$> target+          ]+      )++-- | A single statement to check in a bulk call using BulkCheck. See CheckRequest for details about each field.+--+-- /See:/ 'newStatementTemplate' smart constructor.+data StatementTemplate = StatementTemplate+  { -- | The relationship being asserted between the source and target. If omitted, you must specify a BulkCheckRequest.default_relation value to use here.+    relation :: (Core.Maybe Core.Text),+    -- | The source asset that is asserting the statement. If omitted, you must specify a BulkCheckRequest.default_source value to use here.+    source :: (Core.Maybe Asset),+    -- | The target that the source is declaring the relationship with. If omitted, you must specify a BulkCheckRequest.default_target to use here.+    target :: (Core.Maybe Asset)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'StatementTemplate' with the minimum fields required to make a request.+newStatementTemplate ::+  StatementTemplate+newStatementTemplate =+  StatementTemplate+    { relation = Core.Nothing,+      source = Core.Nothing,+      target = Core.Nothing+    }++instance Core.FromJSON StatementTemplate where+  parseJSON =+    Core.withObject+      "StatementTemplate"+      ( \o ->+          StatementTemplate+            Core.<$> (o Core..:? "relation")+            Core.<*> (o Core..:? "source")+            Core.<*> (o Core..:? "target")+      )++instance Core.ToJSON StatementTemplate where+  toJSON StatementTemplate {..} =+    Core.object+      ( Core.catMaybes+          [ ("relation" Core..=) Core.<$> relation,+            ("source" Core..=) Core.<$> source,+            ("target" Core..=) Core.<$> target+          ]+      )++-- | Describes a web asset.+--+-- /See:/ 'newWebAsset' smart constructor.+newtype WebAsset = WebAsset+  { -- | Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be fully qualified: they must end in a single period (\"@.@\"). Only the schemes \"http\" and \"https\" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the \"site\". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site @https:\/\/www.google.com@ contains all these URLs: * @https:\/\/www.google.com\/@ * @https:\/\/www.google.com:443\/@ * @https:\/\/www.google.com\/foo@ * @https:\/\/www.google.com\/foo?bar@ * @https:\/\/www.google.com\/foo#bar@ * @https:\/\/user\@password:www.google.com\/@ But it does not contain these URLs: * @http:\/\/www.google.com\/@ (wrong scheme) * @https:\/\/google.com\/@ (hostname does not match) *+    -- @https:\/\/www.google.com:444\/@ (port does not match) REQUIRED+    site :: (Core.Maybe Core.Text)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'WebAsset' with the minimum fields required to make a request.+newWebAsset ::+  WebAsset+newWebAsset = WebAsset {site = Core.Nothing}++instance Core.FromJSON WebAsset where+  parseJSON =+    Core.withObject+      "WebAsset"+      (\o -> WebAsset Core.<$> (o Core..:? "site"))++instance Core.ToJSON WebAsset where+  toJSON WebAsset {..} =+    Core.object (Core.catMaybes [("site" Core..=) Core.<$> site])

@@ -0,0 +1,325 @@+{-# 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.DigitalAssetLinks.Internal.Sum+-- 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.DigitalAssetLinks.Internal.Sum+  ( -- * Xgafv+    Xgafv+      ( Xgafv_1,+        Xgafv_2,+        ..+      ),++    -- * BulkCheckResponse_BulkErrorCode+    BulkCheckResponse_BulkErrorCode+      ( BulkCheckResponse_BulkErrorCode_ERRORCODEUNSPECIFIED,+        BulkCheckResponse_BulkErrorCode_ERRORCODEINVALIDQUERY,+        BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHERROR,+        BulkCheckResponse_BulkErrorCode_ERRORCODEFAILEDSSLVALIDATION,+        BulkCheckResponse_BulkErrorCode_ERRORCODEREDIRECT,+        BulkCheckResponse_BulkErrorCode_ERRORCODETOOLARGE,+        BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDHTTPRESPONSE,+        BulkCheckResponse_BulkErrorCode_ERRORCODEWRONGCONTENTTYPE,+        BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDCONTENT,+        BulkCheckResponse_BulkErrorCode_ERRORCODESECUREASSETINCLUDESINSECURE,+        BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHBUDGETEXHAUSTED,+        ..+      ),++    -- * CheckResponse_ErrorCodeItem+    CheckResponse_ErrorCodeItem+      ( CheckResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED,+        CheckResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY,+        CheckResponse_ErrorCodeItem_ERRORCODEFETCHERROR,+        CheckResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION,+        CheckResponse_ErrorCodeItem_ERRORCODEREDIRECT,+        CheckResponse_ErrorCodeItem_ERRORCODETOOLARGE,+        CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE,+        CheckResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE,+        CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT,+        CheckResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE,+        CheckResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED,+        ..+      ),++    -- * ListResponse_ErrorCodeItem+    ListResponse_ErrorCodeItem+      ( ListResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED,+        ListResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY,+        ListResponse_ErrorCodeItem_ERRORCODEFETCHERROR,+        ListResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION,+        ListResponse_ErrorCodeItem_ERRORCODEREDIRECT,+        ListResponse_ErrorCodeItem_ERRORCODETOOLARGE,+        ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE,+        ListResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE,+        ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT,+        ListResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE,+        ListResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED,+        ..+      ),+  )+where++import Gogol.Prelude qualified as Core++-- | V1 error format.+newtype Xgafv = Xgafv {fromXgafv :: Core.Text}+  deriving stock (Core.Show, Core.Read, Core.Eq, Core.Ord, Core.Generic)+  deriving newtype+    ( Core.Hashable,+      Core.ToHttpApiData,+      Core.FromHttpApiData,+      Core.ToJSON,+      Core.ToJSONKey,+      Core.FromJSON,+      Core.FromJSONKey+    )++-- | v1 error format+pattern Xgafv_1 :: Xgafv+pattern Xgafv_1 = Xgafv "1"++-- | v2 error format+pattern Xgafv_2 :: Xgafv+pattern Xgafv_2 = Xgafv "2"++{-# COMPLETE+  Xgafv_1,+  Xgafv_2,+  Xgafv+  #-}++-- | Error code for the entire request. Present only if the entire request failed. Individual check errors will not trigger the presence of this field.+newtype BulkCheckResponse_BulkErrorCode = BulkCheckResponse_BulkErrorCode {fromBulkCheckResponse_BulkErrorCode :: Core.Text}+  deriving stock (Core.Show, Core.Read, Core.Eq, Core.Ord, Core.Generic)+  deriving newtype+    ( Core.Hashable,+      Core.ToHttpApiData,+      Core.FromHttpApiData,+      Core.ToJSON,+      Core.ToJSONKey,+      Core.FromJSON,+      Core.FromJSONKey+    )++-- | Default value, otherwise unused.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEUNSPECIFIED :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEUNSPECIFIED = BulkCheckResponse_BulkErrorCode "ERROR_CODE_UNSPECIFIED"++-- | Unable to parse query.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEINVALIDQUERY :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEINVALIDQUERY = BulkCheckResponse_BulkErrorCode "ERROR_CODE_INVALID_QUERY"++-- | Unable to fetch the asset links data.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHERROR :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHERROR = BulkCheckResponse_BulkErrorCode "ERROR_CODE_FETCH_ERROR"++-- | Invalid HTTPS certificate .+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEFAILEDSSLVALIDATION :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEFAILEDSSLVALIDATION = BulkCheckResponse_BulkErrorCode "ERROR_CODE_FAILED_SSL_VALIDATION"++-- | HTTP redirects (e.g, 301) are not allowed.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEREDIRECT :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEREDIRECT = BulkCheckResponse_BulkErrorCode "ERROR_CODE_REDIRECT"++-- | Asset links data exceeds maximum size.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODETOOLARGE :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODETOOLARGE = BulkCheckResponse_BulkErrorCode "ERROR_CODE_TOO_LARGE"++-- | Can\'t parse HTTP response.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDHTTPRESPONSE :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDHTTPRESPONSE = BulkCheckResponse_BulkErrorCode "ERROR_CODE_MALFORMED_HTTP_RESPONSE"++-- | HTTP Content-type should be application\/json.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEWRONGCONTENTTYPE :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEWRONGCONTENTTYPE = BulkCheckResponse_BulkErrorCode "ERROR_CODE_WRONG_CONTENT_TYPE"++-- | JSON content is malformed.+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDCONTENT :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDCONTENT = BulkCheckResponse_BulkErrorCode "ERROR_CODE_MALFORMED_CONTENT"++-- | A secure asset includes an insecure asset (security downgrade).+pattern BulkCheckResponse_BulkErrorCode_ERRORCODESECUREASSETINCLUDESINSECURE :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODESECUREASSETINCLUDESINSECURE = BulkCheckResponse_BulkErrorCode "ERROR_CODE_SECURE_ASSET_INCLUDES_INSECURE"++-- | Too many includes (maybe a loop).+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHBUDGETEXHAUSTED :: BulkCheckResponse_BulkErrorCode+pattern BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHBUDGETEXHAUSTED = BulkCheckResponse_BulkErrorCode "ERROR_CODE_FETCH_BUDGET_EXHAUSTED"++{-# COMPLETE+  BulkCheckResponse_BulkErrorCode_ERRORCODEUNSPECIFIED,+  BulkCheckResponse_BulkErrorCode_ERRORCODEINVALIDQUERY,+  BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHERROR,+  BulkCheckResponse_BulkErrorCode_ERRORCODEFAILEDSSLVALIDATION,+  BulkCheckResponse_BulkErrorCode_ERRORCODEREDIRECT,+  BulkCheckResponse_BulkErrorCode_ERRORCODETOOLARGE,+  BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDHTTPRESPONSE,+  BulkCheckResponse_BulkErrorCode_ERRORCODEWRONGCONTENTTYPE,+  BulkCheckResponse_BulkErrorCode_ERRORCODEMALFORMEDCONTENT,+  BulkCheckResponse_BulkErrorCode_ERRORCODESECUREASSETINCLUDESINSECURE,+  BulkCheckResponse_BulkErrorCode_ERRORCODEFETCHBUDGETEXHAUSTED,+  BulkCheckResponse_BulkErrorCode+  #-}++newtype CheckResponse_ErrorCodeItem = CheckResponse_ErrorCodeItem {fromCheckResponse_ErrorCodeItem :: Core.Text}+  deriving stock (Core.Show, Core.Read, Core.Eq, Core.Ord, Core.Generic)+  deriving newtype+    ( Core.Hashable,+      Core.ToHttpApiData,+      Core.FromHttpApiData,+      Core.ToJSON,+      Core.ToJSONKey,+      Core.FromJSON,+      Core.FromJSONKey+    )++-- | Default value, otherwise unused.+pattern CheckResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED = CheckResponse_ErrorCodeItem "ERROR_CODE_UNSPECIFIED"++-- | Unable to parse query.+pattern CheckResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY = CheckResponse_ErrorCodeItem "ERROR_CODE_INVALID_QUERY"++-- | Unable to fetch the asset links data.+pattern CheckResponse_ErrorCodeItem_ERRORCODEFETCHERROR :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEFETCHERROR = CheckResponse_ErrorCodeItem "ERROR_CODE_FETCH_ERROR"++-- | Invalid HTTPS certificate .+pattern CheckResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION = CheckResponse_ErrorCodeItem "ERROR_CODE_FAILED_SSL_VALIDATION"++-- | HTTP redirects (e.g, 301) are not allowed.+pattern CheckResponse_ErrorCodeItem_ERRORCODEREDIRECT :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEREDIRECT = CheckResponse_ErrorCodeItem "ERROR_CODE_REDIRECT"++-- | Asset links data exceeds maximum size.+pattern CheckResponse_ErrorCodeItem_ERRORCODETOOLARGE :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODETOOLARGE = CheckResponse_ErrorCodeItem "ERROR_CODE_TOO_LARGE"++-- | Can\'t parse HTTP response.+pattern CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE = CheckResponse_ErrorCodeItem "ERROR_CODE_MALFORMED_HTTP_RESPONSE"++-- | HTTP Content-type should be application\/json.+pattern CheckResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE = CheckResponse_ErrorCodeItem "ERROR_CODE_WRONG_CONTENT_TYPE"++-- | JSON content is malformed.+pattern CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT = CheckResponse_ErrorCodeItem "ERROR_CODE_MALFORMED_CONTENT"++-- | A secure asset includes an insecure asset (security downgrade).+pattern CheckResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE = CheckResponse_ErrorCodeItem "ERROR_CODE_SECURE_ASSET_INCLUDES_INSECURE"++-- | Too many includes (maybe a loop).+pattern CheckResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED :: CheckResponse_ErrorCodeItem+pattern CheckResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED = CheckResponse_ErrorCodeItem "ERROR_CODE_FETCH_BUDGET_EXHAUSTED"++{-# COMPLETE+  CheckResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED,+  CheckResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY,+  CheckResponse_ErrorCodeItem_ERRORCODEFETCHERROR,+  CheckResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION,+  CheckResponse_ErrorCodeItem_ERRORCODEREDIRECT,+  CheckResponse_ErrorCodeItem_ERRORCODETOOLARGE,+  CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE,+  CheckResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE,+  CheckResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT,+  CheckResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE,+  CheckResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED,+  CheckResponse_ErrorCodeItem+  #-}++newtype ListResponse_ErrorCodeItem = ListResponse_ErrorCodeItem {fromListResponse_ErrorCodeItem :: Core.Text}+  deriving stock (Core.Show, Core.Read, Core.Eq, Core.Ord, Core.Generic)+  deriving newtype+    ( Core.Hashable,+      Core.ToHttpApiData,+      Core.FromHttpApiData,+      Core.ToJSON,+      Core.ToJSONKey,+      Core.FromJSON,+      Core.FromJSONKey+    )++-- | Default value, otherwise unused.+pattern ListResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED = ListResponse_ErrorCodeItem "ERROR_CODE_UNSPECIFIED"++-- | Unable to parse query.+pattern ListResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY = ListResponse_ErrorCodeItem "ERROR_CODE_INVALID_QUERY"++-- | Unable to fetch the asset links data.+pattern ListResponse_ErrorCodeItem_ERRORCODEFETCHERROR :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEFETCHERROR = ListResponse_ErrorCodeItem "ERROR_CODE_FETCH_ERROR"++-- | Invalid HTTPS certificate .+pattern ListResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION = ListResponse_ErrorCodeItem "ERROR_CODE_FAILED_SSL_VALIDATION"++-- | HTTP redirects (e.g, 301) are not allowed.+pattern ListResponse_ErrorCodeItem_ERRORCODEREDIRECT :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEREDIRECT = ListResponse_ErrorCodeItem "ERROR_CODE_REDIRECT"++-- | Asset links data exceeds maximum size.+pattern ListResponse_ErrorCodeItem_ERRORCODETOOLARGE :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODETOOLARGE = ListResponse_ErrorCodeItem "ERROR_CODE_TOO_LARGE"++-- | Can\'t parse HTTP response.+pattern ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE = ListResponse_ErrorCodeItem "ERROR_CODE_MALFORMED_HTTP_RESPONSE"++-- | HTTP Content-type should be application\/json.+pattern ListResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE = ListResponse_ErrorCodeItem "ERROR_CODE_WRONG_CONTENT_TYPE"++-- | JSON content is malformed.+pattern ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT = ListResponse_ErrorCodeItem "ERROR_CODE_MALFORMED_CONTENT"++-- | A secure asset includes an insecure asset (security downgrade).+pattern ListResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE = ListResponse_ErrorCodeItem "ERROR_CODE_SECURE_ASSET_INCLUDES_INSECURE"++-- | Too many includes (maybe a loop).+pattern ListResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED :: ListResponse_ErrorCodeItem+pattern ListResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED = ListResponse_ErrorCodeItem "ERROR_CODE_FETCH_BUDGET_EXHAUSTED"++{-# COMPLETE+  ListResponse_ErrorCodeItem_ERRORCODEUNSPECIFIED,+  ListResponse_ErrorCodeItem_ERRORCODEINVALIDQUERY,+  ListResponse_ErrorCodeItem_ERRORCODEFETCHERROR,+  ListResponse_ErrorCodeItem_ERRORCODEFAILEDSSLVALIDATION,+  ListResponse_ErrorCodeItem_ERRORCODEREDIRECT,+  ListResponse_ErrorCodeItem_ERRORCODETOOLARGE,+  ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDHTTPRESPONSE,+  ListResponse_ErrorCodeItem_ERRORCODEWRONGCONTENTTYPE,+  ListResponse_ErrorCodeItem_ERRORCODEMALFORMEDCONTENT,+  ListResponse_ErrorCodeItem_ERRORCODESECUREASSETINCLUDESINSECURE,+  ListResponse_ErrorCodeItem_ERRORCODEFETCHBUDGETEXHAUSTED,+  ListResponse_ErrorCodeItem+  #-}

@@ -0,0 +1,124 @@+{-# 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.DigitalAssetLinks.Statements.List+-- 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)+--+-- Retrieves a list of all statements from a given source that match the specified target and statement string. The API guarantees that all statements with secure source assets, such as HTTPS websites or Android apps, have been made in a secure way by the owner of those assets, as described in the <https://github.com/google/digitalassetlinks/blob/master/well-known/details.md Digital Asset Links technical design specification>. Specifically, you should consider that for insecure websites (that is, where the URL starts with @http:\/\/@ instead of @https:\/\/@), this guarantee cannot be made. The @List@ command is most useful in cases where the API client wants to know all the ways in which two assets are related, or enumerate all the relationships from a particular source asset. Example: a feature that helps users navigate to related items. When a mobile app is running on a device, the feature would make it easy to navigate to the corresponding web site or Google+ profile.+--+-- /See:/ <https://developers.google.com/digital-asset-links/ Digital Asset Links API Reference> for @digitalassetlinks.statements.list@.+module Gogol.DigitalAssetLinks.Statements.List+  ( -- * Resource+    DigitalAssetLinksStatementsListResource,++    -- ** Constructing a Request+    DigitalAssetLinksStatementsList (..),+    newDigitalAssetLinksStatementsList,+  )+where++import Gogol.DigitalAssetLinks.Types+import Gogol.Prelude qualified as Core++-- | A resource alias for @digitalassetlinks.statements.list@ method which the+-- 'DigitalAssetLinksStatementsList' request conforms to.+type DigitalAssetLinksStatementsListResource =+  "v1"+    Core.:> "statements:list"+    Core.:> Core.QueryParam "$.xgafv" Xgafv+    Core.:> Core.QueryParam "access_token" Core.Text+    Core.:> Core.QueryParam "callback" Core.Text+    Core.:> Core.QueryParam "relation" Core.Text+    Core.:> Core.QueryParam+              "source.androidApp.certificate.sha256Fingerprint"+              Core.Text+    Core.:> Core.QueryParam "source.androidApp.packageName" Core.Text+    Core.:> Core.QueryParam "source.web.site" Core.Text+    Core.:> Core.QueryParam "uploadType" Core.Text+    Core.:> Core.QueryParam "upload_protocol" Core.Text+    Core.:> Core.QueryParam "alt" Core.AltJSON+    Core.:> Core.Get '[Core.JSON] ListResponse++-- | Retrieves a list of all statements from a given source that match the specified target and statement string. The API guarantees that all statements with secure source assets, such as HTTPS websites or Android apps, have been made in a secure way by the owner of those assets, as described in the <https://github.com/google/digitalassetlinks/blob/master/well-known/details.md Digital Asset Links technical design specification>. Specifically, you should consider that for insecure websites (that is, where the URL starts with @http:\/\/@ instead of @https:\/\/@), this guarantee cannot be made. The @List@ command is most useful in cases where the API client wants to know all the ways in which two assets are related, or enumerate all the relationships from a particular source asset. Example: a feature that helps users navigate to related items. When a mobile app is running on a device, the feature would make it easy to navigate to the corresponding web site or Google+ profile.+--+-- /See:/ 'newDigitalAssetLinksStatementsList' smart constructor.+data DigitalAssetLinksStatementsList = DigitalAssetLinksStatementsList+  { -- | V1 error format.+    xgafv :: (Core.Maybe Xgafv),+    -- | OAuth access token.+    accessToken :: (Core.Maybe Core.Text),+    -- | JSONP+    callback :: (Core.Maybe Core.Text),+    -- | Use only associations that match the specified relation. See the <#Statement Statement> message for a detailed definition of relation strings. For a query to match a statement, one of the following must be true: * both the query\'s and the statement\'s relation strings match exactly, or * the query\'s relation string is empty or missing. Example: A query with relation @delegate_permission\/common.handle_all_urls@ matches an asset link with relation @delegate_permission\/common.handle_all_urls@.+    relation :: (Core.Maybe Core.Text),+    -- | The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be @14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5@. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).+    sourceAndroidAppCertificateSha256Fingerprint :: (Core.Maybe Core.Text),+    -- | Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name @com.google.android.apps.maps@. REQUIRED+    sourceAndroidAppPackageName :: (Core.Maybe Core.Text),+    -- | Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be fully qualified: they must end in a single period (\"@.@\"). Only the schemes \"http\" and \"https\" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the \"site\". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site @https:\/\/www.google.com@ contains all these URLs: * @https:\/\/www.google.com\/@ * @https:\/\/www.google.com:443\/@ * @https:\/\/www.google.com\/foo@ * @https:\/\/www.google.com\/foo?bar@ * @https:\/\/www.google.com\/foo#bar@ * @https:\/\/user\@password:www.google.com\/@ But it does not contain these URLs: * @http:\/\/www.google.com\/@ (wrong scheme) * @https:\/\/google.com\/@ (hostname does not match) *+    -- @https:\/\/www.google.com:444\/@ (port does not match) REQUIRED+    sourceWebSite :: (Core.Maybe Core.Text),+    -- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").+    uploadType :: (Core.Maybe Core.Text),+    -- | Upload protocol for media (e.g. \"raw\", \"multipart\").+    uploadProtocol :: (Core.Maybe Core.Text)+  }+  deriving (Core.Eq, Core.Show, Core.Generic)++-- | Creates a value of 'DigitalAssetLinksStatementsList' with the minimum fields required to make a request.+newDigitalAssetLinksStatementsList ::+  DigitalAssetLinksStatementsList+newDigitalAssetLinksStatementsList =+  DigitalAssetLinksStatementsList+    { xgafv = Core.Nothing,+      accessToken = Core.Nothing,+      callback = Core.Nothing,+      relation = Core.Nothing,+      sourceAndroidAppCertificateSha256Fingerprint = Core.Nothing,+      sourceAndroidAppPackageName = Core.Nothing,+      sourceWebSite = Core.Nothing,+      uploadType = Core.Nothing,+      uploadProtocol = Core.Nothing+    }++instance Core.GoogleRequest DigitalAssetLinksStatementsList where+  type Rs DigitalAssetLinksStatementsList = ListResponse+  type Scopes DigitalAssetLinksStatementsList = '[]+  requestClient DigitalAssetLinksStatementsList {..} =+    go+      xgafv+      accessToken+      callback+      relation+      sourceAndroidAppCertificateSha256Fingerprint+      sourceAndroidAppPackageName+      sourceWebSite+      uploadType+      uploadProtocol+      (Core.Just Core.AltJSON)+      digitalAssetLinksService+    where+      go =+        Core.buildClient+          (Core.Proxy :: Core.Proxy DigitalAssetLinksStatementsListResource)+          Core.mempty

@@ -0,0 +1,95 @@+{-# 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.DigitalAssetLinks.Types+-- 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.DigitalAssetLinks.Types+  ( -- * Configuration+    digitalAssetLinksService,++    -- * Types++    -- ** Xgafv+    Xgafv (..),++    -- ** AndroidAppAsset+    AndroidAppAsset (..),+    newAndroidAppAsset,++    -- ** Asset+    Asset (..),+    newAsset,++    -- ** BulkCheckRequest+    BulkCheckRequest (..),+    newBulkCheckRequest,++    -- ** BulkCheckResponse+    BulkCheckResponse (..),+    newBulkCheckResponse,++    -- ** BulkCheckResponse_BulkErrorCode+    BulkCheckResponse_BulkErrorCode (..),++    -- ** CertificateInfo+    CertificateInfo (..),+    newCertificateInfo,++    -- ** CheckResponse+    CheckResponse (..),+    newCheckResponse,++    -- ** CheckResponse_ErrorCodeItem+    CheckResponse_ErrorCodeItem (..),++    -- ** ListResponse+    ListResponse (..),+    newListResponse,++    -- ** ListResponse_ErrorCodeItem+    ListResponse_ErrorCodeItem (..),++    -- ** Statement+    Statement (..),+    newStatement,++    -- ** StatementTemplate+    StatementTemplate (..),+    newStatementTemplate,++    -- ** WebAsset+    WebAsset (..),+    newWebAsset,+  )+where++import Gogol.DigitalAssetLinks.Internal.Product+import Gogol.DigitalAssetLinks.Internal.Sum+import Gogol.Prelude qualified as Core++-- | Default request referring to version @v1@ of the Digital Asset Links API. This contains the host and root path used as a starting point for constructing service requests.+digitalAssetLinksService :: Core.ServiceConfig+digitalAssetLinksService =+  Core.defaultService+    (Core.ServiceId "digitalassetlinks:v1")+    "digitalassetlinks.googleapis.com"

@@ -1,98 +0,0 @@-{-# LANGUAGE DataKinds         #-}-{-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE TypeOperators     #-}--{-# OPTIONS_GHC -fno-warn-unused-imports    #-}-{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}---- |--- Module      : Network.Google.DigitalAssetLinks--- Copyright   : (c) 2015-2016 Brendan Hay--- License     : Mozilla Public License, v. 2.0.--- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>--- Stability   : auto-generated--- Portability : non-portable (GHC extensions)------ Discovers relationships between online assets such as websites or mobile--- apps.------ /See:/ <https://developers.google.com/digital-asset-links/ Digital Asset Links API Reference>-module Network.Google.DigitalAssetLinks-    (-    -- * Service Configuration-      digitalAssetLinksService--    -- * API Declaration-    , DigitalAssetLinksAPI--    -- * Resources--    -- ** digitalassetlinks.assetlinks.check-    , module Network.Google.Resource.DigitalAssetLinks.Assetlinks.Check--    -- ** digitalassetlinks.statements.list-    , module Network.Google.Resource.DigitalAssetLinks.Statements.List--    -- * Types--    -- ** AndroidAppAsset-    , AndroidAppAsset-    , androidAppAsset-    , aaaPackageName-    , aaaCertificate--    -- ** Statement-    , Statement-    , statement-    , sRelation-    , sSource-    , sTarget--    -- ** Asset-    , Asset-    , asset-    , aAndroidApp-    , aWeb--    -- ** ListResponse-    , ListResponse-    , listResponse-    , lrDebugString-    , lrMaxAge-    , lrErrorCode-    , lrStatements--    -- ** Xgafv-    , Xgafv (..)--    -- ** CheckResponse-    , CheckResponse-    , checkResponse-    , crDebugString-    , crMaxAge-    , crErrorCode-    , crLinked--    -- ** WebAsset-    , WebAsset-    , webAsset-    , waSite--    -- ** CertificateInfo-    , CertificateInfo-    , certificateInfo-    , ciSha256Fingerprint-    ) where--import           Network.Google.DigitalAssetLinks.Types-import           Network.Google.Prelude-import           Network.Google.Resource.DigitalAssetLinks.Assetlinks.Check-import           Network.Google.Resource.DigitalAssetLinks.Statements.List--{- $resources-TODO--}---- | Represents the entirety of the methods and resources available for the Digital Asset Links API service.-type DigitalAssetLinksAPI =-     AssetlinksCheckResource :<|> StatementsListResource

@@ -1,79 +0,0 @@-{-# LANGUAGE DataKinds          #-}-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveGeneric      #-}-{-# LANGUAGE NoImplicitPrelude  #-}-{-# LANGUAGE OverloadedStrings  #-}--{-# OPTIONS_GHC -fno-warn-unused-imports #-}---- |--- Module      : Network.Google.DigitalAssetLinks.Types--- Copyright   : (c) 2015-2016 Brendan Hay--- License     : Mozilla Public License, v. 2.0.--- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>--- Stability   : auto-generated--- Portability : non-portable (GHC extensions)----module Network.Google.DigitalAssetLinks.Types-    (-    -- * Service Configuration-      digitalAssetLinksService--    -- * AndroidAppAsset-    , AndroidAppAsset-    , androidAppAsset-    , aaaPackageName-    , aaaCertificate--    -- * Statement-    , Statement-    , statement-    , sRelation-    , sSource-    , sTarget--    -- * Asset-    , Asset-    , asset-    , aAndroidApp-    , aWeb--    -- * ListResponse-    , ListResponse-    , listResponse-    , lrDebugString-    , lrMaxAge-    , lrErrorCode-    , lrStatements--    -- * Xgafv-    , Xgafv (..)--    -- * CheckResponse-    , CheckResponse-    , checkResponse-    , crDebugString-    , crMaxAge-    , crErrorCode-    , crLinked--    -- * WebAsset-    , WebAsset-    , webAsset-    , waSite--    -- * CertificateInfo-    , CertificateInfo-    , certificateInfo-    , ciSha256Fingerprint-    ) where--import           Network.Google.DigitalAssetLinks.Types.Product-import           Network.Google.DigitalAssetLinks.Types.Sum-import           Network.Google.Prelude---- | Default request referring to version 'v1' of the Digital Asset Links API. This contains the host and root path used as a starting point for constructing service requests.-digitalAssetLinksService :: ServiceConfig-digitalAssetLinksService-  = defaultService (ServiceId "digitalassetlinks:v1")-      "digitalassetlinks.googleapis.com"

@@ -1,471 +0,0 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveGeneric      #-}-{-# LANGUAGE NoImplicitPrelude  #-}-{-# LANGUAGE OverloadedStrings  #-}-{-# LANGUAGE RecordWildCards    #-}--{-# OPTIONS_GHC -fno-warn-unused-binds   #-}-{-# OPTIONS_GHC -fno-warn-unused-imports #-}---- |--- Module      : Network.Google.DigitalAssetLinks.Types.Product--- Copyright   : (c) 2015-2016 Brendan Hay--- License     : Mozilla Public License, v. 2.0.--- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>--- Stability   : auto-generated--- Portability : non-portable (GHC extensions)----module Network.Google.DigitalAssetLinks.Types.Product where--import           Network.Google.DigitalAssetLinks.Types.Sum-import           Network.Google.Prelude---- | Describes an android app asset.------ /See:/ 'androidAppAsset' smart constructor.-data AndroidAppAsset =-  AndroidAppAsset'-    { _aaaPackageName :: !(Maybe Text)-    , _aaaCertificate :: !(Maybe CertificateInfo)-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'AndroidAppAsset' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'aaaPackageName'------ * 'aaaCertificate'-androidAppAsset-    :: AndroidAppAsset-androidAppAsset =-  AndroidAppAsset' {_aaaPackageName = Nothing, _aaaCertificate = Nothing}----- | Android App assets are naturally identified by their Java package name.--- For example, the Google Maps app uses the package name--- \`com.google.android.apps.maps\`. REQUIRED-aaaPackageName :: Lens' AndroidAppAsset (Maybe Text)-aaaPackageName-  = lens _aaaPackageName-      (\ s a -> s{_aaaPackageName = a})---- | Because there is no global enforcement of package name uniqueness, we--- also require a signing certificate, which in combination with the--- package name uniquely identifies an app. Some apps\' signing keys are--- rotated, so they may be signed by different keys over time. We treat--- these as distinct assets, since we use (package name, cert) as the--- unique ID. This should not normally pose any problems as both versions--- of the app will make the same or similar statements. Other assets making--- statements about the app will have to be updated when a key is rotated,--- however. (Note that the syntaxes for publishing and querying for--- statements contain syntactic sugar to easily let you specify apps that--- are known by multiple certificates.) REQUIRED-aaaCertificate :: Lens' AndroidAppAsset (Maybe CertificateInfo)-aaaCertificate-  = lens _aaaCertificate-      (\ s a -> s{_aaaCertificate = a})--instance FromJSON AndroidAppAsset where-        parseJSON-          = withObject "AndroidAppAsset"-              (\ o ->-                 AndroidAppAsset' <$>-                   (o .:? "packageName") <*> (o .:? "certificate"))--instance ToJSON AndroidAppAsset where-        toJSON AndroidAppAsset'{..}-          = object-              (catMaybes-                 [("packageName" .=) <$> _aaaPackageName,-                  ("certificate" .=) <$> _aaaCertificate])---- | Describes a reliable statement that has been made about the relationship--- between a source asset and a target asset. Statements are always made by--- the source asset, either directly or by delegating to a statement list--- that is stored elsewhere. For more detailed definitions of statements--- and assets, please refer to our [API documentation landing--- page](\/digital-asset-links\/v1\/getting-started).------ /See:/ 'statement' smart constructor.-data Statement =-  Statement'-    { _sRelation :: !(Maybe Text)-    , _sSource   :: !(Maybe Asset)-    , _sTarget   :: !(Maybe Asset)-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'Statement' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'sRelation'------ * 'sSource'------ * 'sTarget'-statement-    :: Statement-statement =-  Statement' {_sRelation = Nothing, _sSource = Nothing, _sTarget = Nothing}----- | The relation identifies the use of the statement as intended by the--- source asset\'s owner (that is, the person or entity who issued the--- statement). Every complete statement has a relation. We identify--- relations with strings of the format \`\/\`, where \`\` must be one of a--- set of pre-defined purpose categories, and \`\` is a free-form lowercase--- alphanumeric string that describes the specific use case of the--- statement. Refer to [our API--- documentation](\/digital-asset-links\/v1\/relation-strings) for the--- current list of supported relations. Example:--- \`delegate_permission\/common.handle_all_urls\` REQUIRED-sRelation :: Lens' Statement (Maybe Text)-sRelation-  = lens _sRelation (\ s a -> s{_sRelation = a})---- | Every statement has a source asset. REQUIRED-sSource :: Lens' Statement (Maybe Asset)-sSource = lens _sSource (\ s a -> s{_sSource = a})---- | Every statement has a target asset. REQUIRED-sTarget :: Lens' Statement (Maybe Asset)-sTarget = lens _sTarget (\ s a -> s{_sTarget = a})--instance FromJSON Statement where-        parseJSON-          = withObject "Statement"-              (\ o ->-                 Statement' <$>-                   (o .:? "relation") <*> (o .:? "source") <*>-                     (o .:? "target"))--instance ToJSON Statement where-        toJSON Statement'{..}-          = object-              (catMaybes-                 [("relation" .=) <$> _sRelation,-                  ("source" .=) <$> _sSource,-                  ("target" .=) <$> _sTarget])---- | Uniquely identifies an asset. A digital asset is an identifiable and--- addressable online entity that typically provides some service or--- content. Examples of assets are websites, Android apps, Twitter feeds,--- and Plus Pages.------ /See:/ 'asset' smart constructor.-data Asset =-  Asset'-    { _aAndroidApp :: !(Maybe AndroidAppAsset)-    , _aWeb        :: !(Maybe WebAsset)-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'Asset' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'aAndroidApp'------ * 'aWeb'-asset-    :: Asset-asset = Asset' {_aAndroidApp = Nothing, _aWeb = Nothing}----- | Set if this is an Android App asset.-aAndroidApp :: Lens' Asset (Maybe AndroidAppAsset)-aAndroidApp-  = lens _aAndroidApp (\ s a -> s{_aAndroidApp = a})---- | Set if this is a web asset.-aWeb :: Lens' Asset (Maybe WebAsset)-aWeb = lens _aWeb (\ s a -> s{_aWeb = a})--instance FromJSON Asset where-        parseJSON-          = withObject "Asset"-              (\ o ->-                 Asset' <$> (o .:? "androidApp") <*> (o .:? "web"))--instance ToJSON Asset where-        toJSON Asset'{..}-          = object-              (catMaybes-                 [("androidApp" .=) <$> _aAndroidApp,-                  ("web" .=) <$> _aWeb])---- | Response message for the List call.------ /See:/ 'listResponse' smart constructor.-data ListResponse =-  ListResponse'-    { _lrDebugString :: !(Maybe Text)-    , _lrMaxAge      :: !(Maybe GDuration)-    , _lrErrorCode   :: !(Maybe [Text])-    , _lrStatements  :: !(Maybe [Statement])-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'ListResponse' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'lrDebugString'------ * 'lrMaxAge'------ * 'lrErrorCode'------ * 'lrStatements'-listResponse-    :: ListResponse-listResponse =-  ListResponse'-    { _lrDebugString = Nothing-    , _lrMaxAge = Nothing-    , _lrErrorCode = Nothing-    , _lrStatements = Nothing-    }----- | Human-readable message containing information intended to help end users--- understand, reproduce and debug the result. The message will be in--- English and we are currently not planning to offer any translations.--- Please note that no guarantees are made about the contents or format of--- this string. Any aspect of it may be subject to change without notice.--- You should not attempt to programmatically parse this data. For--- programmatic access, use the error_code field below.-lrDebugString :: Lens' ListResponse (Maybe Text)-lrDebugString-  = lens _lrDebugString-      (\ s a -> s{_lrDebugString = a})---- | From serving time, how much longer the response should be considered--- valid barring further updates. REQUIRED-lrMaxAge :: Lens' ListResponse (Maybe Scientific)-lrMaxAge-  = lens _lrMaxAge (\ s a -> s{_lrMaxAge = a}) .-      mapping _GDuration---- | Error codes that describe the result of the List operation.-lrErrorCode :: Lens' ListResponse [Text]-lrErrorCode-  = lens _lrErrorCode (\ s a -> s{_lrErrorCode = a}) .-      _Default-      . _Coerce---- | A list of all the matching statements that have been found.-lrStatements :: Lens' ListResponse [Statement]-lrStatements-  = lens _lrStatements (\ s a -> s{_lrStatements = a})-      . _Default-      . _Coerce--instance FromJSON ListResponse where-        parseJSON-          = withObject "ListResponse"-              (\ o ->-                 ListResponse' <$>-                   (o .:? "debugString") <*> (o .:? "maxAge") <*>-                     (o .:? "errorCode" .!= mempty)-                     <*> (o .:? "statements" .!= mempty))--instance ToJSON ListResponse where-        toJSON ListResponse'{..}-          = object-              (catMaybes-                 [("debugString" .=) <$> _lrDebugString,-                  ("maxAge" .=) <$> _lrMaxAge,-                  ("errorCode" .=) <$> _lrErrorCode,-                  ("statements" .=) <$> _lrStatements])---- | Response message for the CheckAssetLinks call.------ /See:/ 'checkResponse' smart constructor.-data CheckResponse =-  CheckResponse'-    { _crDebugString :: !(Maybe Text)-    , _crMaxAge      :: !(Maybe GDuration)-    , _crErrorCode   :: !(Maybe [Text])-    , _crLinked      :: !(Maybe Bool)-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'CheckResponse' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'crDebugString'------ * 'crMaxAge'------ * 'crErrorCode'------ * 'crLinked'-checkResponse-    :: CheckResponse-checkResponse =-  CheckResponse'-    { _crDebugString = Nothing-    , _crMaxAge = Nothing-    , _crErrorCode = Nothing-    , _crLinked = Nothing-    }----- | Human-readable message containing information intended to help end users--- understand, reproduce and debug the result. The message will be in--- English and we are currently not planning to offer any translations.--- Please note that no guarantees are made about the contents or format of--- this string. Any aspect of it may be subject to change without notice.--- You should not attempt to programmatically parse this data. For--- programmatic access, use the error_code field below.-crDebugString :: Lens' CheckResponse (Maybe Text)-crDebugString-  = lens _crDebugString-      (\ s a -> s{_crDebugString = a})---- | From serving time, how much longer the response should be considered--- valid barring further updates. REQUIRED-crMaxAge :: Lens' CheckResponse (Maybe Scientific)-crMaxAge-  = lens _crMaxAge (\ s a -> s{_crMaxAge = a}) .-      mapping _GDuration---- | Error codes that describe the result of the Check operation.-crErrorCode :: Lens' CheckResponse [Text]-crErrorCode-  = lens _crErrorCode (\ s a -> s{_crErrorCode = a}) .-      _Default-      . _Coerce---- | Set to true if the assets specified in the request are linked by the--- relation specified in the request.-crLinked :: Lens' CheckResponse (Maybe Bool)-crLinked = lens _crLinked (\ s a -> s{_crLinked = a})--instance FromJSON CheckResponse where-        parseJSON-          = withObject "CheckResponse"-              (\ o ->-                 CheckResponse' <$>-                   (o .:? "debugString") <*> (o .:? "maxAge") <*>-                     (o .:? "errorCode" .!= mempty)-                     <*> (o .:? "linked"))--instance ToJSON CheckResponse where-        toJSON CheckResponse'{..}-          = object-              (catMaybes-                 [("debugString" .=) <$> _crDebugString,-                  ("maxAge" .=) <$> _crMaxAge,-                  ("errorCode" .=) <$> _crErrorCode,-                  ("linked" .=) <$> _crLinked])---- | Describes a web asset.------ /See:/ 'webAsset' smart constructor.-newtype WebAsset =-  WebAsset'-    { _waSite :: Maybe Text-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'WebAsset' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'waSite'-webAsset-    :: WebAsset-webAsset = WebAsset' {_waSite = Nothing}----- | Web assets are identified by a URL that contains only the scheme,--- hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be--- fully qualified: they must end in a single period (\"\`.\`\"). Only the--- schemes \"http\" and \"https\" are currently allowed. Port numbers are--- given as a decimal number, and they must be omitted if the standard port--- numbers are used: 80 for http and 443 for https. We call this limited--- URL the \"site\". All URLs that share the same scheme, hostname and port--- are considered to be a part of the site and thus belong to the web--- asset. Example: the asset with the site \`https:\/\/www.google.com\`--- contains all these URLs: * \`https:\/\/www.google.com\/\` *--- \`https:\/\/www.google.com:443\/\` * \`https:\/\/www.google.com\/foo\` *--- \`https:\/\/www.google.com\/foo?bar\` *--- \`https:\/\/www.google.com\/foo#bar\` *--- \`https:\/\/user\'password:www.google.com\/\` But it does not contain--- these URLs: * \`http:\/\/www.google.com\/\` (wrong scheme) *--- \`https:\/\/google.com\/\` (hostname does not match) *--- \`https:\/\/www.google.com:444\/\` (port does not match) REQUIRED-waSite :: Lens' WebAsset (Maybe Text)-waSite = lens _waSite (\ s a -> s{_waSite = a})--instance FromJSON WebAsset where-        parseJSON-          = withObject "WebAsset"-              (\ o -> WebAsset' <$> (o .:? "site"))--instance ToJSON WebAsset where-        toJSON WebAsset'{..}-          = object (catMaybes [("site" .=) <$> _waSite])---- | Describes an X509 certificate.------ /See:/ 'certificateInfo' smart constructor.-newtype CertificateInfo =-  CertificateInfo'-    { _ciSha256Fingerprint :: Maybe Text-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'CertificateInfo' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'ciSha256Fingerprint'-certificateInfo-    :: CertificateInfo-certificateInfo = CertificateInfo' {_ciSha256Fingerprint = Nothing}----- | The uppercase SHA-265 fingerprint of the certificate. From the PEM--- certificate, it can be acquired like this: $ keytool -printcert -file--- $CERTFILE | grep SHA256: SHA256:--- 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\--- 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in--- $CERTFILE -noout -fingerprint -sha256 SHA256--- Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\--- 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the--- contents of this field would be \`14:6D:E9:83:C5:73:--- 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:--- 44:E5\`. If these tools are not available to you, you can convert the--- PEM certificate into the DER format, compute the SHA-256 hash of that--- string and represent the result as a hexstring (that is, uppercase--- hexadecimal representations of each octet, separated by colons).-ciSha256Fingerprint :: Lens' CertificateInfo (Maybe Text)-ciSha256Fingerprint-  = lens _ciSha256Fingerprint-      (\ s a -> s{_ciSha256Fingerprint = a})--instance FromJSON CertificateInfo where-        parseJSON-          = withObject "CertificateInfo"-              (\ o ->-                 CertificateInfo' <$> (o .:? "sha256Fingerprint"))--instance ToJSON CertificateInfo where-        toJSON CertificateInfo'{..}-          = object-              (catMaybes-                 [("sha256Fingerprint" .=) <$> _ciSha256Fingerprint])

@@ -1,48 +0,0 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveGeneric      #-}-{-# LANGUAGE LambdaCase         #-}-{-# LANGUAGE NoImplicitPrelude  #-}-{-# LANGUAGE OverloadedStrings  #-}--{-# OPTIONS_GHC -fno-warn-unused-imports #-}---- |--- Module      : Network.Google.DigitalAssetLinks.Types.Sum--- Copyright   : (c) 2015-2016 Brendan Hay--- License     : Mozilla Public License, v. 2.0.--- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>--- Stability   : auto-generated--- Portability : non-portable (GHC extensions)----module Network.Google.DigitalAssetLinks.Types.Sum where--import           Network.Google.Prelude hiding (Bytes)---- | V1 error format.-data Xgafv-    = X1-      -- ^ @1@-      -- v1 error format-    | X2-      -- ^ @2@-      -- v2 error format-      deriving (Eq, Ord, Enum, Read, Show, Data, Typeable, Generic)--instance Hashable Xgafv--instance FromHttpApiData Xgafv where-    parseQueryParam = \case-        "1" -> Right X1-        "2" -> Right X2-        x -> Left ("Unable to parse Xgafv from: " <> x)--instance ToHttpApiData Xgafv where-    toQueryParam = \case-        X1 -> "1"-        X2 -> "2"--instance FromJSON Xgafv where-    parseJSON = parseJSONText "Xgafv"--instance ToJSON Xgafv where-    toJSON = toJSONText

@@ -1,347 +0,0 @@-{-# LANGUAGE DataKinds          #-}-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveGeneric      #-}-{-# LANGUAGE FlexibleInstances  #-}-{-# LANGUAGE NoImplicitPrelude  #-}-{-# LANGUAGE OverloadedStrings  #-}-{-# LANGUAGE RecordWildCards    #-}-{-# LANGUAGE TypeFamilies       #-}-{-# LANGUAGE TypeOperators      #-}--{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}-{-# OPTIONS_GHC -fno-warn-unused-binds      #-}-{-# OPTIONS_GHC -fno-warn-unused-imports    #-}---- |--- Module      : Network.Google.Resource.DigitalAssetLinks.Assetlinks.Check--- Copyright   : (c) 2015-2016 Brendan Hay--- License     : Mozilla Public License, v. 2.0.--- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>--- Stability   : auto-generated--- Portability : non-portable (GHC extensions)------ Determines whether the specified (directional) relationship exists--- between the specified source and target assets. The relation describes--- the intent of the link between the two assets as claimed by the source--- asset. An example for such relationships is the delegation of privileges--- or permissions. This command is most often used by infrastructure--- systems to check preconditions for an action. For example, a client may--- want to know if it is OK to send a web URL to a particular mobile app--- instead. The client can check for the relevant asset link from the--- website to the mobile app to decide if the operation should be allowed.--- A note about security: if you specify a secure asset as the source, such--- as an HTTPS website or an Android app, the API will ensure that any--- statements used to generate the response have been made in a secure way--- by the owner of that asset. Conversely, if the source asset is an--- insecure HTTP website (that is, the URL starts with \`http:\/\/\`--- instead of \`https:\/\/\`), the API cannot verify its statements--- securely, and it is not possible to ensure that the website\'s--- statements have not been altered by a third party. For more information,--- see the [Digital Asset Links technical design--- specification](https:\/\/github.com\/google\/digitalassetlinks\/blob\/master\/well-known\/details.md).------ /See:/ <https://developers.google.com/digital-asset-links/ Digital Asset Links API Reference> for @digitalassetlinks.assetlinks.check@.-module Network.Google.Resource.DigitalAssetLinks.Assetlinks.Check-    (-    -- * REST Resource-      AssetlinksCheckResource--    -- * Creating a Request-    , assetlinksCheck-    , AssetlinksCheck--    -- * Request Lenses-    , acXgafv-    , acSourceAndroidAppCertificateSha256Fingerprint-    , acSourceAndroidAppPackageName-    , acTargetWebSite-    , acUploadProtocol-    , acAccessToken-    , acTargetAndroidAppCertificateSha256Fingerprint-    , acUploadType-    , acRelation-    , acTargetAndroidAppPackageName-    , acSourceWebSite-    , acCallback-    ) where--import           Network.Google.DigitalAssetLinks.Types-import           Network.Google.Prelude---- | A resource alias for @digitalassetlinks.assetlinks.check@ method which the--- 'AssetlinksCheck' request conforms to.-type AssetlinksCheckResource =-     "v1" :>-       "assetlinks:check" :>-         QueryParam "$.xgafv" Xgafv :>-           QueryParam-             "source.androidApp.certificate.sha256Fingerprint"-             Text-             :>-             QueryParam "source.androidApp.packageName" Text :>-               QueryParam "target.web.site" Text :>-                 QueryParam "upload_protocol" Text :>-                   QueryParam "access_token" Text :>-                     QueryParam-                       "target.androidApp.certificate.sha256Fingerprint"-                       Text-                       :>-                       QueryParam "uploadType" Text :>-                         QueryParam "relation" Text :>-                           QueryParam "target.androidApp.packageName" Text :>-                             QueryParam "source.web.site" Text :>-                               QueryParam "callback" Text :>-                                 QueryParam "alt" AltJSON :>-                                   Get '[JSON] CheckResponse---- | Determines whether the specified (directional) relationship exists--- between the specified source and target assets. The relation describes--- the intent of the link between the two assets as claimed by the source--- asset. An example for such relationships is the delegation of privileges--- or permissions. This command is most often used by infrastructure--- systems to check preconditions for an action. For example, a client may--- want to know if it is OK to send a web URL to a particular mobile app--- instead. The client can check for the relevant asset link from the--- website to the mobile app to decide if the operation should be allowed.--- A note about security: if you specify a secure asset as the source, such--- as an HTTPS website or an Android app, the API will ensure that any--- statements used to generate the response have been made in a secure way--- by the owner of that asset. Conversely, if the source asset is an--- insecure HTTP website (that is, the URL starts with \`http:\/\/\`--- instead of \`https:\/\/\`), the API cannot verify its statements--- securely, and it is not possible to ensure that the website\'s--- statements have not been altered by a third party. For more information,--- see the [Digital Asset Links technical design--- specification](https:\/\/github.com\/google\/digitalassetlinks\/blob\/master\/well-known\/details.md).------ /See:/ 'assetlinksCheck' smart constructor.-data AssetlinksCheck =-  AssetlinksCheck'-    { _acXgafv                                        :: !(Maybe Xgafv)-    , _acSourceAndroidAppCertificateSha256Fingerprint :: !(Maybe Text)-    , _acSourceAndroidAppPackageName                  :: !(Maybe Text)-    , _acTargetWebSite                                :: !(Maybe Text)-    , _acUploadProtocol                               :: !(Maybe Text)-    , _acAccessToken                                  :: !(Maybe Text)-    , _acTargetAndroidAppCertificateSha256Fingerprint :: !(Maybe Text)-    , _acUploadType                                   :: !(Maybe Text)-    , _acRelation                                     :: !(Maybe Text)-    , _acTargetAndroidAppPackageName                  :: !(Maybe Text)-    , _acSourceWebSite                                :: !(Maybe Text)-    , _acCallback                                     :: !(Maybe Text)-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'AssetlinksCheck' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'acXgafv'------ * 'acSourceAndroidAppCertificateSha256Fingerprint'------ * 'acSourceAndroidAppPackageName'------ * 'acTargetWebSite'------ * 'acUploadProtocol'------ * 'acAccessToken'------ * 'acTargetAndroidAppCertificateSha256Fingerprint'------ * 'acUploadType'------ * 'acRelation'------ * 'acTargetAndroidAppPackageName'------ * 'acSourceWebSite'------ * 'acCallback'-assetlinksCheck-    :: AssetlinksCheck-assetlinksCheck =-  AssetlinksCheck'-    { _acXgafv = Nothing-    , _acSourceAndroidAppCertificateSha256Fingerprint = Nothing-    , _acSourceAndroidAppPackageName = Nothing-    , _acTargetWebSite = Nothing-    , _acUploadProtocol = Nothing-    , _acAccessToken = Nothing-    , _acTargetAndroidAppCertificateSha256Fingerprint = Nothing-    , _acUploadType = Nothing-    , _acRelation = Nothing-    , _acTargetAndroidAppPackageName = Nothing-    , _acSourceWebSite = Nothing-    , _acCallback = Nothing-    }----- | V1 error format.-acXgafv :: Lens' AssetlinksCheck (Maybe Xgafv)-acXgafv = lens _acXgafv (\ s a -> s{_acXgafv = a})---- | The uppercase SHA-265 fingerprint of the certificate. From the PEM--- certificate, it can be acquired like this: $ keytool -printcert -file--- $CERTFILE | grep SHA256: SHA256:--- 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\--- 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in--- $CERTFILE -noout -fingerprint -sha256 SHA256--- Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\--- 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the--- contents of this field would be \`14:6D:E9:83:C5:73:--- 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:--- 44:E5\`. If these tools are not available to you, you can convert the--- PEM certificate into the DER format, compute the SHA-256 hash of that--- string and represent the result as a hexstring (that is, uppercase--- hexadecimal representations of each octet, separated by colons).-acSourceAndroidAppCertificateSha256Fingerprint :: Lens' AssetlinksCheck (Maybe Text)-acSourceAndroidAppCertificateSha256Fingerprint-  = lens-      _acSourceAndroidAppCertificateSha256Fingerprint-      (\ s a ->-         s{_acSourceAndroidAppCertificateSha256Fingerprint =-             a})---- | Android App assets are naturally identified by their Java package name.--- For example, the Google Maps app uses the package name--- \`com.google.android.apps.maps\`. REQUIRED-acSourceAndroidAppPackageName :: Lens' AssetlinksCheck (Maybe Text)-acSourceAndroidAppPackageName-  = lens _acSourceAndroidAppPackageName-      (\ s a -> s{_acSourceAndroidAppPackageName = a})---- | Web assets are identified by a URL that contains only the scheme,--- hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be--- fully qualified: they must end in a single period (\"\`.\`\"). Only the--- schemes \"http\" and \"https\" are currently allowed. Port numbers are--- given as a decimal number, and they must be omitted if the standard port--- numbers are used: 80 for http and 443 for https. We call this limited--- URL the \"site\". All URLs that share the same scheme, hostname and port--- are considered to be a part of the site and thus belong to the web--- asset. Example: the asset with the site \`https:\/\/www.google.com\`--- contains all these URLs: * \`https:\/\/www.google.com\/\` *--- \`https:\/\/www.google.com:443\/\` * \`https:\/\/www.google.com\/foo\` *--- \`https:\/\/www.google.com\/foo?bar\` *--- \`https:\/\/www.google.com\/foo#bar\` *--- \`https:\/\/user\'password:www.google.com\/\` But it does not contain--- these URLs: * \`http:\/\/www.google.com\/\` (wrong scheme) *--- \`https:\/\/google.com\/\` (hostname does not match) *--- \`https:\/\/www.google.com:444\/\` (port does not match) REQUIRED-acTargetWebSite :: Lens' AssetlinksCheck (Maybe Text)-acTargetWebSite-  = lens _acTargetWebSite-      (\ s a -> s{_acTargetWebSite = a})---- | Upload protocol for media (e.g. \"raw\", \"multipart\").-acUploadProtocol :: Lens' AssetlinksCheck (Maybe Text)-acUploadProtocol-  = lens _acUploadProtocol-      (\ s a -> s{_acUploadProtocol = a})---- | OAuth access token.-acAccessToken :: Lens' AssetlinksCheck (Maybe Text)-acAccessToken-  = lens _acAccessToken-      (\ s a -> s{_acAccessToken = a})---- | The uppercase SHA-265 fingerprint of the certificate. From the PEM--- certificate, it can be acquired like this: $ keytool -printcert -file--- $CERTFILE | grep SHA256: SHA256:--- 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\--- 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in--- $CERTFILE -noout -fingerprint -sha256 SHA256--- Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\--- 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the--- contents of this field would be \`14:6D:E9:83:C5:73:--- 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:--- 44:E5\`. If these tools are not available to you, you can convert the--- PEM certificate into the DER format, compute the SHA-256 hash of that--- string and represent the result as a hexstring (that is, uppercase--- hexadecimal representations of each octet, separated by colons).-acTargetAndroidAppCertificateSha256Fingerprint :: Lens' AssetlinksCheck (Maybe Text)-acTargetAndroidAppCertificateSha256Fingerprint-  = lens-      _acTargetAndroidAppCertificateSha256Fingerprint-      (\ s a ->-         s{_acTargetAndroidAppCertificateSha256Fingerprint =-             a})---- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").-acUploadType :: Lens' AssetlinksCheck (Maybe Text)-acUploadType-  = lens _acUploadType (\ s a -> s{_acUploadType = a})---- | Query string for the relation. We identify relations with strings of the--- format \`\/\`, where \`\` must be one of a set of pre-defined purpose--- categories, and \`\` is a free-form lowercase alphanumeric string that--- describes the specific use case of the statement. Refer to [our API--- documentation](\/digital-asset-links\/v1\/relation-strings) for the--- current list of supported relations. For a query to match an asset link,--- both the query\'s and the asset link\'s relation strings must match--- exactly. Example: A query with relation--- \`delegate_permission\/common.handle_all_urls\` matches an asset link--- with relation \`delegate_permission\/common.handle_all_urls\`.-acRelation :: Lens' AssetlinksCheck (Maybe Text)-acRelation-  = lens _acRelation (\ s a -> s{_acRelation = a})---- | Android App assets are naturally identified by their Java package name.--- For example, the Google Maps app uses the package name--- \`com.google.android.apps.maps\`. REQUIRED-acTargetAndroidAppPackageName :: Lens' AssetlinksCheck (Maybe Text)-acTargetAndroidAppPackageName-  = lens _acTargetAndroidAppPackageName-      (\ s a -> s{_acTargetAndroidAppPackageName = a})---- | Web assets are identified by a URL that contains only the scheme,--- hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be--- fully qualified: they must end in a single period (\"\`.\`\"). Only the--- schemes \"http\" and \"https\" are currently allowed. Port numbers are--- given as a decimal number, and they must be omitted if the standard port--- numbers are used: 80 for http and 443 for https. We call this limited--- URL the \"site\". All URLs that share the same scheme, hostname and port--- are considered to be a part of the site and thus belong to the web--- asset. Example: the asset with the site \`https:\/\/www.google.com\`--- contains all these URLs: * \`https:\/\/www.google.com\/\` *--- \`https:\/\/www.google.com:443\/\` * \`https:\/\/www.google.com\/foo\` *--- \`https:\/\/www.google.com\/foo?bar\` *--- \`https:\/\/www.google.com\/foo#bar\` *--- \`https:\/\/user\'password:www.google.com\/\` But it does not contain--- these URLs: * \`http:\/\/www.google.com\/\` (wrong scheme) *--- \`https:\/\/google.com\/\` (hostname does not match) *--- \`https:\/\/www.google.com:444\/\` (port does not match) REQUIRED-acSourceWebSite :: Lens' AssetlinksCheck (Maybe Text)-acSourceWebSite-  = lens _acSourceWebSite-      (\ s a -> s{_acSourceWebSite = a})---- | JSONP-acCallback :: Lens' AssetlinksCheck (Maybe Text)-acCallback-  = lens _acCallback (\ s a -> s{_acCallback = a})--instance GoogleRequest AssetlinksCheck where-        type Rs AssetlinksCheck = CheckResponse-        type Scopes AssetlinksCheck = '[]-        requestClient AssetlinksCheck'{..}-          = go _acXgafv-              _acSourceAndroidAppCertificateSha256Fingerprint-              _acSourceAndroidAppPackageName-              _acTargetWebSite-              _acUploadProtocol-              _acAccessToken-              _acTargetAndroidAppCertificateSha256Fingerprint-              _acUploadType-              _acRelation-              _acTargetAndroidAppPackageName-              _acSourceWebSite-              _acCallback-              (Just AltJSON)-              digitalAssetLinksService-          where go-                  = buildClient-                      (Proxy :: Proxy AssetlinksCheckResource)-                      mempty

@@ -1,257 +0,0 @@-{-# LANGUAGE DataKinds          #-}-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveGeneric      #-}-{-# LANGUAGE FlexibleInstances  #-}-{-# LANGUAGE NoImplicitPrelude  #-}-{-# LANGUAGE OverloadedStrings  #-}-{-# LANGUAGE RecordWildCards    #-}-{-# LANGUAGE TypeFamilies       #-}-{-# LANGUAGE TypeOperators      #-}--{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}-{-# OPTIONS_GHC -fno-warn-unused-binds      #-}-{-# OPTIONS_GHC -fno-warn-unused-imports    #-}---- |--- Module      : Network.Google.Resource.DigitalAssetLinks.Statements.List--- Copyright   : (c) 2015-2016 Brendan Hay--- License     : Mozilla Public License, v. 2.0.--- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>--- Stability   : auto-generated--- Portability : non-portable (GHC extensions)------ Retrieves a list of all statements from a given source that match the--- specified target and statement string. The API guarantees that all--- statements with secure source assets, such as HTTPS websites or Android--- apps, have been made in a secure way by the owner of those assets, as--- described in the [Digital Asset Links technical design--- specification](https:\/\/github.com\/google\/digitalassetlinks\/blob\/master\/well-known\/details.md).--- Specifically, you should consider that for insecure websites (that is,--- where the URL starts with \`http:\/\/\` instead of \`https:\/\/\`), this--- guarantee cannot be made. The \`List\` command is most useful in cases--- where the API client wants to know all the ways in which two assets are--- related, or enumerate all the relationships from a particular source--- asset. Example: a feature that helps users navigate to related items.--- When a mobile app is running on a device, the feature would make it easy--- to navigate to the corresponding web site or Google+ profile.------ /See:/ <https://developers.google.com/digital-asset-links/ Digital Asset Links API Reference> for @digitalassetlinks.statements.list@.-module Network.Google.Resource.DigitalAssetLinks.Statements.List-    (-    -- * REST Resource-      StatementsListResource--    -- * Creating a Request-    , statementsList-    , StatementsList--    -- * Request Lenses-    , slXgafv-    , slSourceAndroidAppCertificateSha256Fingerprint-    , slSourceAndroidAppPackageName-    , slUploadProtocol-    , slAccessToken-    , slUploadType-    , slRelation-    , slSourceWebSite-    , slCallback-    ) where--import           Network.Google.DigitalAssetLinks.Types-import           Network.Google.Prelude---- | A resource alias for @digitalassetlinks.statements.list@ method which the--- 'StatementsList' request conforms to.-type StatementsListResource =-     "v1" :>-       "statements:list" :>-         QueryParam "$.xgafv" Xgafv :>-           QueryParam-             "source.androidApp.certificate.sha256Fingerprint"-             Text-             :>-             QueryParam "source.androidApp.packageName" Text :>-               QueryParam "upload_protocol" Text :>-                 QueryParam "access_token" Text :>-                   QueryParam "uploadType" Text :>-                     QueryParam "relation" Text :>-                       QueryParam "source.web.site" Text :>-                         QueryParam "callback" Text :>-                           QueryParam "alt" AltJSON :> Get '[JSON] ListResponse---- | Retrieves a list of all statements from a given source that match the--- specified target and statement string. The API guarantees that all--- statements with secure source assets, such as HTTPS websites or Android--- apps, have been made in a secure way by the owner of those assets, as--- described in the [Digital Asset Links technical design--- specification](https:\/\/github.com\/google\/digitalassetlinks\/blob\/master\/well-known\/details.md).--- Specifically, you should consider that for insecure websites (that is,--- where the URL starts with \`http:\/\/\` instead of \`https:\/\/\`), this--- guarantee cannot be made. The \`List\` command is most useful in cases--- where the API client wants to know all the ways in which two assets are--- related, or enumerate all the relationships from a particular source--- asset. Example: a feature that helps users navigate to related items.--- When a mobile app is running on a device, the feature would make it easy--- to navigate to the corresponding web site or Google+ profile.------ /See:/ 'statementsList' smart constructor.-data StatementsList =-  StatementsList'-    { _slXgafv                                        :: !(Maybe Xgafv)-    , _slSourceAndroidAppCertificateSha256Fingerprint :: !(Maybe Text)-    , _slSourceAndroidAppPackageName                  :: !(Maybe Text)-    , _slUploadProtocol                               :: !(Maybe Text)-    , _slAccessToken                                  :: !(Maybe Text)-    , _slUploadType                                   :: !(Maybe Text)-    , _slRelation                                     :: !(Maybe Text)-    , _slSourceWebSite                                :: !(Maybe Text)-    , _slCallback                                     :: !(Maybe Text)-    }-  deriving (Eq, Show, Data, Typeable, Generic)----- | Creates a value of 'StatementsList' with the minimum fields required to make a request.------ Use one of the following lenses to modify other fields as desired:------ * 'slXgafv'------ * 'slSourceAndroidAppCertificateSha256Fingerprint'------ * 'slSourceAndroidAppPackageName'------ * 'slUploadProtocol'------ * 'slAccessToken'------ * 'slUploadType'------ * 'slRelation'------ * 'slSourceWebSite'------ * 'slCallback'-statementsList-    :: StatementsList-statementsList =-  StatementsList'-    { _slXgafv = Nothing-    , _slSourceAndroidAppCertificateSha256Fingerprint = Nothing-    , _slSourceAndroidAppPackageName = Nothing-    , _slUploadProtocol = Nothing-    , _slAccessToken = Nothing-    , _slUploadType = Nothing-    , _slRelation = Nothing-    , _slSourceWebSite = Nothing-    , _slCallback = Nothing-    }----- | V1 error format.-slXgafv :: Lens' StatementsList (Maybe Xgafv)-slXgafv = lens _slXgafv (\ s a -> s{_slXgafv = a})---- | The uppercase SHA-265 fingerprint of the certificate. From the PEM--- certificate, it can be acquired like this: $ keytool -printcert -file--- $CERTFILE | grep SHA256: SHA256:--- 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \\--- 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in--- $CERTFILE -noout -fingerprint -sha256 SHA256--- Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \\--- 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the--- contents of this field would be \`14:6D:E9:83:C5:73:--- 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:--- 44:E5\`. If these tools are not available to you, you can convert the--- PEM certificate into the DER format, compute the SHA-256 hash of that--- string and represent the result as a hexstring (that is, uppercase--- hexadecimal representations of each octet, separated by colons).-slSourceAndroidAppCertificateSha256Fingerprint :: Lens' StatementsList (Maybe Text)-slSourceAndroidAppCertificateSha256Fingerprint-  = lens-      _slSourceAndroidAppCertificateSha256Fingerprint-      (\ s a ->-         s{_slSourceAndroidAppCertificateSha256Fingerprint =-             a})---- | Android App assets are naturally identified by their Java package name.--- For example, the Google Maps app uses the package name--- \`com.google.android.apps.maps\`. REQUIRED-slSourceAndroidAppPackageName :: Lens' StatementsList (Maybe Text)-slSourceAndroidAppPackageName-  = lens _slSourceAndroidAppPackageName-      (\ s a -> s{_slSourceAndroidAppPackageName = a})---- | Upload protocol for media (e.g. \"raw\", \"multipart\").-slUploadProtocol :: Lens' StatementsList (Maybe Text)-slUploadProtocol-  = lens _slUploadProtocol-      (\ s a -> s{_slUploadProtocol = a})---- | OAuth access token.-slAccessToken :: Lens' StatementsList (Maybe Text)-slAccessToken-  = lens _slAccessToken-      (\ s a -> s{_slAccessToken = a})---- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").-slUploadType :: Lens' StatementsList (Maybe Text)-slUploadType-  = lens _slUploadType (\ s a -> s{_slUploadType = a})---- | Use only associations that match the specified relation. See the--- [\`Statement\`](#Statement) message for a detailed definition of--- relation strings. For a query to match a statement, one of the following--- must be true: * both the query\'s and the statement\'s relation strings--- match exactly, or * the query\'s relation string is empty or missing.--- Example: A query with relation--- \`delegate_permission\/common.handle_all_urls\` matches an asset link--- with relation \`delegate_permission\/common.handle_all_urls\`.-slRelation :: Lens' StatementsList (Maybe Text)-slRelation-  = lens _slRelation (\ s a -> s{_slRelation = a})---- | Web assets are identified by a URL that contains only the scheme,--- hostname and port parts. The format is http[s]:\/\/[:] Hostnames must be--- fully qualified: they must end in a single period (\"\`.\`\"). Only the--- schemes \"http\" and \"https\" are currently allowed. Port numbers are--- given as a decimal number, and they must be omitted if the standard port--- numbers are used: 80 for http and 443 for https. We call this limited--- URL the \"site\". All URLs that share the same scheme, hostname and port--- are considered to be a part of the site and thus belong to the web--- asset. Example: the asset with the site \`https:\/\/www.google.com\`--- contains all these URLs: * \`https:\/\/www.google.com\/\` *--- \`https:\/\/www.google.com:443\/\` * \`https:\/\/www.google.com\/foo\` *--- \`https:\/\/www.google.com\/foo?bar\` *--- \`https:\/\/www.google.com\/foo#bar\` *--- \`https:\/\/user\'password:www.google.com\/\` But it does not contain--- these URLs: * \`http:\/\/www.google.com\/\` (wrong scheme) *--- \`https:\/\/google.com\/\` (hostname does not match) *--- \`https:\/\/www.google.com:444\/\` (port does not match) REQUIRED-slSourceWebSite :: Lens' StatementsList (Maybe Text)-slSourceWebSite-  = lens _slSourceWebSite-      (\ s a -> s{_slSourceWebSite = a})---- | JSONP-slCallback :: Lens' StatementsList (Maybe Text)-slCallback-  = lens _slCallback (\ s a -> s{_slCallback = a})--instance GoogleRequest StatementsList where-        type Rs StatementsList = ListResponse-        type Scopes StatementsList = '[]-        requestClient StatementsList'{..}-          = go _slXgafv-              _slSourceAndroidAppCertificateSha256Fingerprint-              _slSourceAndroidAppPackageName-              _slUploadProtocol-              _slAccessToken-              _slUploadType-              _slRelation-              _slSourceWebSite-              _slCallback-              (Just AltJSON)-              digitalAssetLinksService-          where go-                  = buildClient (Proxy :: Proxy StatementsListResource)-                      mempty

@@ -1,48 +1,63 @@-name:                  gogol-digitalassetlinks-version:               0.5.0-synopsis:              Google Digital Asset Links SDK.-homepage:              https://github.com/brendanhay/gogol-bug-reports:           https://github.com/brendanhay/gogol/issues-license:               OtherLicense-license-file:          LICENSE-author:                Brendan Hay-maintainer:            Brendan Hay <brendan.g.hay@gmail.com>-copyright:             Copyright (c) 2015-2016 Brendan Hay-category:              Network, Google, Cloud-build-type:            Simple-cabal-version:         >= 1.10-extra-source-files:    README.md src/.gitkeep+cabal-version:      2.2+name:               gogol-digitalassetlinks+version:            1.0.0+synopsis:           Google Digital Asset Links SDK.+homepage:           https://github.com/brendanhay/gogol+bug-reports:        https://github.com/brendanhay/gogol/issues+license:            MPL-2.0+license-file:       LICENSE+author:             Brendan Hay+maintainer:+  Brendan Hay <brendan.g.hay+gogol@gmail.com>, Toni Cebrián <toni@tonicebrian.com> +copyright:          Copyright (c) 2015-2025 Brendan Hay+category:           Google+build-type:         Simple+extra-source-files:+  README.md+  src/.gitkeep+ description:-    Discovers relationships between online assets such as websites or mobile-    apps.-    .-    /Warning:/ This is an experimental prototype/preview release which is still-    under exploratory development and not intended for public use, caveat emptor!-    .-    This library is compatible with version @v1@-    of the API.+  Discovers relationships between online assets such as websites or mobile apps.+  .+  /Warning:/ This is an experimental prototype/preview release which is still+  under exploratory development and not intended for public use, caveat emptor!+  .+  This library is compatible with version @v1@+  of the API.  source-repository head-    type:     git-    location: git://github.com/brendanhay/gogol.git+  type:     git+  location: git://github.com/brendanhay/gogol.git+  subdir:   gogol-digitalassetlinks +flag field-selectors+  description:+    If record field selectors should be enabled. Disabling this requires GHC >=9.2 and the NoFieldSelectors extension.++  default:     False+  manual:      True+ library-    default-language:  Haskell2010-    hs-source-dirs:    src gen+  default-language: GHC2021+  hs-source-dirs:   src gen+  ghc-options:+    -Wall -fwarn-incomplete-uni-patterns+    -fwarn-incomplete-record-updates -funbox-strict-fields+    -fwarn-unused-packages -    ghc-options:       -Wall+  if (!flag(field-selectors) && impl(ghc >=9.2))+    default-extensions: NoFieldSelectors -    exposed-modules:-          Network.Google.DigitalAssetLinks-        , Network.Google.DigitalAssetLinks.Types-        , Network.Google.Resource.DigitalAssetLinks.Assetlinks.Check-        , Network.Google.Resource.DigitalAssetLinks.Statements.List+  exposed-modules:+    Gogol.DigitalAssetLinks+    Gogol.DigitalAssetLinks.Assetlinks.BulkCheck+    Gogol.DigitalAssetLinks.Assetlinks.Check+    Gogol.DigitalAssetLinks.Statements.List+    Gogol.DigitalAssetLinks.Types -    other-modules:-          Network.Google.DigitalAssetLinks.Types.Product-        , Network.Google.DigitalAssetLinks.Types.Sum+  other-modules:+    Gogol.DigitalAssetLinks.Internal.Product+    Gogol.DigitalAssetLinks.Internal.Sum -    build-depends:-          gogol-core == 0.5.0.*-        , base       >= 4.7 && < 5+  build-depends:    gogol-core ^>=1.0.0