content: {-# 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.BigtableAdmin.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.BigtableAdmin.Internal.Product
    ( -- * AppProfile
      AppProfile (..),
      newAppProfile,
  
      -- * AuditConfig
      AuditConfig (..),
      newAuditConfig,
  
      -- * AuditLogConfig
      AuditLogConfig (..),
      newAuditLogConfig,
  
      -- * AuthorizedView
      AuthorizedView (..),
      newAuthorizedView,
  
      -- * AutomatedBackupPolicy
      AutomatedBackupPolicy (..),
      newAutomatedBackupPolicy,
  
      -- * AutoscalingLimits
      AutoscalingLimits (..),
      newAutoscalingLimits,
  
      -- * AutoscalingTargets
      AutoscalingTargets (..),
      newAutoscalingTargets,
  
      -- * Backup
      Backup (..),
      newBackup,
  
      -- * BackupInfo
      BackupInfo (..),
      newBackupInfo,
  
      -- * Binding
      Binding (..),
      newBinding,
  
      -- * ChangeStreamConfig
      ChangeStreamConfig (..),
      newChangeStreamConfig,
  
      -- * CheckConsistencyRequest
      CheckConsistencyRequest (..),
      newCheckConsistencyRequest,
  
      -- * CheckConsistencyResponse
      CheckConsistencyResponse (..),
      newCheckConsistencyResponse,
  
      -- * Cluster
      Cluster (..),
      newCluster,
  
      -- * ClusterAutoscalingConfig
      ClusterAutoscalingConfig (..),
      newClusterAutoscalingConfig,
  
      -- * ClusterConfig
      ClusterConfig (..),
      newClusterConfig,
  
      -- * ClusterState
      ClusterState (..),
      newClusterState,
  
      -- * ColumnFamily
      ColumnFamily (..),
      newColumnFamily,
  
      -- * ColumnFamilyStats
      ColumnFamilyStats (..),
      newColumnFamilyStats,
  
      -- * CopyBackupMetadata
      CopyBackupMetadata (..),
      newCopyBackupMetadata,
  
      -- * CopyBackupRequest
      CopyBackupRequest (..),
      newCopyBackupRequest,
  
      -- * CreateAuthorizedViewMetadata
      CreateAuthorizedViewMetadata (..),
      newCreateAuthorizedViewMetadata,
  
      -- * CreateAuthorizedViewRequest
      CreateAuthorizedViewRequest (..),
      newCreateAuthorizedViewRequest,
  
      -- * CreateBackupMetadata
      CreateBackupMetadata (..),
      newCreateBackupMetadata,
  
      -- * CreateClusterMetadata
      CreateClusterMetadata (..),
      newCreateClusterMetadata,
  
      -- * CreateClusterMetadata_Tables
      CreateClusterMetadata_Tables (..),
      newCreateClusterMetadata_Tables,
  
      -- * CreateClusterRequest
      CreateClusterRequest (..),
      newCreateClusterRequest,
  
      -- * CreateInstanceMetadata
      CreateInstanceMetadata (..),
      newCreateInstanceMetadata,
  
      -- * CreateInstanceRequest
      CreateInstanceRequest (..),
      newCreateInstanceRequest,
  
      -- * CreateInstanceRequest_Clusters
      CreateInstanceRequest_Clusters (..),
      newCreateInstanceRequest_Clusters,
  
      -- * CreateTableRequest
      CreateTableRequest (..),
      newCreateTableRequest,
  
      -- * DataBoostIsolationReadOnly
      DataBoostIsolationReadOnly (..),
      newDataBoostIsolationReadOnly,
  
      -- * DataBoostReadLocalWrites
      DataBoostReadLocalWrites (..),
      newDataBoostReadLocalWrites,
  
      -- * DropRowRangeRequest
      DropRowRangeRequest (..),
      newDropRowRangeRequest,
  
      -- * Empty
      Empty (..),
      newEmpty,
  
      -- * EncryptionConfig
      EncryptionConfig (..),
      newEncryptionConfig,
  
      -- * EncryptionInfo
      EncryptionInfo (..),
      newEncryptionInfo,
  
      -- * Expr
      Expr (..),
      newExpr,
  
      -- * GcRule
      GcRule (..),
      newGcRule,
  
      -- * GenerateConsistencyTokenRequest
      GenerateConsistencyTokenRequest (..),
      newGenerateConsistencyTokenRequest,
  
      -- * GenerateConsistencyTokenResponse
      GenerateConsistencyTokenResponse (..),
      newGenerateConsistencyTokenResponse,
  
      -- * GetIamPolicyRequest
      GetIamPolicyRequest (..),
      newGetIamPolicyRequest,
  
      -- * GetPolicyOptions
      GetPolicyOptions (..),
      newGetPolicyOptions,
  
      -- * GoogleBigtableAdminV2AuthorizedViewFamilySubsets
      GoogleBigtableAdminV2AuthorizedViewFamilySubsets (..),
      newGoogleBigtableAdminV2AuthorizedViewFamilySubsets,
  
      -- * GoogleBigtableAdminV2AuthorizedViewSubsetView
      GoogleBigtableAdminV2AuthorizedViewSubsetView (..),
      newGoogleBigtableAdminV2AuthorizedViewSubsetView,
  
      -- * GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
      GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets (..),
      newGoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets,
  
      -- * GoogleBigtableAdminV2TypeAggregate
      GoogleBigtableAdminV2TypeAggregate (..),
      newGoogleBigtableAdminV2TypeAggregate,
  
      -- * GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
      GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount (..),
      newGoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount,
  
      -- * GoogleBigtableAdminV2TypeAggregateMax
      GoogleBigtableAdminV2TypeAggregateMax (..),
      newGoogleBigtableAdminV2TypeAggregateMax,
  
      -- * GoogleBigtableAdminV2TypeAggregateMin
      GoogleBigtableAdminV2TypeAggregateMin (..),
      newGoogleBigtableAdminV2TypeAggregateMin,
  
      -- * GoogleBigtableAdminV2TypeAggregateSum
      GoogleBigtableAdminV2TypeAggregateSum (..),
      newGoogleBigtableAdminV2TypeAggregateSum,
  
      -- * GoogleBigtableAdminV2TypeArray
      GoogleBigtableAdminV2TypeArray (..),
      newGoogleBigtableAdminV2TypeArray,
  
      -- * GoogleBigtableAdminV2TypeBool
      GoogleBigtableAdminV2TypeBool (..),
      newGoogleBigtableAdminV2TypeBool,
  
      -- * GoogleBigtableAdminV2TypeBytes
      GoogleBigtableAdminV2TypeBytes (..),
      newGoogleBigtableAdminV2TypeBytes,
  
      -- * GoogleBigtableAdminV2TypeBytesEncoding
      GoogleBigtableAdminV2TypeBytesEncoding (..),
      newGoogleBigtableAdminV2TypeBytesEncoding,
  
      -- * GoogleBigtableAdminV2TypeBytesEncodingRaw
      GoogleBigtableAdminV2TypeBytesEncodingRaw (..),
      newGoogleBigtableAdminV2TypeBytesEncodingRaw,
  
      -- * GoogleBigtableAdminV2TypeDate
      GoogleBigtableAdminV2TypeDate (..),
      newGoogleBigtableAdminV2TypeDate,
  
      -- * GoogleBigtableAdminV2TypeFloat32
      GoogleBigtableAdminV2TypeFloat32 (..),
      newGoogleBigtableAdminV2TypeFloat32,
  
      -- * GoogleBigtableAdminV2TypeFloat64
      GoogleBigtableAdminV2TypeFloat64 (..),
      newGoogleBigtableAdminV2TypeFloat64,
  
      -- * GoogleBigtableAdminV2TypeInt64
      GoogleBigtableAdminV2TypeInt64 (..),
      newGoogleBigtableAdminV2TypeInt64,
  
      -- * GoogleBigtableAdminV2TypeInt64Encoding
      GoogleBigtableAdminV2TypeInt64Encoding (..),
      newGoogleBigtableAdminV2TypeInt64Encoding,
  
      -- * GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
      GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes (..),
      newGoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes,
  
      -- * GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes
      GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes (..),
      newGoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes,
  
      -- * GoogleBigtableAdminV2TypeMap
      GoogleBigtableAdminV2TypeMap (..),
      newGoogleBigtableAdminV2TypeMap,
  
      -- * GoogleBigtableAdminV2TypeString
      GoogleBigtableAdminV2TypeString (..),
      newGoogleBigtableAdminV2TypeString,
  
      -- * GoogleBigtableAdminV2TypeStringEncoding
      GoogleBigtableAdminV2TypeStringEncoding (..),
      newGoogleBigtableAdminV2TypeStringEncoding,
  
      -- * GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
      GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes (..),
      newGoogleBigtableAdminV2TypeStringEncodingUtf8Bytes,
  
      -- * GoogleBigtableAdminV2TypeStringEncodingUtf8Raw
      GoogleBigtableAdminV2TypeStringEncodingUtf8Raw (..),
      newGoogleBigtableAdminV2TypeStringEncodingUtf8Raw,
  
      -- * GoogleBigtableAdminV2TypeStruct
      GoogleBigtableAdminV2TypeStruct (..),
      newGoogleBigtableAdminV2TypeStruct,
  
      -- * GoogleBigtableAdminV2TypeStructEncoding
      GoogleBigtableAdminV2TypeStructEncoding (..),
      newGoogleBigtableAdminV2TypeStructEncoding,
  
      -- * GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes
      GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes (..),
      newGoogleBigtableAdminV2TypeStructEncodingDelimitedBytes,
  
      -- * GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
      GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes (..),
      newGoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes,
  
      -- * GoogleBigtableAdminV2TypeStructEncodingSingleton
      GoogleBigtableAdminV2TypeStructEncodingSingleton (..),
      newGoogleBigtableAdminV2TypeStructEncodingSingleton,
  
      -- * GoogleBigtableAdminV2TypeStructField
      GoogleBigtableAdminV2TypeStructField (..),
      newGoogleBigtableAdminV2TypeStructField,
  
      -- * GoogleBigtableAdminV2TypeTimestamp
      GoogleBigtableAdminV2TypeTimestamp (..),
      newGoogleBigtableAdminV2TypeTimestamp,
  
      -- * GoogleBigtableAdminV2TypeTimestampEncoding
      GoogleBigtableAdminV2TypeTimestampEncoding (..),
      newGoogleBigtableAdminV2TypeTimestampEncoding,
  
      -- * HotTablet
      HotTablet (..),
      newHotTablet,
  
      -- * Instance
      Instance (..),
      newInstance,
  
      -- * Instance_Labels
      Instance_Labels (..),
      newInstance_Labels,
  
      -- * Intersection
      Intersection (..),
      newIntersection,
  
      -- * ListAppProfilesResponse
      ListAppProfilesResponse (..),
      newListAppProfilesResponse,
  
      -- * ListAuthorizedViewsResponse
      ListAuthorizedViewsResponse (..),
      newListAuthorizedViewsResponse,
  
      -- * ListBackupsResponse
      ListBackupsResponse (..),
      newListBackupsResponse,
  
      -- * ListClustersResponse
      ListClustersResponse (..),
      newListClustersResponse,
  
      -- * ListHotTabletsResponse
      ListHotTabletsResponse (..),
      newListHotTabletsResponse,
  
      -- * ListInstancesResponse
      ListInstancesResponse (..),
      newListInstancesResponse,
  
      -- * ListLocationsResponse
      ListLocationsResponse (..),
      newListLocationsResponse,
  
      -- * ListOperationsResponse
      ListOperationsResponse (..),
      newListOperationsResponse,
  
      -- * ListTablesResponse
      ListTablesResponse (..),
      newListTablesResponse,
  
      -- * Location
      Location (..),
      newLocation,
  
      -- * Location_Labels
      Location_Labels (..),
      newLocation_Labels,
  
      -- * Location_Metadata
      Location_Metadata (..),
      newLocation_Metadata,
  
      -- * Modification
      Modification (..),
      newModification,
  
      -- * ModifyColumnFamiliesRequest
      ModifyColumnFamiliesRequest (..),
      newModifyColumnFamiliesRequest,
  
      -- * MultiClusterRoutingUseAny
      MultiClusterRoutingUseAny (..),
      newMultiClusterRoutingUseAny,
  
      -- * Operation
      Operation (..),
      newOperation,
  
      -- * Operation_Metadata
      Operation_Metadata (..),
      newOperation_Metadata,
  
      -- * Operation_Response
      Operation_Response (..),
      newOperation_Response,
  
      -- * OperationProgress
      OperationProgress (..),
      newOperationProgress,
  
      -- * OptimizeRestoredTableMetadata
      OptimizeRestoredTableMetadata (..),
      newOptimizeRestoredTableMetadata,
  
      -- * PartialUpdateClusterMetadata
      PartialUpdateClusterMetadata (..),
      newPartialUpdateClusterMetadata,
  
      -- * PartialUpdateClusterRequest
      PartialUpdateClusterRequest (..),
      newPartialUpdateClusterRequest,
  
      -- * PartialUpdateInstanceRequest
      PartialUpdateInstanceRequest (..),
      newPartialUpdateInstanceRequest,
  
      -- * Policy
      Policy (..),
      newPolicy,
  
      -- * RestoreInfo
      RestoreInfo (..),
      newRestoreInfo,
  
      -- * RestoreTableMetadata
      RestoreTableMetadata (..),
      newRestoreTableMetadata,
  
      -- * RestoreTableRequest
      RestoreTableRequest (..),
      newRestoreTableRequest,
  
      -- * RowAffinity
      RowAffinity (..),
      newRowAffinity,
  
      -- * SetIamPolicyRequest
      SetIamPolicyRequest (..),
      newSetIamPolicyRequest,
  
      -- * SingleClusterRouting
      SingleClusterRouting (..),
      newSingleClusterRouting,
  
      -- * Split
      Split (..),
      newSplit,
  
      -- * StandardIsolation
      StandardIsolation (..),
      newStandardIsolation,
  
      -- * StandardReadRemoteWrites
      StandardReadRemoteWrites (..),
      newStandardReadRemoteWrites,
  
      -- * Status
      Status (..),
      newStatus,
  
      -- * Status_DetailsItem
      Status_DetailsItem (..),
      newStatus_DetailsItem,
  
      -- * Table
      Table (..),
      newTable,
  
      -- * Table_ClusterStates
      Table_ClusterStates (..),
      newTable_ClusterStates,
  
      -- * Table_ColumnFamilies
      Table_ColumnFamilies (..),
      newTable_ColumnFamilies,
  
      -- * TableProgress
      TableProgress (..),
      newTableProgress,
  
      -- * TableStats
      TableStats (..),
      newTableStats,
  
      -- * TestIamPermissionsRequest
      TestIamPermissionsRequest (..),
      newTestIamPermissionsRequest,
  
      -- * TestIamPermissionsResponse
      TestIamPermissionsResponse (..),
      newTestIamPermissionsResponse,
  
      -- * Type
      Type (..),
      newType,
  
      -- * UndeleteTableMetadata
      UndeleteTableMetadata (..),
      newUndeleteTableMetadata,
  
      -- * UndeleteTableRequest
      UndeleteTableRequest (..),
      newUndeleteTableRequest,
  
      -- * Union
      Union (..),
      newUnion,
  
      -- * UpdateAppProfileMetadata
      UpdateAppProfileMetadata (..),
      newUpdateAppProfileMetadata,
  
      -- * UpdateAuthorizedViewMetadata
      UpdateAuthorizedViewMetadata (..),
      newUpdateAuthorizedViewMetadata,
  
      -- * UpdateAuthorizedViewRequest
      UpdateAuthorizedViewRequest (..),
      newUpdateAuthorizedViewRequest,
  
      -- * UpdateClusterMetadata
      UpdateClusterMetadata (..),
      newUpdateClusterMetadata,
  
      -- * UpdateInstanceMetadata
      UpdateInstanceMetadata (..),
      newUpdateInstanceMetadata,
  
      -- * UpdateTableMetadata
      UpdateTableMetadata (..),
      newUpdateTableMetadata,
    )
  where
  
  import Gogol.BigtableAdmin.Internal.Sum
  import Gogol.Prelude qualified as Core
  
  -- | A configuration object describing how Cloud Bigtable should treat traffic from a particular end user application.
  --
  -- /See:/ 'newAppProfile' smart constructor.
  data AppProfile = AppProfile
    { -- | Specifies that this app profile is intended for read-only usage via the Data Boost feature.
      dataBoostIsolationReadOnly :: (Core.Maybe DataBoostIsolationReadOnly),
      -- | Long form description of the use case for this AppProfile.
      description :: (Core.Maybe Core.Text),
      -- | Strongly validated etag for optimistic concurrency control. Preserve the value returned from @GetAppProfile@ when calling @UpdateAppProfile@ to fail the request if there has been a modification in the mean time. The @update_mask@ of the request need not include @etag@ for this protection to apply. See <https://en.wikipedia.org/wiki/HTTP_ETag Wikipedia> and <https://tools.ietf.org/html/rfc7232#section-2.3 RFC 7232> for more details.
      etag :: (Core.Maybe Core.Text),
      -- | Use a multi-cluster routing policy.
      multiClusterRoutingUseAny :: (Core.Maybe MultiClusterRoutingUseAny),
      -- | The unique name of the app profile. Values are of the form @projects\/{project}\/instances\/{instance}\/appProfiles\/_a-zA-Z0-9*@.
      name :: (Core.Maybe Core.Text),
      -- | This field has been deprecated in favor of @standard_isolation.priority@. If you set this field, @standard_isolation.priority@ will be set instead. The priority of requests sent using this app profile.
      priority :: (Core.Maybe AppProfile_Priority),
      -- | Use a single-cluster routing policy.
      singleClusterRouting :: (Core.Maybe SingleClusterRouting),
      -- | The standard options used for isolating this app profile\'s traffic from other use cases.
      standardIsolation :: (Core.Maybe StandardIsolation)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AppProfile' with the minimum fields required to make a request.
  newAppProfile ::
    AppProfile
  newAppProfile =
    AppProfile
      { dataBoostIsolationReadOnly = Core.Nothing,
        description = Core.Nothing,
        etag = Core.Nothing,
        multiClusterRoutingUseAny = Core.Nothing,
        name = Core.Nothing,
        priority = Core.Nothing,
        singleClusterRouting = Core.Nothing,
        standardIsolation = Core.Nothing
      }
  
  instance Core.FromJSON AppProfile where
    parseJSON =
      Core.withObject
        "AppProfile"
        ( \o ->
            AppProfile
              Core.<$> (o Core..:? "dataBoostIsolationReadOnly")
              Core.<*> (o Core..:? "description")
              Core.<*> (o Core..:? "etag")
              Core.<*> (o Core..:? "multiClusterRoutingUseAny")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "priority")
              Core.<*> (o Core..:? "singleClusterRouting")
              Core.<*> (o Core..:? "standardIsolation")
        )
  
  instance Core.ToJSON AppProfile where
    toJSON AppProfile {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataBoostIsolationReadOnly" Core..=)
                Core.<$> dataBoostIsolationReadOnly,
              ("description" Core..=) Core.<$> description,
              ("etag" Core..=) Core.<$> etag,
              ("multiClusterRoutingUseAny" Core..=)
                Core.<$> multiClusterRoutingUseAny,
              ("name" Core..=) Core.<$> name,
              ("priority" Core..=) Core.<$> priority,
              ("singleClusterRouting" Core..=) Core.<$> singleClusterRouting,
              ("standardIsolation" Core..=) Core.<$> standardIsolation
            ]
        )
  
  -- | Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both @allServices@ and a specific service, the union of the two AuditConfigs is used for that service: the log/types specified in each AuditConfig are enabled, and the exempted/members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { \"audit/configs\": [ { \"service\": \"allServices\", \"audit/log/configs\": [ { \"log/type\": \"DATA/READ\", \"exempted/members\": [ \"user:jose\@example.com\" ] }, { \"log/type\": \"DATA/WRITE\" }, { \"log/type\": \"ADMIN/READ\" } ] }, { \"service\": \"sampleservice.googleapis.com\", \"audit/log/configs\": [ { \"log/type\": \"DATA/READ\" }, { \"log/type\": \"DATA/WRITE\", \"exempted/members\": [ \"user:aliya\@example.com\" ] } ] } ] } For sampleservice, this policy enables DATA/READ, DATA/WRITE and
  -- ADMIN/READ logging. It also exempts @jose\@example.com@ from DATA/READ logging, and @aliya\@example.com@ from DATA/WRITE logging.
  --
  -- /See:/ 'newAuditConfig' smart constructor.
  data AuditConfig = AuditConfig
    { -- | The configuration for logging of each type of permission.
      auditLogConfigs :: (Core.Maybe [AuditLogConfig]),
      -- | Specifies a service that will be enabled for audit logging. For example, @storage.googleapis.com@, @cloudsql.googleapis.com@. @allServices@ is a special value that covers all services.
      service :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuditConfig' with the minimum fields required to make a request.
  newAuditConfig ::
    AuditConfig
  newAuditConfig =
    AuditConfig
      { auditLogConfigs = Core.Nothing,
        service = Core.Nothing
      }
  
  instance Core.FromJSON AuditConfig where
    parseJSON =
      Core.withObject
        "AuditConfig"
        ( \o ->
            AuditConfig
              Core.<$> (o Core..:? "auditLogConfigs")
              Core.<*> (o Core..:? "service")
        )
  
  instance Core.ToJSON AuditConfig where
    toJSON AuditConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("auditLogConfigs" Core..=) Core.<$> auditLogConfigs,
              ("service" Core..=) Core.<$> service
            ]
        )
  
  -- | Provides the configuration for logging a type of permissions. Example: { \"audit/log/configs\": [ { \"log/type\": \"DATA/READ\", \"exempted/members\": [ \"user:jose\@example.com\" ] }, { \"log/type\": \"DATA/WRITE\" } ] } This enables \'DATA/READ\' and \'DATA/WRITE\' logging, while exempting jose\@example.com from DATA/READ logging.
  --
  -- /See:/ 'newAuditLogConfig' smart constructor.
  data AuditLogConfig = AuditLogConfig
    { -- | Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
      exemptedMembers :: (Core.Maybe [Core.Text]),
      -- | The log type that this config enables.
      logType :: (Core.Maybe AuditLogConfig_LogType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuditLogConfig' with the minimum fields required to make a request.
  newAuditLogConfig ::
    AuditLogConfig
  newAuditLogConfig =
    AuditLogConfig
      { exemptedMembers = Core.Nothing,
        logType = Core.Nothing
      }
  
  instance Core.FromJSON AuditLogConfig where
    parseJSON =
      Core.withObject
        "AuditLogConfig"
        ( \o ->
            AuditLogConfig
              Core.<$> (o Core..:? "exemptedMembers")
              Core.<*> (o Core..:? "logType")
        )
  
  instance Core.ToJSON AuditLogConfig where
    toJSON AuditLogConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("exemptedMembers" Core..=) Core.<$> exemptedMembers,
              ("logType" Core..=) Core.<$> logType
            ]
        )
  
  -- | An Authorized View of a Cloud Bigtable Table.
  --
  -- /See:/ 'newAuthorizedView' smart constructor.
  data AuthorizedView = AuthorizedView
    { -- | Set to true to make the AuthorizedView protected against deletion. The parent Table and containing Instance cannot be deleted if an AuthorizedView has this bit set.
      deletionProtection :: (Core.Maybe Core.Bool),
      -- | The etag for this AuthorizedView. If this is provided on update, it must match the server\'s etag. The server returns ABORTED error on a mismatched etag.
      etag :: (Core.Maybe Core.Text),
      -- | Identifier. The name of this AuthorizedView. Values are of the form @projects\/{project}\/instances\/{instance}\/tables\/{table}\/authorizedViews\/{authorized_view}@
      name :: (Core.Maybe Core.Text),
      -- | An AuthorizedView permitting access to an explicit subset of a Table.
      subsetView :: (Core.Maybe GoogleBigtableAdminV2AuthorizedViewSubsetView)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuthorizedView' with the minimum fields required to make a request.
  newAuthorizedView ::
    AuthorizedView
  newAuthorizedView =
    AuthorizedView
      { deletionProtection = Core.Nothing,
        etag = Core.Nothing,
        name = Core.Nothing,
        subsetView = Core.Nothing
      }
  
  instance Core.FromJSON AuthorizedView where
    parseJSON =
      Core.withObject
        "AuthorizedView"
        ( \o ->
            AuthorizedView
              Core.<$> (o Core..:? "deletionProtection")
              Core.<*> (o Core..:? "etag")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "subsetView")
        )
  
  instance Core.ToJSON AuthorizedView where
    toJSON AuthorizedView {..} =
      Core.object
        ( Core.catMaybes
            [ ("deletionProtection" Core..=) Core.<$> deletionProtection,
              ("etag" Core..=) Core.<$> etag,
              ("name" Core..=) Core.<$> name,
              ("subsetView" Core..=) Core.<$> subsetView
            ]
        )
  
  -- | Defines an automated backup policy for a table
  --
  -- /See:/ 'newAutomatedBackupPolicy' smart constructor.
  data AutomatedBackupPolicy = AutomatedBackupPolicy
    { -- | How frequently automated backups should occur. The only supported value at this time is 24 hours. An undefined frequency is treated as 24 hours.
      frequency :: (Core.Maybe Core.Duration),
      -- | Required. How long the automated backups should be retained. Values must be at least 3 days and at most 90 days.
      retentionPeriod :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AutomatedBackupPolicy' with the minimum fields required to make a request.
  newAutomatedBackupPolicy ::
    AutomatedBackupPolicy
  newAutomatedBackupPolicy =
    AutomatedBackupPolicy
      { frequency = Core.Nothing,
        retentionPeriod = Core.Nothing
      }
  
  instance Core.FromJSON AutomatedBackupPolicy where
    parseJSON =
      Core.withObject
        "AutomatedBackupPolicy"
        ( \o ->
            AutomatedBackupPolicy
              Core.<$> (o Core..:? "frequency")
              Core.<*> (o Core..:? "retentionPeriod")
        )
  
  instance Core.ToJSON AutomatedBackupPolicy where
    toJSON AutomatedBackupPolicy {..} =
      Core.object
        ( Core.catMaybes
            [ ("frequency" Core..=) Core.<$> frequency,
              ("retentionPeriod" Core..=) Core.<$> retentionPeriod
            ]
        )
  
  -- | Limits for the number of nodes a Cluster can autoscale up\/down to.
  --
  -- /See:/ 'newAutoscalingLimits' smart constructor.
  data AutoscalingLimits = AutoscalingLimits
    { -- | Required. Maximum number of nodes to scale up to.
      maxServeNodes :: (Core.Maybe Core.Int32),
      -- | Required. Minimum number of nodes to scale down to.
      minServeNodes :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AutoscalingLimits' with the minimum fields required to make a request.
  newAutoscalingLimits ::
    AutoscalingLimits
  newAutoscalingLimits =
    AutoscalingLimits
      { maxServeNodes = Core.Nothing,
        minServeNodes = Core.Nothing
      }
  
  instance Core.FromJSON AutoscalingLimits where
    parseJSON =
      Core.withObject
        "AutoscalingLimits"
        ( \o ->
            AutoscalingLimits
              Core.<$> (o Core..:? "maxServeNodes")
              Core.<*> (o Core..:? "minServeNodes")
        )
  
  instance Core.ToJSON AutoscalingLimits where
    toJSON AutoscalingLimits {..} =
      Core.object
        ( Core.catMaybes
            [ ("maxServeNodes" Core..=) Core.<$> maxServeNodes,
              ("minServeNodes" Core..=) Core.<$> minServeNodes
            ]
        )
  
  -- | The Autoscaling targets for a Cluster. These determine the recommended nodes.
  --
  -- /See:/ 'newAutoscalingTargets' smart constructor.
  data AutoscalingTargets = AutoscalingTargets
    { -- | The cpu utilization that the Autoscaler should be trying to achieve. This number is on a scale from 0 (no utilization) to 100 (total utilization), and is limited between 10 and 80, otherwise it will return INVALID_ARGUMENT error.
      cpuUtilizationPercent :: (Core.Maybe Core.Int32),
      -- | The storage utilization that the Autoscaler should be trying to achieve. This number is limited between 2560 (2.5TiB) and 5120 (5TiB) for a SSD cluster and between 8192 (8TiB) and 16384 (16TiB) for an HDD cluster, otherwise it will return INVALID_ARGUMENT error. If this value is set to 0, it will be treated as if it were set to the default value: 2560 for SSD, 8192 for HDD.
      storageUtilizationGibPerNode :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AutoscalingTargets' with the minimum fields required to make a request.
  newAutoscalingTargets ::
    AutoscalingTargets
  newAutoscalingTargets =
    AutoscalingTargets
      { cpuUtilizationPercent = Core.Nothing,
        storageUtilizationGibPerNode = Core.Nothing
      }
  
  instance Core.FromJSON AutoscalingTargets where
    parseJSON =
      Core.withObject
        "AutoscalingTargets"
        ( \o ->
            AutoscalingTargets
              Core.<$> (o Core..:? "cpuUtilizationPercent")
              Core.<*> (o Core..:? "storageUtilizationGibPerNode")
        )
  
  instance Core.ToJSON AutoscalingTargets where
    toJSON AutoscalingTargets {..} =
      Core.object
        ( Core.catMaybes
            [ ("cpuUtilizationPercent" Core..=) Core.<$> cpuUtilizationPercent,
              ("storageUtilizationGibPerNode" Core..=)
                Core.<$> storageUtilizationGibPerNode
            ]
        )
  
  -- | A backup of a Cloud Bigtable table.
  --
  -- /See:/ 'newBackup' smart constructor.
  data Backup = Backup
    { -- | Indicates the backup type of the backup.
      backupType :: (Core.Maybe Backup_BackupType),
      -- | Output only. The encryption information for the backup.
      encryptionInfo :: (Core.Maybe EncryptionInfo),
      -- | Output only. @end_time@ is the time that the backup was finished. The row data in the backup will be no newer than this timestamp.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Required. The expiration time of the backup. When creating a backup or updating its @expire_time@, the value must be greater than the backup creation time by: - At least 6 hours - At most 90 days Once the @expire_time@ has passed, Cloud Bigtable will delete the backup.
      expireTime :: (Core.Maybe Core.DateTime),
      -- | The time at which the hot backup will be converted to a standard backup. Once the @hot_to_standard_time@ has passed, Cloud Bigtable will convert the hot backup to a standard backup. This value must be greater than the backup creation time by: - At least 24 hours This field only applies for hot backups. When creating or updating a standard backup, attempting to set this field will fail the request.
      hotToStandardTime :: (Core.Maybe Core.DateTime),
      -- | A globally unique identifier for the backup which cannot be changed. Values are of the form @projects\/{project}\/instances\/{instance}\/clusters\/{cluster}\/ backups\/_a-zA-Z0-9*@ The final segment of the name must be between 1 and 50 characters in length. The backup is stored in the cluster identified by the prefix of the backup name of the form @projects\/{project}\/instances\/{instance}\/clusters\/{cluster}@.
      name :: (Core.Maybe Core.Text),
      -- | Output only. Size of the backup in bytes.
      sizeBytes :: (Core.Maybe Core.Int64),
      -- | Output only. Name of the backup from which this backup was copied. If a backup is not created by copying a backup, this field will be empty. Values are of the form: projects\/\/instances\/\/clusters\/\/backups\/
      sourceBackup :: (Core.Maybe Core.Text),
      -- | Required. Immutable. Name of the table from which this backup was created. This needs to be in the same instance as the backup. Values are of the form @projects\/{project}\/instances\/{instance}\/tables\/{source_table}@.
      sourceTable :: (Core.Maybe Core.Text),
      -- | Output only. @start_time@ is the time that the backup was started (i.e. approximately the time the CreateBackup request is received). The row data in this backup will be no older than this timestamp.
      startTime :: (Core.Maybe Core.DateTime),
      -- | Output only. The current state of the backup.
      state :: (Core.Maybe Backup_State)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Backup' with the minimum fields required to make a request.
  newBackup ::
    Backup
  newBackup =
    Backup
      { backupType = Core.Nothing,
        encryptionInfo = Core.Nothing,
        endTime = Core.Nothing,
        expireTime = Core.Nothing,
        hotToStandardTime = Core.Nothing,
        name = Core.Nothing,
        sizeBytes = Core.Nothing,
        sourceBackup = Core.Nothing,
        sourceTable = Core.Nothing,
        startTime = Core.Nothing,
        state = Core.Nothing
      }
  
  instance Core.FromJSON Backup where
    parseJSON =
      Core.withObject
        "Backup"
        ( \o ->
            Backup
              Core.<$> (o Core..:? "backupType")
              Core.<*> (o Core..:? "encryptionInfo")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "expireTime")
              Core.<*> (o Core..:? "hotToStandardTime")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "sizeBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "sourceBackup")
              Core.<*> (o Core..:? "sourceTable")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "state")
        )
  
  instance Core.ToJSON Backup where
    toJSON Backup {..} =
      Core.object
        ( Core.catMaybes
            [ ("backupType" Core..=) Core.<$> backupType,
              ("encryptionInfo" Core..=) Core.<$> encryptionInfo,
              ("endTime" Core..=) Core.<$> endTime,
              ("expireTime" Core..=) Core.<$> expireTime,
              ("hotToStandardTime" Core..=) Core.<$> hotToStandardTime,
              ("name" Core..=) Core.<$> name,
              ("sizeBytes" Core..=) Core.. Core.AsText Core.<$> sizeBytes,
              ("sourceBackup" Core..=) Core.<$> sourceBackup,
              ("sourceTable" Core..=) Core.<$> sourceTable,
              ("startTime" Core..=) Core.<$> startTime,
              ("state" Core..=) Core.<$> state
            ]
        )
  
  -- | Information about a backup.
  --
  -- /See:/ 'newBackupInfo' smart constructor.
  data BackupInfo = BackupInfo
    { -- | Output only. Name of the backup.
      backup :: (Core.Maybe Core.Text),
      -- | Output only. This time that the backup was finished. Row data in the backup will be no newer than this timestamp.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Output only. Name of the backup from which this backup was copied. If a backup is not created by copying a backup, this field will be empty. Values are of the form: projects\/\/instances\/\/clusters\/\/backups\/
      sourceBackup :: (Core.Maybe Core.Text),
      -- | Output only. Name of the table the backup was created from.
      sourceTable :: (Core.Maybe Core.Text),
      -- | Output only. The time that the backup was started. Row data in the backup will be no older than this timestamp.
      startTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BackupInfo' with the minimum fields required to make a request.
  newBackupInfo ::
    BackupInfo
  newBackupInfo =
    BackupInfo
      { backup = Core.Nothing,
        endTime = Core.Nothing,
        sourceBackup = Core.Nothing,
        sourceTable = Core.Nothing,
        startTime = Core.Nothing
      }
  
  instance Core.FromJSON BackupInfo where
    parseJSON =
      Core.withObject
        "BackupInfo"
        ( \o ->
            BackupInfo
              Core.<$> (o Core..:? "backup")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "sourceBackup")
              Core.<*> (o Core..:? "sourceTable")
              Core.<*> (o Core..:? "startTime")
        )
  
  instance Core.ToJSON BackupInfo where
    toJSON BackupInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("backup" Core..=) Core.<$> backup,
              ("endTime" Core..=) Core.<$> endTime,
              ("sourceBackup" Core..=) Core.<$> sourceBackup,
              ("sourceTable" Core..=) Core.<$> sourceTable,
              ("startTime" Core..=) Core.<$> startTime
            ]
        )
  
  -- | Associates @members@, or principals, with a @role@.
  --
  -- /See:/ 'newBinding' smart constructor.
  data Binding = Binding
    { -- | The condition that is associated with this binding. If the condition evaluates to @true@, then this binding applies to the current request. If the condition evaluates to @false@, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the <https://cloud.google.com/iam/help/conditions/resource-policies IAM documentation>.
      condition :: (Core.Maybe Expr),
      -- | Specifies the principals requesting access for a Google Cloud resource. @members@ can have the following values: * @allUsers@: A special identifier that represents anyone who is on the internet; with or without a Google account. * @allAuthenticatedUsers@: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * @user:{emailid}@: An email address that represents a specific Google account. For example, @alice\@example.com@ . * @serviceAccount:{emailid}@: An email address that represents a Google service account. For example, @my-other-app\@appspot.gserviceaccount.com@. * @serviceAccount:{projectid}.svc.id.goog[{namespace}\/{kubernetes-sa}]@: An identifier for a <https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts Kubernetes service account>. For example, @my-project.svc.id.goog[my-namespace\/my-kubernetes-sa]@. *
      -- @group:{emailid}@: An email address that represents a Google group. For example, @admins\@example.com@. * @domain:{domain}@: The G Suite domain (primary) that represents all the users of that domain. For example, @google.com@ or @example.com@. * @principal:\/\/iam.googleapis.com\/locations\/global\/workforcePools\/{pool_id}\/subject\/{subject_attribute_value}@: A single identity in a workforce identity pool. * @principalSet:\/\/iam.googleapis.com\/locations\/global\/workforcePools\/{pool_id}\/group\/{group_id}@: All workforce identities in a group. * @principalSet:\/\/iam.googleapis.com\/locations\/global\/workforcePools\/{pool_id}\/attribute.{attribute_name}\/{attribute_value}@: All workforce identities with a specific attribute value. * @principalSet:\/\/iam.googleapis.com\/locations\/global\/workforcePools\/{pool_id}\/*@: All identities in a workforce identity pool. *
      -- @principal:\/\/iam.googleapis.com\/projects\/{project_number}\/locations\/global\/workloadIdentityPools\/{pool_id}\/subject\/{subject_attribute_value}@: A single identity in a workload identity pool. * @principalSet:\/\/iam.googleapis.com\/projects\/{project_number}\/locations\/global\/workloadIdentityPools\/{pool_id}\/group\/{group_id}@: A workload identity pool group. * @principalSet:\/\/iam.googleapis.com\/projects\/{project_number}\/locations\/global\/workloadIdentityPools\/{pool_id}\/attribute.{attribute_name}\/{attribute_value}@: All identities in a workload identity pool with a certain attribute. * @principalSet:\/\/iam.googleapis.com\/projects\/{project_number}\/locations\/global\/workloadIdentityPools\/{pool_id}\/*@: All identities in a workload identity pool. * @deleted:user:{emailid}?uid={uniqueid}@: An email address (plus unique identifier) representing a user that has been recently deleted. For example, @alice\@example.com?uid=123456789012345678901@. If the user is recovered, this value reverts
      -- to @user:{emailid}@ and the recovered user retains the role in the binding. * @deleted:serviceAccount:{emailid}?uid={uniqueid}@: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, @my-other-app\@appspot.gserviceaccount.com?uid=123456789012345678901@. If the service account is undeleted, this value reverts to @serviceAccount:{emailid}@ and the undeleted service account retains the role in the binding. * @deleted:group:{emailid}?uid={uniqueid}@: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, @admins\@example.com?uid=123456789012345678901@. If the group is recovered, this value reverts to @group:{emailid}@ and the recovered group retains the role in the binding. * @deleted:principal:\/\/iam.googleapis.com\/locations\/global\/workforcePools\/{pool_id}\/subject\/{subject_attribute_value}@: Deleted single identity in a workforce identity pool. For example,
      -- @deleted:principal:\/\/iam.googleapis.com\/locations\/global\/workforcePools\/my-pool-id\/subject\/my-subject-attribute-value@.
      members :: (Core.Maybe [Core.Text]),
      -- | Role that is assigned to the list of @members@, or principals. For example, @roles\/viewer@, @roles\/editor@, or @roles\/owner@. For an overview of the IAM roles and permissions, see the <https://cloud.google.com/iam/docs/roles-overview IAM documentation>. For a list of the available pre-defined roles, see <https://cloud.google.com/iam/docs/understanding-roles here>.
      role' :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Binding' with the minimum fields required to make a request.
  newBinding ::
    Binding
  newBinding =
    Binding
      { condition = Core.Nothing,
        members = Core.Nothing,
        role' = Core.Nothing
      }
  
  instance Core.FromJSON Binding where
    parseJSON =
      Core.withObject
        "Binding"
        ( \o ->
            Binding
              Core.<$> (o Core..:? "condition")
              Core.<*> (o Core..:? "members")
              Core.<*> (o Core..:? "role")
        )
  
  instance Core.ToJSON Binding where
    toJSON Binding {..} =
      Core.object
        ( Core.catMaybes
            [ ("condition" Core..=) Core.<$> condition,
              ("members" Core..=) Core.<$> members,
              ("role" Core..=) Core.<$> role'
            ]
        )
  
  -- | Change stream configuration.
  --
  -- /See:/ 'newChangeStreamConfig' smart constructor.
  newtype ChangeStreamConfig = ChangeStreamConfig
    { -- | How long the change stream should be retained. Change stream data older than the retention period will not be returned when reading the change stream from the table. Values must be at least 1 day and at most 7 days, and will be truncated to microsecond granularity.
      retentionPeriod :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ChangeStreamConfig' with the minimum fields required to make a request.
  newChangeStreamConfig ::
    ChangeStreamConfig
  newChangeStreamConfig =
    ChangeStreamConfig {retentionPeriod = Core.Nothing}
  
  instance Core.FromJSON ChangeStreamConfig where
    parseJSON =
      Core.withObject
        "ChangeStreamConfig"
        (\o -> ChangeStreamConfig Core.<$> (o Core..:? "retentionPeriod"))
  
  instance Core.ToJSON ChangeStreamConfig where
    toJSON ChangeStreamConfig {..} =
      Core.object
        ( Core.catMaybes
            [("retentionPeriod" Core..=) Core.<$> retentionPeriod]
        )
  
  -- | Request message for google.bigtable.admin.v2.BigtableTableAdmin.CheckConsistency
  --
  -- /See:/ 'newCheckConsistencyRequest' smart constructor.
  data CheckConsistencyRequest = CheckConsistencyRequest
    { -- | Required. The token created using GenerateConsistencyToken for the Table.
      consistencyToken :: (Core.Maybe Core.Text),
      -- | Checks that reads using an app profile with @DataBoostIsolationReadOnly@ can see all writes committed before the token was created, but only if the read and write target the same cluster.
      dataBoostReadLocalWrites :: (Core.Maybe DataBoostReadLocalWrites),
      -- | Checks that reads using an app profile with @StandardIsolation@ can see all writes committed before the token was created, even if the read and write target different clusters.
      standardReadRemoteWrites :: (Core.Maybe StandardReadRemoteWrites)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckConsistencyRequest' with the minimum fields required to make a request.
  newCheckConsistencyRequest ::
    CheckConsistencyRequest
  newCheckConsistencyRequest =
    CheckConsistencyRequest
      { consistencyToken = Core.Nothing,
        dataBoostReadLocalWrites = Core.Nothing,
        standardReadRemoteWrites = Core.Nothing
      }
  
  instance Core.FromJSON CheckConsistencyRequest where
    parseJSON =
      Core.withObject
        "CheckConsistencyRequest"
        ( \o ->
            CheckConsistencyRequest
              Core.<$> (o Core..:? "consistencyToken")
              Core.<*> (o Core..:? "dataBoostReadLocalWrites")
              Core.<*> (o Core..:? "standardReadRemoteWrites")
        )
  
  instance Core.ToJSON CheckConsistencyRequest where
    toJSON CheckConsistencyRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("consistencyToken" Core..=) Core.<$> consistencyToken,
              ("dataBoostReadLocalWrites" Core..=)
                Core.<$> dataBoostReadLocalWrites,
              ("standardReadRemoteWrites" Core..=)
                Core.<$> standardReadRemoteWrites
            ]
        )
  
  -- | Response message for google.bigtable.admin.v2.BigtableTableAdmin.CheckConsistency
  --
  -- /See:/ 'newCheckConsistencyResponse' smart constructor.
  newtype CheckConsistencyResponse = CheckConsistencyResponse
    { -- | True only if the token is consistent. A token is consistent if replication has caught up with the restrictions specified in the request.
      consistent :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckConsistencyResponse' with the minimum fields required to make a request.
  newCheckConsistencyResponse ::
    CheckConsistencyResponse
  newCheckConsistencyResponse =
    CheckConsistencyResponse {consistent = Core.Nothing}
  
  instance Core.FromJSON CheckConsistencyResponse where
    parseJSON =
      Core.withObject
        "CheckConsistencyResponse"
        ( \o ->
            CheckConsistencyResponse Core.<$> (o Core..:? "consistent")
        )
  
  instance Core.ToJSON CheckConsistencyResponse where
    toJSON CheckConsistencyResponse {..} =
      Core.object
        (Core.catMaybes [("consistent" Core..=) Core.<$> consistent])
  
  -- | A resizable group of nodes in a particular cloud location, capable of serving all Tables in the parent Instance.
  --
  -- /See:/ 'newCluster' smart constructor.
  data Cluster = Cluster
    { -- | Configuration for this cluster.
      clusterConfig :: (Core.Maybe ClusterConfig),
      -- | Immutable. The type of storage used by this cluster to serve its parent instance\'s tables, unless explicitly overridden.
      defaultStorageType :: (Core.Maybe Cluster_DefaultStorageType),
      -- | Immutable. The encryption configuration for CMEK-protected clusters.
      encryptionConfig :: (Core.Maybe EncryptionConfig),
      -- | Immutable. The location where this cluster\'s nodes and storage reside. For best performance, clients should be located as close as possible to this cluster. Currently only zones are supported, so values should be of the form @projects\/{project}\/locations\/{zone}@.
      location :: (Core.Maybe Core.Text),
      -- | The unique name of the cluster. Values are of the form @projects\/{project}\/instances\/{instance}\/clusters\/a-z*@.
      name :: (Core.Maybe Core.Text),
      -- | Immutable. The node scaling factor of this cluster.
      nodeScalingFactor :: (Core.Maybe Cluster_NodeScalingFactor),
      -- | The number of nodes in the cluster. If no value is set, Cloud Bigtable automatically allocates nodes based on your data footprint and optimized for 50% storage utilization.
      serveNodes :: (Core.Maybe Core.Int32),
      -- | Output only. The current state of the cluster.
      state :: (Core.Maybe Cluster_State)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Cluster' with the minimum fields required to make a request.
  newCluster ::
    Cluster
  newCluster =
    Cluster
      { clusterConfig = Core.Nothing,
        defaultStorageType = Core.Nothing,
        encryptionConfig = Core.Nothing,
        location = Core.Nothing,
        name = Core.Nothing,
        nodeScalingFactor = Core.Nothing,
        serveNodes = Core.Nothing,
        state = Core.Nothing
      }
  
  instance Core.FromJSON Cluster where
    parseJSON =
      Core.withObject
        "Cluster"
        ( \o ->
            Cluster
              Core.<$> (o Core..:? "clusterConfig")
              Core.<*> (o Core..:? "defaultStorageType")
              Core.<*> (o Core..:? "encryptionConfig")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "nodeScalingFactor")
              Core.<*> (o Core..:? "serveNodes")
              Core.<*> (o Core..:? "state")
        )
  
  instance Core.ToJSON Cluster where
    toJSON Cluster {..} =
      Core.object
        ( Core.catMaybes
            [ ("clusterConfig" Core..=) Core.<$> clusterConfig,
              ("defaultStorageType" Core..=) Core.<$> defaultStorageType,
              ("encryptionConfig" Core..=) Core.<$> encryptionConfig,
              ("location" Core..=) Core.<$> location,
              ("name" Core..=) Core.<$> name,
              ("nodeScalingFactor" Core..=) Core.<$> nodeScalingFactor,
              ("serveNodes" Core..=) Core.<$> serveNodes,
              ("state" Core..=) Core.<$> state
            ]
        )
  
  -- | Autoscaling config for a cluster.
  --
  -- /See:/ 'newClusterAutoscalingConfig' smart constructor.
  data ClusterAutoscalingConfig = ClusterAutoscalingConfig
    { -- | Required. Autoscaling limits for this cluster.
      autoscalingLimits :: (Core.Maybe AutoscalingLimits),
      -- | Required. Autoscaling targets for this cluster.
      autoscalingTargets :: (Core.Maybe AutoscalingTargets)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ClusterAutoscalingConfig' with the minimum fields required to make a request.
  newClusterAutoscalingConfig ::
    ClusterAutoscalingConfig
  newClusterAutoscalingConfig =
    ClusterAutoscalingConfig
      { autoscalingLimits = Core.Nothing,
        autoscalingTargets = Core.Nothing
      }
  
  instance Core.FromJSON ClusterAutoscalingConfig where
    parseJSON =
      Core.withObject
        "ClusterAutoscalingConfig"
        ( \o ->
            ClusterAutoscalingConfig
              Core.<$> (o Core..:? "autoscalingLimits")
              Core.<*> (o Core..:? "autoscalingTargets")
        )
  
  instance Core.ToJSON ClusterAutoscalingConfig where
    toJSON ClusterAutoscalingConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("autoscalingLimits" Core..=) Core.<$> autoscalingLimits,
              ("autoscalingTargets" Core..=) Core.<$> autoscalingTargets
            ]
        )
  
  -- | Configuration for a cluster.
  --
  -- /See:/ 'newClusterConfig' smart constructor.
  newtype ClusterConfig = ClusterConfig
    { -- | Autoscaling configuration for this cluster.
      clusterAutoscalingConfig :: (Core.Maybe ClusterAutoscalingConfig)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ClusterConfig' with the minimum fields required to make a request.
  newClusterConfig ::
    ClusterConfig
  newClusterConfig =
    ClusterConfig {clusterAutoscalingConfig = Core.Nothing}
  
  instance Core.FromJSON ClusterConfig where
    parseJSON =
      Core.withObject
        "ClusterConfig"
        ( \o ->
            ClusterConfig Core.<$> (o Core..:? "clusterAutoscalingConfig")
        )
  
  instance Core.ToJSON ClusterConfig where
    toJSON ClusterConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("clusterAutoscalingConfig" Core..=)
                Core.<$> clusterAutoscalingConfig
            ]
        )
  
  -- | The state of a table\'s data in a particular cluster.
  --
  -- /See:/ 'newClusterState' smart constructor.
  data ClusterState = ClusterState
    { -- | Output only. The encryption information for the table in this cluster. If the encryption key protecting this resource is customer managed, then its version can be rotated in Cloud Key Management Service (Cloud KMS). The primary version of the key and its status will be reflected here when changes propagate from Cloud KMS.
      encryptionInfo :: (Core.Maybe [EncryptionInfo]),
      -- | Output only. The state of replication for the table in this cluster.
      replicationState :: (Core.Maybe ClusterState_ReplicationState)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ClusterState' with the minimum fields required to make a request.
  newClusterState ::
    ClusterState
  newClusterState =
    ClusterState
      { encryptionInfo = Core.Nothing,
        replicationState = Core.Nothing
      }
  
  instance Core.FromJSON ClusterState where
    parseJSON =
      Core.withObject
        "ClusterState"
        ( \o ->
            ClusterState
              Core.<$> (o Core..:? "encryptionInfo")
              Core.<*> (o Core..:? "replicationState")
        )
  
  instance Core.ToJSON ClusterState where
    toJSON ClusterState {..} =
      Core.object
        ( Core.catMaybes
            [ ("encryptionInfo" Core..=) Core.<$> encryptionInfo,
              ("replicationState" Core..=) Core.<$> replicationState
            ]
        )
  
  -- | A set of columns within a table which share a common configuration.
  --
  -- /See:/ 'newColumnFamily' smart constructor.
  data ColumnFamily = ColumnFamily
    { -- | Garbage collection rule specified as a protobuf. Must serialize to at most 500 bytes. NOTE: Garbage collection executes opportunistically in the background, and so it\'s possible for reads to return a cell even if it matches the active GC expression for its family.
      gcRule :: (Core.Maybe GcRule),
      -- | Output only. Only available with STATS_VIEW, this includes summary statistics about column family contents. For statistics over an entire table, see TableStats above.
      stats :: (Core.Maybe ColumnFamilyStats),
      -- | The type of data stored in each of this family\'s cell values, including its full encoding. If omitted, the family only serves raw untyped bytes. For now, only the @Aggregate@ type is supported. @Aggregate@ can only be set at family creation and is immutable afterwards. If @value_type@ is @Aggregate@, written data must be compatible with: * @value_type.input_type@ for @AddInput@ mutations
      valueType :: (Core.Maybe Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ColumnFamily' with the minimum fields required to make a request.
  newColumnFamily ::
    ColumnFamily
  newColumnFamily =
    ColumnFamily
      { gcRule = Core.Nothing,
        stats = Core.Nothing,
        valueType = Core.Nothing
      }
  
  instance Core.FromJSON ColumnFamily where
    parseJSON =
      Core.withObject
        "ColumnFamily"
        ( \o ->
            ColumnFamily
              Core.<$> (o Core..:? "gcRule")
              Core.<*> (o Core..:? "stats")
              Core.<*> (o Core..:? "valueType")
        )
  
  instance Core.ToJSON ColumnFamily where
    toJSON ColumnFamily {..} =
      Core.object
        ( Core.catMaybes
            [ ("gcRule" Core..=) Core.<$> gcRule,
              ("stats" Core..=) Core.<$> stats,
              ("valueType" Core..=) Core.<$> valueType
            ]
        )
  
  -- | Approximate statistics related to a single column family within a table. This information may change rapidly, interpreting these values at a point in time may already preset out-of-date information. Everything below is approximate, unless otherwise specified.
  --
  -- /See:/ 'newColumnFamilyStats' smart constructor.
  data ColumnFamilyStats = ColumnFamilyStats
    { -- | How many cells are present per column qualifier in this column family, averaged over all rows containing any column in the column family. e.g. For column family \"family\" in a table with 3 rows: * A row with 3 cells in \"family:col\" and 1 cell in \"other:col\" (3 cells \/ 1 column in \"family\") * A row with 1 cell in \"family:col\", 7 cells in \"family:other_col\", and 7 cells in \"other:data\" (8 cells \/ 2 columns in \"family\") * A row with 3 cells in \"other:col\" (0 columns in \"family\", \"family\" not present) would report (3 + 8 + 0)\/(1 + 2 + 0) = 3.66 in this field.
      averageCellsPerColumn :: (Core.Maybe Core.Double),
      -- | How many column qualifiers are present in this column family, averaged over all rows in the table. e.g. For column family \"family\" in a table with 3 rows: * A row with cells in \"family:col\" and \"other:col\" (1 column in \"family\") * A row with cells in \"family:col\", \"family:other_col\", and \"other:data\" (2 columns in \"family\") * A row with cells in \"other:col\" (0 columns in \"family\", \"family\" not present) would report (1 + 2 + 0)\/3 = 1.5 in this field.
      averageColumnsPerRow :: (Core.Maybe Core.Double),
      -- | How much space the data in the column family occupies. This is roughly how many bytes would be needed to read the contents of the entire column family (e.g. by streaming all contents out).
      logicalDataBytes :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ColumnFamilyStats' with the minimum fields required to make a request.
  newColumnFamilyStats ::
    ColumnFamilyStats
  newColumnFamilyStats =
    ColumnFamilyStats
      { averageCellsPerColumn = Core.Nothing,
        averageColumnsPerRow = Core.Nothing,
        logicalDataBytes = Core.Nothing
      }
  
  instance Core.FromJSON ColumnFamilyStats where
    parseJSON =
      Core.withObject
        "ColumnFamilyStats"
        ( \o ->
            ColumnFamilyStats
              Core.<$> (o Core..:? "averageCellsPerColumn")
              Core.<*> (o Core..:? "averageColumnsPerRow")
              Core.<*> (o Core..:? "logicalDataBytes" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON ColumnFamilyStats where
    toJSON ColumnFamilyStats {..} =
      Core.object
        ( Core.catMaybes
            [ ("averageCellsPerColumn" Core..=) Core.<$> averageCellsPerColumn,
              ("averageColumnsPerRow" Core..=) Core.<$> averageColumnsPerRow,
              ("logicalDataBytes" Core..=)
                Core.. Core.AsText
                Core.<$> logicalDataBytes
            ]
        )
  
  -- | Metadata type for the google.longrunning.Operation returned by CopyBackup.
  --
  -- /See:/ 'newCopyBackupMetadata' smart constructor.
  data CopyBackupMetadata = CopyBackupMetadata
    { -- | The name of the backup being created through the copy operation. Values are of the form @projects\/\/instances\/\/clusters\/\/backups\/@.
      name :: (Core.Maybe Core.Text),
      -- | The progress of the CopyBackup operation.
      progress :: (Core.Maybe OperationProgress),
      -- | Information about the source backup that is being copied from.
      sourceBackupInfo :: (Core.Maybe BackupInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CopyBackupMetadata' with the minimum fields required to make a request.
  newCopyBackupMetadata ::
    CopyBackupMetadata
  newCopyBackupMetadata =
    CopyBackupMetadata
      { name = Core.Nothing,
        progress = Core.Nothing,
        sourceBackupInfo = Core.Nothing
      }
  
  instance Core.FromJSON CopyBackupMetadata where
    parseJSON =
      Core.withObject
        "CopyBackupMetadata"
        ( \o ->
            CopyBackupMetadata
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "progress")
              Core.<*> (o Core..:? "sourceBackupInfo")
        )
  
  instance Core.ToJSON CopyBackupMetadata where
    toJSON CopyBackupMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("progress" Core..=) Core.<$> progress,
              ("sourceBackupInfo" Core..=) Core.<$> sourceBackupInfo
            ]
        )
  
  -- | The request for CopyBackup.
  --
  -- /See:/ 'newCopyBackupRequest' smart constructor.
  data CopyBackupRequest = CopyBackupRequest
    { -- | Required. The id of the new backup. The @backup_id@ along with @parent@ are combined as {parent}\/backups\/{backup/id} to create the full backup name, of the form: @projects\/{project}\/instances\/{instance}\/clusters\/{cluster}\/backups\/{backup_id}@. This string must be between 1 and 50 characters in length and match the regex /a-zA-Z0-9*.
      backupId :: (Core.Maybe Core.Text),
      -- | Required. Required. The expiration time of the copied backup with microsecond granularity that must be at least 6 hours and at most 30 days from the time the request is received. Once the @expire_time@ has passed, Cloud Bigtable will delete the backup and free the resources used by the backup.
      expireTime :: (Core.Maybe Core.DateTime),
      -- | Required. The source backup to be copied from. The source backup needs to be in READY state for it to be copied. Copying a copied backup is not allowed. Once CopyBackup is in progress, the source backup cannot be deleted or cleaned up on expiration until CopyBackup is finished. Values are of the form: @projects\/\/instances\/\/clusters\/\/backups\/@.
      sourceBackup :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CopyBackupRequest' with the minimum fields required to make a request.
  newCopyBackupRequest ::
    CopyBackupRequest
  newCopyBackupRequest =
    CopyBackupRequest
      { backupId = Core.Nothing,
        expireTime = Core.Nothing,
        sourceBackup = Core.Nothing
      }
  
  instance Core.FromJSON CopyBackupRequest where
    parseJSON =
      Core.withObject
        "CopyBackupRequest"
        ( \o ->
            CopyBackupRequest
              Core.<$> (o Core..:? "backupId")
              Core.<*> (o Core..:? "expireTime")
              Core.<*> (o Core..:? "sourceBackup")
        )
  
  instance Core.ToJSON CopyBackupRequest where
    toJSON CopyBackupRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("backupId" Core..=) Core.<$> backupId,
              ("expireTime" Core..=) Core.<$> expireTime,
              ("sourceBackup" Core..=) Core.<$> sourceBackup
            ]
        )
  
  -- | The metadata for the Operation returned by CreateAuthorizedView.
  --
  -- /See:/ 'newCreateAuthorizedViewMetadata' smart constructor.
  data CreateAuthorizedViewMetadata = CreateAuthorizedViewMetadata
    { -- | The time at which the operation failed or was completed successfully.
      finishTime :: (Core.Maybe Core.DateTime),
      -- | The request that prompted the initiation of this CreateAuthorizedView operation.
      originalRequest :: (Core.Maybe CreateAuthorizedViewRequest),
      -- | The time at which the original request was received.
      requestTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateAuthorizedViewMetadata' with the minimum fields required to make a request.
  newCreateAuthorizedViewMetadata ::
    CreateAuthorizedViewMetadata
  newCreateAuthorizedViewMetadata =
    CreateAuthorizedViewMetadata
      { finishTime = Core.Nothing,
        originalRequest = Core.Nothing,
        requestTime = Core.Nothing
      }
  
  instance Core.FromJSON CreateAuthorizedViewMetadata where
    parseJSON =
      Core.withObject
        "CreateAuthorizedViewMetadata"
        ( \o ->
            CreateAuthorizedViewMetadata
              Core.<$> (o Core..:? "finishTime")
              Core.<*> (o Core..:? "originalRequest")
              Core.<*> (o Core..:? "requestTime")
        )
  
  instance Core.ToJSON CreateAuthorizedViewMetadata where
    toJSON CreateAuthorizedViewMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("finishTime" Core..=) Core.<$> finishTime,
              ("originalRequest" Core..=) Core.<$> originalRequest,
              ("requestTime" Core..=) Core.<$> requestTime
            ]
        )
  
  -- | The request for CreateAuthorizedView
  --
  -- /See:/ 'newCreateAuthorizedViewRequest' smart constructor.
  data CreateAuthorizedViewRequest = CreateAuthorizedViewRequest
    { -- | Required. The AuthorizedView to create.
      authorizedView :: (Core.Maybe AuthorizedView),
      -- | Required. The id of the AuthorizedView to create. This AuthorizedView must not already exist. The @authorized_view_id@ appended to @parent@ forms the full AuthorizedView name of the form @projects\/{project}\/instances\/{instance}\/tables\/{table}\/authorizedView\/{authorized_view}@.
      authorizedViewId :: (Core.Maybe Core.Text),
      -- | Required. This is the name of the table the AuthorizedView belongs to. Values are of the form @projects\/{project}\/instances\/{instance}\/tables\/{table}@.
      parent :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateAuthorizedViewRequest' with the minimum fields required to make a request.
  newCreateAuthorizedViewRequest ::
    CreateAuthorizedViewRequest
  newCreateAuthorizedViewRequest =
    CreateAuthorizedViewRequest
      { authorizedView = Core.Nothing,
        authorizedViewId = Core.Nothing,
        parent = Core.Nothing
      }
  
  instance Core.FromJSON CreateAuthorizedViewRequest where
    parseJSON =
      Core.withObject
        "CreateAuthorizedViewRequest"
        ( \o ->
            CreateAuthorizedViewRequest
              Core.<$> (o Core..:? "authorizedView")
              Core.<*> (o Core..:? "authorizedViewId")
              Core.<*> (o Core..:? "parent")
        )
  
  instance Core.ToJSON CreateAuthorizedViewRequest where
    toJSON CreateAuthorizedViewRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("authorizedView" Core..=) Core.<$> authorizedView,
              ("authorizedViewId" Core..=) Core.<$> authorizedViewId,
              ("parent" Core..=) Core.<$> parent
            ]
        )
  
  -- | Metadata type for the operation returned by CreateBackup.
  --
  -- /See:/ 'newCreateBackupMetadata' smart constructor.
  data CreateBackupMetadata = CreateBackupMetadata
    { -- | If set, the time at which this operation finished or was cancelled.
      endTime :: (Core.Maybe Core.DateTime),
      -- | The name of the backup being created.
      name :: (Core.Maybe Core.Text),
      -- | The name of the table the backup is created from.
      sourceTable :: (Core.Maybe Core.Text),
      -- | The time at which this operation started.
      startTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateBackupMetadata' with the minimum fields required to make a request.
  newCreateBackupMetadata ::
    CreateBackupMetadata
  newCreateBackupMetadata =
    CreateBackupMetadata
      { endTime = Core.Nothing,
        name = Core.Nothing,
        sourceTable = Core.Nothing,
        startTime = Core.Nothing
      }
  
  instance Core.FromJSON CreateBackupMetadata where
    parseJSON =
      Core.withObject
        "CreateBackupMetadata"
        ( \o ->
            CreateBackupMetadata
              Core.<$> (o Core..:? "endTime")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "sourceTable")
              Core.<*> (o Core..:? "startTime")
        )
  
  instance Core.ToJSON CreateBackupMetadata where
    toJSON CreateBackupMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("endTime" Core..=) Core.<$> endTime,
              ("name" Core..=) Core.<$> name,
              ("sourceTable" Core..=) Core.<$> sourceTable,
              ("startTime" Core..=) Core.<$> startTime
            ]
        )
  
  -- | The metadata for the Operation returned by CreateCluster.
  --
  -- /See:/ 'newCreateClusterMetadata' smart constructor.
  data CreateClusterMetadata = CreateClusterMetadata
    { -- | The time at which the operation failed or was completed successfully.
      finishTime :: (Core.Maybe Core.DateTime),
      -- | The request that prompted the initiation of this CreateCluster operation.
      originalRequest :: (Core.Maybe CreateClusterRequest),
      -- | The time at which the original request was received.
      requestTime :: (Core.Maybe Core.DateTime),
      -- | Keys: the full @name@ of each table that existed in the instance when CreateCluster was first called, i.e. @projects\/\/instances\/\/tables\/@. Any table added to the instance by a later API call will be created in the new cluster by that API call, not this one. Values: information on how much of a table\'s data has been copied to the newly-created cluster so far.
      tables :: (Core.Maybe CreateClusterMetadata_Tables)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateClusterMetadata' with the minimum fields required to make a request.
  newCreateClusterMetadata ::
    CreateClusterMetadata
  newCreateClusterMetadata =
    CreateClusterMetadata
      { finishTime = Core.Nothing,
        originalRequest = Core.Nothing,
        requestTime = Core.Nothing,
        tables = Core.Nothing
      }
  
  instance Core.FromJSON CreateClusterMetadata where
    parseJSON =
      Core.withObject
        "CreateClusterMetadata"
        ( \o ->
            CreateClusterMetadata
              Core.<$> (o Core..:? "finishTime")
              Core.<*> (o Core..:? "originalRequest")
              Core.<*> (o Core..:? "requestTime")
              Core.<*> (o Core..:? "tables")
        )
  
  instance Core.ToJSON CreateClusterMetadata where
    toJSON CreateClusterMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("finishTime" Core..=) Core.<$> finishTime,
              ("originalRequest" Core..=) Core.<$> originalRequest,
              ("requestTime" Core..=) Core.<$> requestTime,
              ("tables" Core..=) Core.<$> tables
            ]
        )
  
  -- | Keys: the full @name@ of each table that existed in the instance when CreateCluster was first called, i.e. @projects\/\/instances\/\/tables\/@. Any table added to the instance by a later API call will be created in the new cluster by that API call, not this one. Values: information on how much of a table\'s data has been copied to the newly-created cluster so far.
  --
  -- /See:/ 'newCreateClusterMetadata_Tables' smart constructor.
  newtype CreateClusterMetadata_Tables = CreateClusterMetadata_Tables
    { additional :: (Core.HashMap Core.Text TableProgress)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateClusterMetadata_Tables' with the minimum fields required to make a request.
  newCreateClusterMetadata_Tables ::
    -- |  See 'additional'.
    Core.HashMap Core.Text TableProgress ->
    CreateClusterMetadata_Tables
  newCreateClusterMetadata_Tables additional =
    CreateClusterMetadata_Tables {additional = additional}
  
  instance Core.FromJSON CreateClusterMetadata_Tables where
    parseJSON =
      Core.withObject
        "CreateClusterMetadata_Tables"
        ( \o ->
            CreateClusterMetadata_Tables Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON CreateClusterMetadata_Tables where
    toJSON CreateClusterMetadata_Tables {..} = Core.toJSON additional
  
  -- | Request message for BigtableInstanceAdmin.CreateCluster.
  --
  -- /See:/ 'newCreateClusterRequest' smart constructor.
  data CreateClusterRequest = CreateClusterRequest
    { -- | Required. The cluster to be created. Fields marked @OutputOnly@ must be left blank.
      cluster :: (Core.Maybe Cluster),
      -- | Required. The ID to be used when referring to the new cluster within its instance, e.g., just @mycluster@ rather than @projects\/myproject\/instances\/myinstance\/clusters\/mycluster@.
      clusterId :: (Core.Maybe Core.Text),
      -- | Required. The unique name of the instance in which to create the new cluster. Values are of the form @projects\/{project}\/instances\/{instance}@.
      parent :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateClusterRequest' with the minimum fields required to make a request.
  newCreateClusterRequest ::
    CreateClusterRequest
  newCreateClusterRequest =
    CreateClusterRequest
      { cluster = Core.Nothing,
        clusterId = Core.Nothing,
        parent = Core.Nothing
      }
  
  instance Core.FromJSON CreateClusterRequest where
    parseJSON =
      Core.withObject
        "CreateClusterRequest"
        ( \o ->
            CreateClusterRequest
              Core.<$> (o Core..:? "cluster")
              Core.<*> (o Core..:? "clusterId")
              Core.<*> (o Core..:? "parent")
        )
  
  instance Core.ToJSON CreateClusterRequest where
    toJSON CreateClusterRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("cluster" Core..=) Core.<$> cluster,
              ("clusterId" Core..=) Core.<$> clusterId,
              ("parent" Core..=) Core.<$> parent
            ]
        )
  
  -- | The metadata for the Operation returned by CreateInstance.
  --
  -- /See:/ 'newCreateInstanceMetadata' smart constructor.
  data CreateInstanceMetadata = CreateInstanceMetadata
    { -- | The time at which the operation failed or was completed successfully.
      finishTime :: (Core.Maybe Core.DateTime),
      -- | The request that prompted the initiation of this CreateInstance operation.
      originalRequest :: (Core.Maybe CreateInstanceRequest),
      -- | The time at which the original request was received.
      requestTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateInstanceMetadata' with the minimum fields required to make a request.
  newCreateInstanceMetadata ::
    CreateInstanceMetadata
  newCreateInstanceMetadata =
    CreateInstanceMetadata
      { finishTime = Core.Nothing,
        originalRequest = Core.Nothing,
        requestTime = Core.Nothing
      }
  
  instance Core.FromJSON CreateInstanceMetadata where
    parseJSON =
      Core.withObject
        "CreateInstanceMetadata"
        ( \o ->
            CreateInstanceMetadata
              Core.<$> (o Core..:? "finishTime")
              Core.<*> (o Core..:? "originalRequest")
              Core.<*> (o Core..:? "requestTime")
        )
  
  instance Core.ToJSON CreateInstanceMetadata where
    toJSON CreateInstanceMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("finishTime" Core..=) Core.<$> finishTime,
              ("originalRequest" Core..=) Core.<$> originalRequest,
              ("requestTime" Core..=) Core.<$> requestTime
            ]
        )
  
  -- | Request message for BigtableInstanceAdmin.CreateInstance.
  --
  -- /See:/ 'newCreateInstanceRequest' smart constructor.
  data CreateInstanceRequest = CreateInstanceRequest
    { -- | Required. The clusters to be created within the instance, mapped by desired cluster ID, e.g., just @mycluster@ rather than @projects\/myproject\/instances\/myinstance\/clusters\/mycluster@. Fields marked @OutputOnly@ must be left blank.
      clusters :: (Core.Maybe CreateInstanceRequest_Clusters),
      -- | Required. The instance to create. Fields marked @OutputOnly@ must be left blank.
      instance' :: (Core.Maybe Instance),
      -- | Required. The ID to be used when referring to the new instance within its project, e.g., just @myinstance@ rather than @projects\/myproject\/instances\/myinstance@.
      instanceId :: (Core.Maybe Core.Text),
      -- | Required. The unique name of the project in which to create the new instance. Values are of the form @projects\/{project}@.
      parent :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateInstanceRequest' with the minimum fields required to make a request.
  newCreateInstanceRequest ::
    CreateInstanceRequest
  newCreateInstanceRequest =
    CreateInstanceRequest
      { clusters = Core.Nothing,
        instance' = Core.Nothing,
        instanceId = Core.Nothing,
        parent = Core.Nothing
      }
  
  instance Core.FromJSON CreateInstanceRequest where
    parseJSON =
      Core.withObject
        "CreateInstanceRequest"
        ( \o ->
            CreateInstanceRequest
              Core.<$> (o Core..:? "clusters")
              Core.<*> (o Core..:? "instance")
              Core.<*> (o Core..:? "instanceId")
              Core.<*> (o Core..:? "parent")
        )
  
  instance Core.ToJSON CreateInstanceRequest where
    toJSON CreateInstanceRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("clusters" Core..=) Core.<$> clusters,
              ("instance" Core..=) Core.<$> instance',
              ("instanceId" Core..=) Core.<$> instanceId,
              ("parent" Core..=) Core.<$> parent
            ]
        )
  
  -- | Required. The clusters to be created within the instance, mapped by desired cluster ID, e.g., just @mycluster@ rather than @projects\/myproject\/instances\/myinstance\/clusters\/mycluster@. Fields marked @OutputOnly@ must be left blank.
  --
  -- /See:/ 'newCreateInstanceRequest_Clusters' smart constructor.
  newtype CreateInstanceRequest_Clusters = CreateInstanceRequest_Clusters
    { additional :: (Core.HashMap Core.Text Cluster)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateInstanceRequest_Clusters' with the minimum fields required to make a request.
  newCreateInstanceRequest_Clusters ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Cluster ->
    CreateInstanceRequest_Clusters
  newCreateInstanceRequest_Clusters additional =
    CreateInstanceRequest_Clusters {additional = additional}
  
  instance Core.FromJSON CreateInstanceRequest_Clusters where
    parseJSON =
      Core.withObject
        "CreateInstanceRequest_Clusters"
        ( \o ->
            CreateInstanceRequest_Clusters Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON CreateInstanceRequest_Clusters where
    toJSON CreateInstanceRequest_Clusters {..} = Core.toJSON additional
  
  -- | Request message for google.bigtable.admin.v2.BigtableTableAdmin.CreateTable
  --
  -- /See:/ 'newCreateTableRequest' smart constructor.
  data CreateTableRequest = CreateTableRequest
    { -- | The optional list of row keys that will be used to initially split the table into several tablets (tablets are similar to HBase regions). Given two split keys, @s1@ and @s2@, three tablets will be created, spanning the key ranges: @[, s1), [s1, s2), [s2, )@. Example: * Row keys := @[\"a\", \"apple\", \"custom\", \"customer_1\", \"customer_2\",@ @\"other\", \"zz\"]@ * initial/split/keys := @[\"apple\", \"customer_1\", \"customer_2\", \"other\"]@ * Key assignment: - Tablet 1 @[, apple) => {\"a\"}.@ - Tablet 2 @[apple, customer_1) => {\"apple\", \"custom\"}.@ - Tablet 3 @[customer_1, customer_2) => {\"customer_1\"}.@ - Tablet 4 @[customer_2, other) => {\"customer_2\"}.@ - Tablet 5 @[other, ) => {\"other\", \"zz\"}.@
      initialSplits :: (Core.Maybe [Split]),
      -- | Required. The Table to create.
      table :: (Core.Maybe Table),
      -- | Required. The name by which the new table should be referred to within the parent instance, e.g., @foobar@ rather than @{parent}\/tables\/foobar@. Maximum 50 characters.
      tableId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateTableRequest' with the minimum fields required to make a request.
  newCreateTableRequest ::
    CreateTableRequest
  newCreateTableRequest =
    CreateTableRequest
      { initialSplits = Core.Nothing,
        table = Core.Nothing,
        tableId = Core.Nothing
      }
  
  instance Core.FromJSON CreateTableRequest where
    parseJSON =
      Core.withObject
        "CreateTableRequest"
        ( \o ->
            CreateTableRequest
              Core.<$> (o Core..:? "initialSplits")
              Core.<*> (o Core..:? "table")
              Core.<*> (o Core..:? "tableId")
        )
  
  instance Core.ToJSON CreateTableRequest where
    toJSON CreateTableRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("initialSplits" Core..=) Core.<$> initialSplits,
              ("table" Core..=) Core.<$> table,
              ("tableId" Core..=) Core.<$> tableId
            ]
        )
  
  -- | Data Boost is a serverless compute capability that lets you run high-throughput read jobs and queries on your Bigtable data, without impacting the performance of the clusters that handle your application traffic. Data Boost supports read-only use cases with single-cluster routing.
  --
  -- /See:/ 'newDataBoostIsolationReadOnly' smart constructor.
  newtype DataBoostIsolationReadOnly = DataBoostIsolationReadOnly
    { -- | The Compute Billing Owner for this Data Boost App Profile.
      computeBillingOwner :: (Core.Maybe DataBoostIsolationReadOnly_ComputeBillingOwner)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DataBoostIsolationReadOnly' with the minimum fields required to make a request.
  newDataBoostIsolationReadOnly ::
    DataBoostIsolationReadOnly
  newDataBoostIsolationReadOnly =
    DataBoostIsolationReadOnly {computeBillingOwner = Core.Nothing}
  
  instance Core.FromJSON DataBoostIsolationReadOnly where
    parseJSON =
      Core.withObject
        "DataBoostIsolationReadOnly"
        ( \o ->
            DataBoostIsolationReadOnly
              Core.<$> (o Core..:? "computeBillingOwner")
        )
  
  instance Core.ToJSON DataBoostIsolationReadOnly where
    toJSON DataBoostIsolationReadOnly {..} =
      Core.object
        ( Core.catMaybes
            [("computeBillingOwner" Core..=) Core.<$> computeBillingOwner]
        )
  
  -- | Checks that all writes before the consistency token was generated in the same cluster are readable by Databoost.
  --
  -- /See:/ 'newDataBoostReadLocalWrites' smart constructor.
  data DataBoostReadLocalWrites = DataBoostReadLocalWrites
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DataBoostReadLocalWrites' with the minimum fields required to make a request.
  newDataBoostReadLocalWrites ::
    DataBoostReadLocalWrites
  newDataBoostReadLocalWrites = DataBoostReadLocalWrites
  
  instance Core.FromJSON DataBoostReadLocalWrites where
    parseJSON =
      Core.withObject
        "DataBoostReadLocalWrites"
        (\o -> Core.pure DataBoostReadLocalWrites)
  
  instance Core.ToJSON DataBoostReadLocalWrites where
    toJSON = Core.const Core.emptyObject
  
  -- | Request message for google.bigtable.admin.v2.BigtableTableAdmin.DropRowRange
  --
  -- /See:/ 'newDropRowRangeRequest' smart constructor.
  data DropRowRangeRequest = DropRowRangeRequest
    { -- | Delete all rows in the table. Setting this to false is a no-op.
      deleteAllDataFromTable :: (Core.Maybe Core.Bool),
      -- | Delete all rows that start with this row key prefix. Prefix cannot be zero length.
      rowKeyPrefix :: (Core.Maybe Core.Base64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DropRowRangeRequest' with the minimum fields required to make a request.
  newDropRowRangeRequest ::
    DropRowRangeRequest
  newDropRowRangeRequest =
    DropRowRangeRequest
      { deleteAllDataFromTable = Core.Nothing,
        rowKeyPrefix = Core.Nothing
      }
  
  instance Core.FromJSON DropRowRangeRequest where
    parseJSON =
      Core.withObject
        "DropRowRangeRequest"
        ( \o ->
            DropRowRangeRequest
              Core.<$> (o Core..:? "deleteAllDataFromTable")
              Core.<*> (o Core..:? "rowKeyPrefix")
        )
  
  instance Core.ToJSON DropRowRangeRequest where
    toJSON DropRowRangeRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("deleteAllDataFromTable" Core..=)
                Core.<$> deleteAllDataFromTable,
              ("rowKeyPrefix" Core..=) Core.<$> rowKeyPrefix
            ]
        )
  
  -- | A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
  --
  -- /See:/ 'newEmpty' smart constructor.
  data Empty = Empty
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Empty' with the minimum fields required to make a request.
  newEmpty ::
    Empty
  newEmpty = Empty
  
  instance Core.FromJSON Empty where
    parseJSON = Core.withObject "Empty" (\o -> Core.pure Empty)
  
  instance Core.ToJSON Empty where
    toJSON = Core.const Core.emptyObject
  
  -- | Cloud Key Management Service (Cloud KMS) settings for a CMEK-protected cluster.
  --
  -- /See:/ 'newEncryptionConfig' smart constructor.
  newtype EncryptionConfig = EncryptionConfig
    { -- | Describes the Cloud KMS encryption key that will be used to protect the destination Bigtable cluster. The requirements for this key are: 1) The Cloud Bigtable service account associated with the project that contains this cluster must be granted the @cloudkms.cryptoKeyEncrypterDecrypter@ role on the CMEK key. 2) Only regional keys can be used and the region of the CMEK key must match the region of the cluster. Values are of the form @projects\/{project}\/locations\/{location}\/keyRings\/{keyring}\/cryptoKeys\/{key}@
      kmsKeyName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EncryptionConfig' with the minimum fields required to make a request.
  newEncryptionConfig ::
    EncryptionConfig
  newEncryptionConfig = EncryptionConfig {kmsKeyName = Core.Nothing}
  
  instance Core.FromJSON EncryptionConfig where
    parseJSON =
      Core.withObject
        "EncryptionConfig"
        (\o -> EncryptionConfig Core.<$> (o Core..:? "kmsKeyName"))
  
  instance Core.ToJSON EncryptionConfig where
    toJSON EncryptionConfig {..} =
      Core.object
        (Core.catMaybes [("kmsKeyName" Core..=) Core.<$> kmsKeyName])
  
  -- | Encryption information for a given resource. If this resource is protected with customer managed encryption, the in-use Cloud Key Management Service (Cloud KMS) key version is specified along with its status.
  --
  -- /See:/ 'newEncryptionInfo' smart constructor.
  data EncryptionInfo = EncryptionInfo
    { -- | Output only. The status of encrypt\/decrypt calls on underlying data for this resource. Regardless of status, the existing data is always encrypted at rest.
      encryptionStatus :: (Core.Maybe Status),
      -- | Output only. The type of encryption used to protect this resource.
      encryptionType :: (Core.Maybe EncryptionInfo_EncryptionType),
      -- | Output only. The version of the Cloud KMS key specified in the parent cluster that is in use for the data underlying this table.
      kmsKeyVersion :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EncryptionInfo' with the minimum fields required to make a request.
  newEncryptionInfo ::
    EncryptionInfo
  newEncryptionInfo =
    EncryptionInfo
      { encryptionStatus = Core.Nothing,
        encryptionType = Core.Nothing,
        kmsKeyVersion = Core.Nothing
      }
  
  instance Core.FromJSON EncryptionInfo where
    parseJSON =
      Core.withObject
        "EncryptionInfo"
        ( \o ->
            EncryptionInfo
              Core.<$> (o Core..:? "encryptionStatus")
              Core.<*> (o Core..:? "encryptionType")
              Core.<*> (o Core..:? "kmsKeyVersion")
        )
  
  instance Core.ToJSON EncryptionInfo where
    toJSON EncryptionInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("encryptionStatus" Core..=) Core.<$> encryptionStatus,
              ("encryptionType" Core..=) Core.<$> encryptionType,
              ("kmsKeyVersion" Core..=) Core.<$> kmsKeyVersion
            ]
        )
  
  -- | Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https:\/\/github.com\/google\/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() \< 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != \'private\' && document.type != \'internal\'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"\'New message received at \' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are
  -- determined by the service that evaluates it. See the service documentation for additional information.
  --
  -- /See:/ 'newExpr' smart constructor.
  data Expr = Expr
    { -- | Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
      description :: (Core.Maybe Core.Text),
      -- | Textual representation of an expression in Common Expression Language syntax.
      expression :: (Core.Maybe Core.Text),
      -- | Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
      location :: (Core.Maybe Core.Text),
      -- | Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
      title :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Expr' with the minimum fields required to make a request.
  newExpr ::
    Expr
  newExpr =
    Expr
      { description = Core.Nothing,
        expression = Core.Nothing,
        location = Core.Nothing,
        title = Core.Nothing
      }
  
  instance Core.FromJSON Expr where
    parseJSON =
      Core.withObject
        "Expr"
        ( \o ->
            Expr
              Core.<$> (o Core..:? "description")
              Core.<*> (o Core..:? "expression")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "title")
        )
  
  instance Core.ToJSON Expr where
    toJSON Expr {..} =
      Core.object
        ( Core.catMaybes
            [ ("description" Core..=) Core.<$> description,
              ("expression" Core..=) Core.<$> expression,
              ("location" Core..=) Core.<$> location,
              ("title" Core..=) Core.<$> title
            ]
        )
  
  -- | Rule for determining which cells to delete during garbage collection.
  --
  -- /See:/ 'newGcRule' smart constructor.
  data GcRule = GcRule
    { -- | Delete cells that would be deleted by every nested rule.
      intersection :: (Core.Maybe Intersection),
      -- | Delete cells in a column older than the given age. Values must be at least one millisecond, and will be truncated to microsecond granularity.
      maxAge :: (Core.Maybe Core.Duration),
      -- | Delete all cells in a column except the most recent N.
      maxNumVersions :: (Core.Maybe Core.Int32),
      -- | Delete cells that would be deleted by any nested rule.
      union :: (Core.Maybe Union)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GcRule' with the minimum fields required to make a request.
  newGcRule ::
    GcRule
  newGcRule =
    GcRule
      { intersection = Core.Nothing,
        maxAge = Core.Nothing,
        maxNumVersions = Core.Nothing,
        union = Core.Nothing
      }
  
  instance Core.FromJSON GcRule where
    parseJSON =
      Core.withObject
        "GcRule"
        ( \o ->
            GcRule
              Core.<$> (o Core..:? "intersection")
              Core.<*> (o Core..:? "maxAge")
              Core.<*> (o Core..:? "maxNumVersions")
              Core.<*> (o Core..:? "union")
        )
  
  instance Core.ToJSON GcRule where
    toJSON GcRule {..} =
      Core.object
        ( Core.catMaybes
            [ ("intersection" Core..=) Core.<$> intersection,
              ("maxAge" Core..=) Core.<$> maxAge,
              ("maxNumVersions" Core..=) Core.<$> maxNumVersions,
              ("union" Core..=) Core.<$> union
            ]
        )
  
  -- | Request message for google.bigtable.admin.v2.BigtableTableAdmin.GenerateConsistencyToken
  --
  -- /See:/ 'newGenerateConsistencyTokenRequest' smart constructor.
  data GenerateConsistencyTokenRequest = GenerateConsistencyTokenRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GenerateConsistencyTokenRequest' with the minimum fields required to make a request.
  newGenerateConsistencyTokenRequest ::
    GenerateConsistencyTokenRequest
  newGenerateConsistencyTokenRequest =
    GenerateConsistencyTokenRequest
  
  instance Core.FromJSON GenerateConsistencyTokenRequest where
    parseJSON =
      Core.withObject
        "GenerateConsistencyTokenRequest"
        (\o -> Core.pure GenerateConsistencyTokenRequest)
  
  instance Core.ToJSON GenerateConsistencyTokenRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | Response message for google.bigtable.admin.v2.BigtableTableAdmin.GenerateConsistencyToken
  --
  -- /See:/ 'newGenerateConsistencyTokenResponse' smart constructor.
  newtype GenerateConsistencyTokenResponse = GenerateConsistencyTokenResponse
    { -- | The generated consistency token.
      consistencyToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GenerateConsistencyTokenResponse' with the minimum fields required to make a request.
  newGenerateConsistencyTokenResponse ::
    GenerateConsistencyTokenResponse
  newGenerateConsistencyTokenResponse =
    GenerateConsistencyTokenResponse {consistencyToken = Core.Nothing}
  
  instance Core.FromJSON GenerateConsistencyTokenResponse where
    parseJSON =
      Core.withObject
        "GenerateConsistencyTokenResponse"
        ( \o ->
            GenerateConsistencyTokenResponse
              Core.<$> (o Core..:? "consistencyToken")
        )
  
  instance Core.ToJSON GenerateConsistencyTokenResponse where
    toJSON GenerateConsistencyTokenResponse {..} =
      Core.object
        ( Core.catMaybes
            [("consistencyToken" Core..=) Core.<$> consistencyToken]
        )
  
  -- | Request message for @GetIamPolicy@ method.
  --
  -- /See:/ 'newGetIamPolicyRequest' smart constructor.
  newtype GetIamPolicyRequest = GetIamPolicyRequest
    { -- | OPTIONAL: A @GetPolicyOptions@ object for specifying options to @GetIamPolicy@.
      options :: (Core.Maybe GetPolicyOptions)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GetIamPolicyRequest' with the minimum fields required to make a request.
  newGetIamPolicyRequest ::
    GetIamPolicyRequest
  newGetIamPolicyRequest =
    GetIamPolicyRequest {options = Core.Nothing}
  
  instance Core.FromJSON GetIamPolicyRequest where
    parseJSON =
      Core.withObject
        "GetIamPolicyRequest"
        (\o -> GetIamPolicyRequest Core.<$> (o Core..:? "options"))
  
  instance Core.ToJSON GetIamPolicyRequest where
    toJSON GetIamPolicyRequest {..} =
      Core.object
        (Core.catMaybes [("options" Core..=) Core.<$> options])
  
  -- | Encapsulates settings provided to GetIamPolicy.
  --
  -- /See:/ 'newGetPolicyOptions' smart constructor.
  newtype GetPolicyOptions = GetPolicyOptions
    { -- | Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the <https://cloud.google.com/iam/help/conditions/resource-policies IAM documentation>.
      requestedPolicyVersion :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GetPolicyOptions' with the minimum fields required to make a request.
  newGetPolicyOptions ::
    GetPolicyOptions
  newGetPolicyOptions =
    GetPolicyOptions {requestedPolicyVersion = Core.Nothing}
  
  instance Core.FromJSON GetPolicyOptions where
    parseJSON =
      Core.withObject
        "GetPolicyOptions"
        ( \o ->
            GetPolicyOptions Core.<$> (o Core..:? "requestedPolicyVersion")
        )
  
  instance Core.ToJSON GetPolicyOptions where
    toJSON GetPolicyOptions {..} =
      Core.object
        ( Core.catMaybes
            [ ("requestedPolicyVersion" Core..=)
                Core.<$> requestedPolicyVersion
            ]
        )
  
  -- | Subsets of a column family that are included in this AuthorizedView.
  --
  -- /See:/ 'newGoogleBigtableAdminV2AuthorizedViewFamilySubsets' smart constructor.
  data GoogleBigtableAdminV2AuthorizedViewFamilySubsets = GoogleBigtableAdminV2AuthorizedViewFamilySubsets
    { -- | Prefixes for qualifiers to be included in the AuthorizedView. Every qualifier starting with one of these prefixes is included in the AuthorizedView. To provide access to all qualifiers, include the empty string as a prefix (\"\").
      qualifierPrefixes :: (Core.Maybe [Core.Base64]),
      -- | Individual exact column qualifiers to be included in the AuthorizedView.
      qualifiers :: (Core.Maybe [Core.Base64])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2AuthorizedViewFamilySubsets' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2AuthorizedViewFamilySubsets ::
    GoogleBigtableAdminV2AuthorizedViewFamilySubsets
  newGoogleBigtableAdminV2AuthorizedViewFamilySubsets =
    GoogleBigtableAdminV2AuthorizedViewFamilySubsets
      { qualifierPrefixes =
          Core.Nothing,
        qualifiers = Core.Nothing
      }
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2AuthorizedViewFamilySubsets
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2AuthorizedViewFamilySubsets"
        ( \o ->
            GoogleBigtableAdminV2AuthorizedViewFamilySubsets
              Core.<$> (o Core..:? "qualifierPrefixes")
              Core.<*> (o Core..:? "qualifiers")
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2AuthorizedViewFamilySubsets
    where
    toJSON GoogleBigtableAdminV2AuthorizedViewFamilySubsets {..} =
      Core.object
        ( Core.catMaybes
            [ ("qualifierPrefixes" Core..=) Core.<$> qualifierPrefixes,
              ("qualifiers" Core..=) Core.<$> qualifiers
            ]
        )
  
  -- | Defines a simple AuthorizedView that is a subset of the underlying Table.
  --
  -- /See:/ 'newGoogleBigtableAdminV2AuthorizedViewSubsetView' smart constructor.
  data GoogleBigtableAdminV2AuthorizedViewSubsetView = GoogleBigtableAdminV2AuthorizedViewSubsetView
    { -- | Map from column family name to the columns in this family to be included in the AuthorizedView.
      familySubsets ::
        ( Core.Maybe
            GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
        ),
      -- | Row prefixes to be included in the AuthorizedView. To provide access to all rows, include the empty string as a prefix (\"\").
      rowPrefixes :: (Core.Maybe [Core.Base64])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2AuthorizedViewSubsetView' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2AuthorizedViewSubsetView ::
    GoogleBigtableAdminV2AuthorizedViewSubsetView
  newGoogleBigtableAdminV2AuthorizedViewSubsetView =
    GoogleBigtableAdminV2AuthorizedViewSubsetView
      { familySubsets =
          Core.Nothing,
        rowPrefixes = Core.Nothing
      }
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2AuthorizedViewSubsetView
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2AuthorizedViewSubsetView"
        ( \o ->
            GoogleBigtableAdminV2AuthorizedViewSubsetView
              Core.<$> (o Core..:? "familySubsets")
              Core.<*> (o Core..:? "rowPrefixes")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2AuthorizedViewSubsetView where
    toJSON GoogleBigtableAdminV2AuthorizedViewSubsetView {..} =
      Core.object
        ( Core.catMaybes
            [ ("familySubsets" Core..=) Core.<$> familySubsets,
              ("rowPrefixes" Core..=) Core.<$> rowPrefixes
            ]
        )
  
  -- | Map from column family name to the columns in this family to be included in the AuthorizedView.
  --
  -- /See:/ 'newGoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets' smart constructor.
  newtype GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets = GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
    { additional ::
        ( Core.HashMap
            Core.Text
            GoogleBigtableAdminV2AuthorizedViewFamilySubsets
        )
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets ::
    -- |  See 'additional'.
    Core.HashMap
      Core.Text
      GoogleBigtableAdminV2AuthorizedViewFamilySubsets ->
    GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
  newGoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
    additional =
      GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
        { additional =
            additional
        }
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets"
        ( \o ->
            GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets
    where
    toJSON
      GoogleBigtableAdminV2AuthorizedViewSubsetView_FamilySubsets {..} =
        Core.toJSON additional
  
  -- | A value that combines incremental updates into a summarized value. Data is never directly written or read using type @Aggregate@. Writes provide either the @input_type@ or @state_type@, and reads always return the @state_type@ .
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeAggregate' smart constructor.
  data GoogleBigtableAdminV2TypeAggregate = GoogleBigtableAdminV2TypeAggregate
    { -- | HyperLogLogPlusPlusUniqueCount aggregator.
      hllppUniqueCount ::
        ( Core.Maybe
            GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
        ),
      -- | Type of the inputs that are accumulated by this @Aggregate@. Use @AddInput@ mutations to accumulate new inputs.
      inputType :: (Core.Maybe Type),
      -- | Max aggregator.
      max :: (Core.Maybe GoogleBigtableAdminV2TypeAggregateMax),
      -- | Min aggregator.
      min :: (Core.Maybe GoogleBigtableAdminV2TypeAggregateMin),
      -- | Output only. Type that holds the internal accumulator state for the @Aggregate@. This is a function of the @input_type@ and @aggregator@ chosen.
      stateType :: (Core.Maybe Type),
      -- | Sum aggregator.
      sum :: (Core.Maybe GoogleBigtableAdminV2TypeAggregateSum)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeAggregate' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeAggregate ::
    GoogleBigtableAdminV2TypeAggregate
  newGoogleBigtableAdminV2TypeAggregate =
    GoogleBigtableAdminV2TypeAggregate
      { hllppUniqueCount =
          Core.Nothing,
        inputType = Core.Nothing,
        max = Core.Nothing,
        min = Core.Nothing,
        stateType = Core.Nothing,
        sum = Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeAggregate where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeAggregate"
        ( \o ->
            GoogleBigtableAdminV2TypeAggregate
              Core.<$> (o Core..:? "hllppUniqueCount")
              Core.<*> (o Core..:? "inputType")
              Core.<*> (o Core..:? "max")
              Core.<*> (o Core..:? "min")
              Core.<*> (o Core..:? "stateType")
              Core.<*> (o Core..:? "sum")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeAggregate where
    toJSON GoogleBigtableAdminV2TypeAggregate {..} =
      Core.object
        ( Core.catMaybes
            [ ("hllppUniqueCount" Core..=) Core.<$> hllppUniqueCount,
              ("inputType" Core..=) Core.<$> inputType,
              ("max" Core..=) Core.<$> max,
              ("min" Core..=) Core.<$> min,
              ("stateType" Core..=) Core.<$> stateType,
              ("sum" Core..=) Core.<$> sum
            ]
        )
  
  -- | Computes an approximate unique count over the input values. When using raw data as input, be careful to use a consistent encoding. Otherwise the same value encoded differently could count more than once, or two distinct values could count as identical. Input: Any, or omit for Raw State: TBD Special state conversions: @Int64@ (the unique count estimate)
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount' smart constructor.
  data GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount = GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount ::
    GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
  newGoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount =
    GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount"
        ( \o ->
            Core.pure
              GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
    where
    toJSON = Core.const Core.emptyObject
  
  -- | Computes the max of the input values. Allowed input: @Int64@ State: same as input
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeAggregateMax' smart constructor.
  data GoogleBigtableAdminV2TypeAggregateMax = GoogleBigtableAdminV2TypeAggregateMax
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeAggregateMax' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeAggregateMax ::
    GoogleBigtableAdminV2TypeAggregateMax
  newGoogleBigtableAdminV2TypeAggregateMax =
    GoogleBigtableAdminV2TypeAggregateMax
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeAggregateMax where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeAggregateMax"
        (\o -> Core.pure GoogleBigtableAdminV2TypeAggregateMax)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeAggregateMax where
    toJSON = Core.const Core.emptyObject
  
  -- | Computes the min of the input values. Allowed input: @Int64@ State: same as input
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeAggregateMin' smart constructor.
  data GoogleBigtableAdminV2TypeAggregateMin = GoogleBigtableAdminV2TypeAggregateMin
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeAggregateMin' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeAggregateMin ::
    GoogleBigtableAdminV2TypeAggregateMin
  newGoogleBigtableAdminV2TypeAggregateMin =
    GoogleBigtableAdminV2TypeAggregateMin
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeAggregateMin where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeAggregateMin"
        (\o -> Core.pure GoogleBigtableAdminV2TypeAggregateMin)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeAggregateMin where
    toJSON = Core.const Core.emptyObject
  
  -- | Computes the sum of the input values. Allowed input: @Int64@ State: same as input
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeAggregateSum' smart constructor.
  data GoogleBigtableAdminV2TypeAggregateSum = GoogleBigtableAdminV2TypeAggregateSum
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeAggregateSum' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeAggregateSum ::
    GoogleBigtableAdminV2TypeAggregateSum
  newGoogleBigtableAdminV2TypeAggregateSum =
    GoogleBigtableAdminV2TypeAggregateSum
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeAggregateSum where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeAggregateSum"
        (\o -> Core.pure GoogleBigtableAdminV2TypeAggregateSum)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeAggregateSum where
    toJSON = Core.const Core.emptyObject
  
  -- | An ordered list of elements of a given type. Values of type @Array@ are stored in @Value.array_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeArray' smart constructor.
  newtype GoogleBigtableAdminV2TypeArray = GoogleBigtableAdminV2TypeArray
    { -- | The type of the elements in the array. This must not be @Array@.
      elementType :: (Core.Maybe Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeArray' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeArray ::
    GoogleBigtableAdminV2TypeArray
  newGoogleBigtableAdminV2TypeArray =
    GoogleBigtableAdminV2TypeArray {elementType = Core.Nothing}
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeArray where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeArray"
        ( \o ->
            GoogleBigtableAdminV2TypeArray Core.<$> (o Core..:? "elementType")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeArray where
    toJSON GoogleBigtableAdminV2TypeArray {..} =
      Core.object
        (Core.catMaybes [("elementType" Core..=) Core.<$> elementType])
  
  -- | bool Values of type @Bool@ are stored in @Value.bool_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeBool' smart constructor.
  data GoogleBigtableAdminV2TypeBool = GoogleBigtableAdminV2TypeBool
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeBool' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeBool ::
    GoogleBigtableAdminV2TypeBool
  newGoogleBigtableAdminV2TypeBool = GoogleBigtableAdminV2TypeBool
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeBool where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeBool"
        (\o -> Core.pure GoogleBigtableAdminV2TypeBool)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeBool where
    toJSON = Core.const Core.emptyObject
  
  -- | Bytes Values of type @Bytes@ are stored in @Value.bytes_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeBytes' smart constructor.
  newtype GoogleBigtableAdminV2TypeBytes = GoogleBigtableAdminV2TypeBytes
    { -- | The encoding to use when converting to or from lower level types.
      encoding :: (Core.Maybe GoogleBigtableAdminV2TypeBytesEncoding)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeBytes' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeBytes ::
    GoogleBigtableAdminV2TypeBytes
  newGoogleBigtableAdminV2TypeBytes =
    GoogleBigtableAdminV2TypeBytes {encoding = Core.Nothing}
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeBytes where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeBytes"
        ( \o ->
            GoogleBigtableAdminV2TypeBytes Core.<$> (o Core..:? "encoding")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeBytes where
    toJSON GoogleBigtableAdminV2TypeBytes {..} =
      Core.object
        (Core.catMaybes [("encoding" Core..=) Core.<$> encoding])
  
  -- | Rules used to convert to or from lower level types.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeBytesEncoding' smart constructor.
  newtype GoogleBigtableAdminV2TypeBytesEncoding = GoogleBigtableAdminV2TypeBytesEncoding
    { -- | Use @Raw@ encoding.
      raw :: (Core.Maybe GoogleBigtableAdminV2TypeBytesEncodingRaw)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeBytesEncoding' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeBytesEncoding ::
    GoogleBigtableAdminV2TypeBytesEncoding
  newGoogleBigtableAdminV2TypeBytesEncoding =
    GoogleBigtableAdminV2TypeBytesEncoding {raw = Core.Nothing}
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeBytesEncoding where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeBytesEncoding"
        ( \o ->
            GoogleBigtableAdminV2TypeBytesEncoding Core.<$> (o Core..:? "raw")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeBytesEncoding where
    toJSON GoogleBigtableAdminV2TypeBytesEncoding {..} =
      Core.object (Core.catMaybes [("raw" Core..=) Core.<$> raw])
  
  -- | Leaves the value as-is. Sorted mode: all values are supported. Distinct mode: all values are supported.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeBytesEncodingRaw' smart constructor.
  newtype GoogleBigtableAdminV2TypeBytesEncodingRaw = GoogleBigtableAdminV2TypeBytesEncodingRaw
    { -- | If set, allows NULL values to be encoded as the empty string \"\". The actual empty string, or any value which only contains the null byte 0x00, has one more null byte appended.
      escapeNulls :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeBytesEncodingRaw' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeBytesEncodingRaw ::
    GoogleBigtableAdminV2TypeBytesEncodingRaw
  newGoogleBigtableAdminV2TypeBytesEncodingRaw =
    GoogleBigtableAdminV2TypeBytesEncodingRaw
      { escapeNulls =
          Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeBytesEncodingRaw where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeBytesEncodingRaw"
        ( \o ->
            GoogleBigtableAdminV2TypeBytesEncodingRaw
              Core.<$> (o Core..:? "escapeNulls")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeBytesEncodingRaw where
    toJSON GoogleBigtableAdminV2TypeBytesEncodingRaw {..} =
      Core.object
        (Core.catMaybes [("escapeNulls" Core..=) Core.<$> escapeNulls])
  
  -- | Date Values of type @Date@ are stored in @Value.date_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeDate' smart constructor.
  data GoogleBigtableAdminV2TypeDate = GoogleBigtableAdminV2TypeDate
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeDate' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeDate ::
    GoogleBigtableAdminV2TypeDate
  newGoogleBigtableAdminV2TypeDate = GoogleBigtableAdminV2TypeDate
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeDate where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeDate"
        (\o -> Core.pure GoogleBigtableAdminV2TypeDate)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeDate where
    toJSON = Core.const Core.emptyObject
  
  -- | Float32 Values of type @Float32@ are stored in @Value.float_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeFloat32' smart constructor.
  data GoogleBigtableAdminV2TypeFloat32 = GoogleBigtableAdminV2TypeFloat32
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeFloat32' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeFloat32 ::
    GoogleBigtableAdminV2TypeFloat32
  newGoogleBigtableAdminV2TypeFloat32 =
    GoogleBigtableAdminV2TypeFloat32
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeFloat32 where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeFloat32"
        (\o -> Core.pure GoogleBigtableAdminV2TypeFloat32)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeFloat32 where
    toJSON = Core.const Core.emptyObject
  
  -- | Float64 Values of type @Float64@ are stored in @Value.float_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeFloat64' smart constructor.
  data GoogleBigtableAdminV2TypeFloat64 = GoogleBigtableAdminV2TypeFloat64
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeFloat64' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeFloat64 ::
    GoogleBigtableAdminV2TypeFloat64
  newGoogleBigtableAdminV2TypeFloat64 =
    GoogleBigtableAdminV2TypeFloat64
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeFloat64 where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeFloat64"
        (\o -> Core.pure GoogleBigtableAdminV2TypeFloat64)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeFloat64 where
    toJSON = Core.const Core.emptyObject
  
  -- | Int64 Values of type @Int64@ are stored in @Value.int_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeInt64' smart constructor.
  newtype GoogleBigtableAdminV2TypeInt64 = GoogleBigtableAdminV2TypeInt64
    { -- | The encoding to use when converting to or from lower level types.
      encoding :: (Core.Maybe GoogleBigtableAdminV2TypeInt64Encoding)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeInt64' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeInt64 ::
    GoogleBigtableAdminV2TypeInt64
  newGoogleBigtableAdminV2TypeInt64 =
    GoogleBigtableAdminV2TypeInt64 {encoding = Core.Nothing}
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeInt64 where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeInt64"
        ( \o ->
            GoogleBigtableAdminV2TypeInt64 Core.<$> (o Core..:? "encoding")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeInt64 where
    toJSON GoogleBigtableAdminV2TypeInt64 {..} =
      Core.object
        (Core.catMaybes [("encoding" Core..=) Core.<$> encoding])
  
  -- | Rules used to convert to or from lower level types.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeInt64Encoding' smart constructor.
  data GoogleBigtableAdminV2TypeInt64Encoding = GoogleBigtableAdminV2TypeInt64Encoding
    { -- | Use @BigEndianBytes@ encoding.
      bigEndianBytes :: (Core.Maybe GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes),
      -- | Use @OrderedCodeBytes@ encoding.
      orderedCodeBytes :: (Core.Maybe GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeInt64Encoding' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeInt64Encoding ::
    GoogleBigtableAdminV2TypeInt64Encoding
  newGoogleBigtableAdminV2TypeInt64Encoding =
    GoogleBigtableAdminV2TypeInt64Encoding
      { bigEndianBytes =
          Core.Nothing,
        orderedCodeBytes = Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeInt64Encoding where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeInt64Encoding"
        ( \o ->
            GoogleBigtableAdminV2TypeInt64Encoding
              Core.<$> (o Core..:? "bigEndianBytes")
              Core.<*> (o Core..:? "orderedCodeBytes")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeInt64Encoding where
    toJSON GoogleBigtableAdminV2TypeInt64Encoding {..} =
      Core.object
        ( Core.catMaybes
            [ ("bigEndianBytes" Core..=) Core.<$> bigEndianBytes,
              ("orderedCodeBytes" Core..=) Core.<$> orderedCodeBytes
            ]
        )
  
  -- | Encodes the value as an 8-byte big-endian two\'s complement value. Sorted mode: non-negative values are supported. Distinct mode: all values are supported. Compatible with: - BigQuery @BINARY@ encoding - HBase @Bytes.toBytes@ - Java @ByteBuffer.putLong()@ with @ByteOrder.BIG_ENDIAN@
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes' smart constructor.
  newtype GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes = GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
    { -- | Deprecated: ignored if set.
      bytesType :: (Core.Maybe GoogleBigtableAdminV2TypeBytes)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes ::
    GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
  newGoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes =
    GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
      { bytesType =
          Core.Nothing
      }
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes"
        ( \o ->
            GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
              Core.<$> (o Core..:? "bytesType")
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
    where
    toJSON GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes {..} =
      Core.object
        (Core.catMaybes [("bytesType" Core..=) Core.<$> bytesType])
  
  -- | Encodes the value in a variable length binary format of up to 10 bytes. Values that are closer to zero use fewer bytes. Sorted mode: all values are supported. Distinct mode: all values are supported.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes' smart constructor.
  data GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes = GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes ::
    GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes
  newGoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes =
    GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes"
        ( \o ->
            Core.pure GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2TypeInt64EncodingOrderedCodeBytes
    where
    toJSON = Core.const Core.emptyObject
  
  -- | A mapping of keys to values of a given type. Values of type @Map@ are stored in a @Value.array_value@ where each entry is another @Value.array_value@ with two elements (the key and the value, in that order). Normally encoded Map values won\'t have repeated keys, however, clients are expected to handle the case in which they do. If the same key appears multiple times, the /last/ value takes precedence.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeMap' smart constructor.
  data GoogleBigtableAdminV2TypeMap = GoogleBigtableAdminV2TypeMap
    { -- | The type of a map key. Only @Bytes@, @String@, and @Int64@ are allowed as key types.
      keyType :: (Core.Maybe Type),
      -- | The type of the values in a map.
      valueType :: (Core.Maybe Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeMap' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeMap ::
    GoogleBigtableAdminV2TypeMap
  newGoogleBigtableAdminV2TypeMap =
    GoogleBigtableAdminV2TypeMap
      { keyType = Core.Nothing,
        valueType = Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeMap where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeMap"
        ( \o ->
            GoogleBigtableAdminV2TypeMap
              Core.<$> (o Core..:? "keyType")
              Core.<*> (o Core..:? "valueType")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeMap where
    toJSON GoogleBigtableAdminV2TypeMap {..} =
      Core.object
        ( Core.catMaybes
            [ ("keyType" Core..=) Core.<$> keyType,
              ("valueType" Core..=) Core.<$> valueType
            ]
        )
  
  -- | String Values of type @String@ are stored in @Value.string_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeString' smart constructor.
  newtype GoogleBigtableAdminV2TypeString = GoogleBigtableAdminV2TypeString
    { -- | The encoding to use when converting to or from lower level types.
      encoding :: (Core.Maybe GoogleBigtableAdminV2TypeStringEncoding)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeString' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeString ::
    GoogleBigtableAdminV2TypeString
  newGoogleBigtableAdminV2TypeString =
    GoogleBigtableAdminV2TypeString {encoding = Core.Nothing}
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeString where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeString"
        ( \o ->
            GoogleBigtableAdminV2TypeString Core.<$> (o Core..:? "encoding")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeString where
    toJSON GoogleBigtableAdminV2TypeString {..} =
      Core.object
        (Core.catMaybes [("encoding" Core..=) Core.<$> encoding])
  
  -- | Rules used to convert to or from lower level types.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStringEncoding' smart constructor.
  data GoogleBigtableAdminV2TypeStringEncoding = GoogleBigtableAdminV2TypeStringEncoding
    { -- | Use @Utf8Bytes@ encoding.
      utf8Bytes :: (Core.Maybe GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes),
      -- | Deprecated: if set, converts to an empty @utf8_bytes@.
      utf8Raw :: (Core.Maybe GoogleBigtableAdminV2TypeStringEncodingUtf8Raw)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStringEncoding' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStringEncoding ::
    GoogleBigtableAdminV2TypeStringEncoding
  newGoogleBigtableAdminV2TypeStringEncoding =
    GoogleBigtableAdminV2TypeStringEncoding
      { utf8Bytes = Core.Nothing,
        utf8Raw = Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeStringEncoding where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStringEncoding"
        ( \o ->
            GoogleBigtableAdminV2TypeStringEncoding
              Core.<$> (o Core..:? "utf8Bytes")
              Core.<*> (o Core..:? "utf8Raw")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeStringEncoding where
    toJSON GoogleBigtableAdminV2TypeStringEncoding {..} =
      Core.object
        ( Core.catMaybes
            [ ("utf8Bytes" Core..=) Core.<$> utf8Bytes,
              ("utf8Raw" Core..=) Core.<$> utf8Raw
            ]
        )
  
  -- | UTF-8 encoding. Sorted mode: - All values are supported. - Code point order is preserved. Distinct mode: all values are supported. Compatible with: - BigQuery @TEXT@ encoding - HBase @Bytes.toBytes@ - Java @String#getBytes(StandardCharsets.UTF_8)@
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStringEncodingUtf8Bytes' smart constructor.
  newtype GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes = GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
    { -- | Single-character escape sequence used to support NULL values. If set, allows NULL values to be encoded as the empty string \"\". The actual empty string, or any value where every character equals @null_escape_char@, has one more @null_escape_char@ appended. If @null_escape_char@ is set and does not equal the ASCII null character 0x00, then the encoding will not support sorted mode. .
      nullEscapeChar :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStringEncodingUtf8Bytes ::
    GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
  newGoogleBigtableAdminV2TypeStringEncodingUtf8Bytes =
    GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
      { nullEscapeChar =
          Core.Nothing
      }
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes"
        ( \o ->
            GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
              Core.<$> (o Core..:? "nullEscapeChar")
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
    where
    toJSON GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes {..} =
      Core.object
        ( Core.catMaybes
            [("nullEscapeChar" Core..=) Core.<$> nullEscapeChar]
        )
  
  -- | Deprecated: prefer the equivalent @Utf8Bytes@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStringEncodingUtf8Raw' smart constructor.
  data GoogleBigtableAdminV2TypeStringEncodingUtf8Raw = GoogleBigtableAdminV2TypeStringEncodingUtf8Raw
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStringEncodingUtf8Raw' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStringEncodingUtf8Raw ::
    GoogleBigtableAdminV2TypeStringEncodingUtf8Raw
  newGoogleBigtableAdminV2TypeStringEncodingUtf8Raw =
    GoogleBigtableAdminV2TypeStringEncodingUtf8Raw
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeStringEncodingUtf8Raw
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStringEncodingUtf8Raw"
        (\o -> Core.pure GoogleBigtableAdminV2TypeStringEncodingUtf8Raw)
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeStringEncodingUtf8Raw where
    toJSON = Core.const Core.emptyObject
  
  -- | A structured data value, consisting of fields which map to dynamically typed values. Values of type @Struct@ are stored in @Value.array_value@ where entries are in the same order and number as @field_types@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStruct' smart constructor.
  data GoogleBigtableAdminV2TypeStruct = GoogleBigtableAdminV2TypeStruct
    { -- | The encoding to use when converting to or from lower level types.
      encoding :: (Core.Maybe GoogleBigtableAdminV2TypeStructEncoding),
      -- | The names and types of the fields in this struct.
      fields :: (Core.Maybe [GoogleBigtableAdminV2TypeStructField])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStruct' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStruct ::
    GoogleBigtableAdminV2TypeStruct
  newGoogleBigtableAdminV2TypeStruct =
    GoogleBigtableAdminV2TypeStruct
      { encoding = Core.Nothing,
        fields = Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeStruct where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStruct"
        ( \o ->
            GoogleBigtableAdminV2TypeStruct
              Core.<$> (o Core..:? "encoding")
              Core.<*> (o Core..:? "fields")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeStruct where
    toJSON GoogleBigtableAdminV2TypeStruct {..} =
      Core.object
        ( Core.catMaybes
            [ ("encoding" Core..=) Core.<$> encoding,
              ("fields" Core..=) Core.<$> fields
            ]
        )
  
  -- | Rules used to convert to or from lower level types.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStructEncoding' smart constructor.
  data GoogleBigtableAdminV2TypeStructEncoding = GoogleBigtableAdminV2TypeStructEncoding
    { -- | Use @DelimitedBytes@ encoding.
      delimitedBytes :: (Core.Maybe GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes),
      -- | User @OrderedCodeBytes@ encoding.
      orderedCodeBytes ::
        ( Core.Maybe
            GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
        ),
      -- | Use @Singleton@ encoding.
      singleton :: (Core.Maybe GoogleBigtableAdminV2TypeStructEncodingSingleton)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStructEncoding' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStructEncoding ::
    GoogleBigtableAdminV2TypeStructEncoding
  newGoogleBigtableAdminV2TypeStructEncoding =
    GoogleBigtableAdminV2TypeStructEncoding
      { delimitedBytes =
          Core.Nothing,
        orderedCodeBytes = Core.Nothing,
        singleton = Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeStructEncoding where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStructEncoding"
        ( \o ->
            GoogleBigtableAdminV2TypeStructEncoding
              Core.<$> (o Core..:? "delimitedBytes")
              Core.<*> (o Core..:? "orderedCodeBytes")
              Core.<*> (o Core..:? "singleton")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeStructEncoding where
    toJSON GoogleBigtableAdminV2TypeStructEncoding {..} =
      Core.object
        ( Core.catMaybes
            [ ("delimitedBytes" Core..=) Core.<$> delimitedBytes,
              ("orderedCodeBytes" Core..=) Core.<$> orderedCodeBytes,
              ("singleton" Core..=) Core.<$> singleton
            ]
        )
  
  -- | Fields are encoded independently and concatenated with a configurable @delimiter@ in between. A struct with no fields defined is encoded as a single @delimiter@. Sorted mode: - Fields are encoded in sorted mode. - Encoded field values must not contain any bytes \<= @delimiter[0]@ - Element-wise order is preserved: @A \< B@ if @A[0] \< B[0]@, or if @A[0] == B[0] && A[1] \< B[1]@, etc. Strict prefixes sort first. Distinct mode: - Fields are encoded in distinct mode. - Encoded field values must not contain @delimiter[0]@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStructEncodingDelimitedBytes' smart constructor.
  newtype GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes = GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes
    { -- | Byte sequence used to delimit concatenated fields. The delimiter must contain at least 1 character and at most 50 characters.
      delimiter :: (Core.Maybe Core.Base64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStructEncodingDelimitedBytes ::
    GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes
  newGoogleBigtableAdminV2TypeStructEncodingDelimitedBytes =
    GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes
      { delimiter =
          Core.Nothing
      }
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes"
        ( \o ->
            GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes
              Core.<$> (o Core..:? "delimiter")
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes
    where
    toJSON GoogleBigtableAdminV2TypeStructEncodingDelimitedBytes {..} =
      Core.object
        (Core.catMaybes [("delimiter" Core..=) Core.<$> delimiter])
  
  -- | Fields are encoded independently and concatenated with the fixed byte pair {0x00, 0x01} in between. Any null (0x00) byte in an encoded field is replaced by the fixed byte pair {0x00, 0xFF}. Fields that encode to the empty string \"\" have special handling: - If /every/ field encodes to \"\", or if the STRUCT has no fields defined, then the STRUCT is encoded as the fixed byte pair {0x00, 0x00}. - Otherwise, the STRUCT only encodes until the last non-empty field, omitting any trailing empty fields. Any empty fields that aren\'t omitted are replaced with the fixed byte pair {0x00, 0x00}. Examples: - STRUCT() -> \"\\00\\00\" - STRUCT(\"\") -> \"\\00\\00\" - STRUCT(\"\", \"\") -> \"\\00\\00\" - STRUCT(\"\", \"B\") -> \"\\00\\00\" + \"\\00\\01\" + \"B\" - STRUCT(\"A\", \"\") -> \"A\" - STRUCT(\"\", \"B\", \"\") -> \"\\00\\00\" + \"\\00\\01\" + \"B\" - STRUCT(\"A\", \"\", \"C\") -> \"A\" + \"\\00\\01\" + \"\\00\\00\" + \"\\00\\01\" + \"C\" Since null bytes are always escaped, this encoding can cause size blowup for
  -- encodings like @Int64.BigEndianBytes@ that are likely to produce many such bytes. Sorted mode: - Fields are encoded in sorted mode. - All values supported by the field encodings are allowed - Element-wise order is preserved: @A \< B@ if @A[0] \< B[0]@, or if @A[0] == B[0] && A[1] \< B[1]@, etc. Strict prefixes sort first. Distinct mode: - Fields are encoded in distinct mode. - All values supported by the field encodings are allowed.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes' smart constructor.
  data GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes = GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes ::
    GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
  newGoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes =
    GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes"
        ( \o ->
            Core.pure GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
        )
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2TypeStructEncodingOrderedCodeBytes
    where
    toJSON = Core.const Core.emptyObject
  
  -- | Uses the encoding of @fields[0].type@ as-is. Only valid if @fields.size == 1@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStructEncodingSingleton' smart constructor.
  data GoogleBigtableAdminV2TypeStructEncodingSingleton = GoogleBigtableAdminV2TypeStructEncodingSingleton
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStructEncodingSingleton' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStructEncodingSingleton ::
    GoogleBigtableAdminV2TypeStructEncodingSingleton
  newGoogleBigtableAdminV2TypeStructEncodingSingleton =
    GoogleBigtableAdminV2TypeStructEncodingSingleton
  
  instance
    Core.FromJSON
      GoogleBigtableAdminV2TypeStructEncodingSingleton
    where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStructEncodingSingleton"
        (\o -> Core.pure GoogleBigtableAdminV2TypeStructEncodingSingleton)
  
  instance
    Core.ToJSON
      GoogleBigtableAdminV2TypeStructEncodingSingleton
    where
    toJSON = Core.const Core.emptyObject
  
  -- | A struct field and its type.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeStructField' smart constructor.
  data GoogleBigtableAdminV2TypeStructField = GoogleBigtableAdminV2TypeStructField
    { -- | The field name (optional). Fields without a @field_name@ are considered anonymous and cannot be referenced by name.
      fieldName :: (Core.Maybe Core.Text),
      -- | The type of values in this field.
      type' :: (Core.Maybe Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeStructField' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeStructField ::
    GoogleBigtableAdminV2TypeStructField
  newGoogleBigtableAdminV2TypeStructField =
    GoogleBigtableAdminV2TypeStructField
      { fieldName = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeStructField where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeStructField"
        ( \o ->
            GoogleBigtableAdminV2TypeStructField
              Core.<$> (o Core..:? "fieldName")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeStructField where
    toJSON GoogleBigtableAdminV2TypeStructField {..} =
      Core.object
        ( Core.catMaybes
            [ ("fieldName" Core..=) Core.<$> fieldName,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Timestamp Values of type @Timestamp@ are stored in @Value.timestamp_value@.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeTimestamp' smart constructor.
  newtype GoogleBigtableAdminV2TypeTimestamp = GoogleBigtableAdminV2TypeTimestamp
    { -- | The encoding to use when converting to or from lower level types.
      encoding :: (Core.Maybe GoogleBigtableAdminV2TypeTimestampEncoding)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeTimestamp' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeTimestamp ::
    GoogleBigtableAdminV2TypeTimestamp
  newGoogleBigtableAdminV2TypeTimestamp =
    GoogleBigtableAdminV2TypeTimestamp {encoding = Core.Nothing}
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeTimestamp where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeTimestamp"
        ( \o ->
            GoogleBigtableAdminV2TypeTimestamp
              Core.<$> (o Core..:? "encoding")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeTimestamp where
    toJSON GoogleBigtableAdminV2TypeTimestamp {..} =
      Core.object
        (Core.catMaybes [("encoding" Core..=) Core.<$> encoding])
  
  -- | Rules used to convert to or from lower level types.
  --
  -- /See:/ 'newGoogleBigtableAdminV2TypeTimestampEncoding' smart constructor.
  newtype GoogleBigtableAdminV2TypeTimestampEncoding = GoogleBigtableAdminV2TypeTimestampEncoding
    { -- | Encodes the number of microseconds since the Unix epoch using the given @Int64@ encoding. Values must be microsecond-aligned. Compatible with: - Java @Instant.truncatedTo()@ with @ChronoUnit.MICROS@
      unixMicrosInt64 :: (Core.Maybe GoogleBigtableAdminV2TypeInt64Encoding)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleBigtableAdminV2TypeTimestampEncoding' with the minimum fields required to make a request.
  newGoogleBigtableAdminV2TypeTimestampEncoding ::
    GoogleBigtableAdminV2TypeTimestampEncoding
  newGoogleBigtableAdminV2TypeTimestampEncoding =
    GoogleBigtableAdminV2TypeTimestampEncoding
      { unixMicrosInt64 =
          Core.Nothing
      }
  
  instance Core.FromJSON GoogleBigtableAdminV2TypeTimestampEncoding where
    parseJSON =
      Core.withObject
        "GoogleBigtableAdminV2TypeTimestampEncoding"
        ( \o ->
            GoogleBigtableAdminV2TypeTimestampEncoding
              Core.<$> (o Core..:? "unixMicrosInt64")
        )
  
  instance Core.ToJSON GoogleBigtableAdminV2TypeTimestampEncoding where
    toJSON GoogleBigtableAdminV2TypeTimestampEncoding {..} =
      Core.object
        ( Core.catMaybes
            [("unixMicrosInt64" Core..=) Core.<$> unixMicrosInt64]
        )
  
  -- | A tablet is a defined by a start and end key and is explained in https:\/\/cloud.google.com\/bigtable\/docs\/overview#architecture and https:\/\/cloud.google.com\/bigtable\/docs\/performance#optimization. A Hot tablet is a tablet that exhibits high average cpu usage during the time interval from start time to end time.
  --
  -- /See:/ 'newHotTablet' smart constructor.
  data HotTablet = HotTablet
    { -- | Tablet End Key (inclusive).
      endKey :: (Core.Maybe Core.Text),
      -- | Output only. The end time of the hot tablet.
      endTime :: (Core.Maybe Core.DateTime),
      -- | The unique name of the hot tablet. Values are of the form @projects\/{project}\/instances\/{instance}\/clusters\/{cluster}\/hotTablets\/[a-zA-Z0-9_-]*@.
      name :: (Core.Maybe Core.Text),
      -- | Output only. The average CPU usage spent by a node on this tablet over the start/time to end/time time range. The percentage is the amount of CPU used by the node to serve the tablet, from 0% (tablet was not interacted with) to 100% (the node spent all cycles serving the hot tablet).
      nodeCpuUsagePercent :: (Core.Maybe Core.Double),
      -- | Tablet Start Key (inclusive).
      startKey :: (Core.Maybe Core.Text),
      -- | Output only. The start time of the hot tablet.
      startTime :: (Core.Maybe Core.DateTime),
      -- | Name of the table that contains the tablet. Values are of the form @projects\/{project}\/instances\/{instance}\/tables\/_a-zA-Z0-9*@.
      tableName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HotTablet' with the minimum fields required to make a request.
  newHotTablet ::
    HotTablet
  newHotTablet =
    HotTablet
      { endKey = Core.Nothing,
        endTime = Core.Nothing,
        name = Core.Nothing,
        nodeCpuUsagePercent = Core.Nothing,
        startKey = Core.Nothing,
        startTime = Core.Nothing,
        tableName = Core.Nothing
      }
  
  instance Core.FromJSON HotTablet where
    parseJSON =
      Core.withObject
        "HotTablet"
        ( \o ->
            HotTablet
              Core.<$> (o Core..:? "endKey")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "nodeCpuUsagePercent")
              Core.<*> (o Core..:? "startKey")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "tableName")
        )
  
  instance Core.ToJSON HotTablet where
    toJSON HotTablet {..} =
      Core.object
        ( Core.catMaybes
            [ ("endKey" Core..=) Core.<$> endKey,
              ("endTime" Core..=) Core.<$> endTime,
              ("name" Core..=) Core.<$> name,
              ("nodeCpuUsagePercent" Core..=) Core.<$> nodeCpuUsagePercent,
              ("startKey" Core..=) Core.<$> startKey,
              ("startTime" Core..=) Core.<$> startTime,
              ("tableName" Core..=) Core.<$> tableName
            ]
        )
  
  -- | A collection of Bigtable Tables and the resources that serve them. All tables in an instance are served from all Clusters in the instance.
  --
  -- /See:/ 'newInstance' smart constructor.
  data Instance = Instance
    { -- | Output only. A commit timestamp representing when this Instance was created. For instances created before this field was added (August 2021), this value is @seconds: 0, nanos: 1@.
      createTime :: (Core.Maybe Core.DateTime),
      -- | Required. The descriptive name for this instance as it appears in UIs. Can be changed at any time, but should be kept globally unique to avoid confusion.
      displayName :: (Core.Maybe Core.Text),
      -- | Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer\'s organizational needs and deployment strategies. They can be used to filter resources and aggregate metrics. * Label keys must be between 1 and 63 characters long and must conform to the regular expression: @\\p{Ll}\\p{Lo}{0,62}@. * Label values must be between 0 and 63 characters long and must conform to the regular expression: @[\\p{Ll}\\p{Lo}\\p{N}_-]{0,63}@. * No more than 64 labels can be associated with a given resource. * Keys and values must both be under 128 bytes.
      labels :: (Core.Maybe Instance_Labels),
      -- | The unique name of the instance. Values are of the form @projects\/{project}\/instances\/a-z+[a-z0-9]@.
      name :: (Core.Maybe Core.Text),
      -- | Output only. Reserved for future use.
      satisfiesPzi :: (Core.Maybe Core.Bool),
      -- | Output only. Reserved for future use.
      satisfiesPzs :: (Core.Maybe Core.Bool),
      -- | Output only. The current state of the instance.
      state :: (Core.Maybe Instance_State),
      -- | The type of the instance. Defaults to @PRODUCTION@.
      type' :: (Core.Maybe Instance_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Instance' with the minimum fields required to make a request.
  newInstance ::
    Instance
  newInstance =
    Instance
      { createTime = Core.Nothing,
        displayName = Core.Nothing,
        labels = Core.Nothing,
        name = Core.Nothing,
        satisfiesPzi = Core.Nothing,
        satisfiesPzs = Core.Nothing,
        state = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON Instance where
    parseJSON =
      Core.withObject
        "Instance"
        ( \o ->
            Instance
              Core.<$> (o Core..:? "createTime")
              Core.<*> (o Core..:? "displayName")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "satisfiesPzi")
              Core.<*> (o Core..:? "satisfiesPzs")
              Core.<*> (o Core..:? "state")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON Instance where
    toJSON Instance {..} =
      Core.object
        ( Core.catMaybes
            [ ("createTime" Core..=) Core.<$> createTime,
              ("displayName" Core..=) Core.<$> displayName,
              ("labels" Core..=) Core.<$> labels,
              ("name" Core..=) Core.<$> name,
              ("satisfiesPzi" Core..=) Core.<$> satisfiesPzi,
              ("satisfiesPzs" Core..=) Core.<$> satisfiesPzs,
              ("state" Core..=) Core.<$> state,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer\'s organizational needs and deployment strategies. They can be used to filter resources and aggregate metrics. * Label keys must be between 1 and 63 characters long and must conform to the regular expression: @\\p{Ll}\\p{Lo}{0,62}@. * Label values must be between 0 and 63 characters long and must conform to the regular expression: @[\\p{Ll}\\p{Lo}\\p{N}_-]{0,63}@. * No more than 64 labels can be associated with a given resource. * Keys and values must both be under 128 bytes.
  --
  -- /See:/ 'newInstance_Labels' smart constructor.
  newtype Instance_Labels = Instance_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Instance_Labels' with the minimum fields required to make a request.
  newInstance_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Instance_Labels
  newInstance_Labels additional =
    Instance_Labels {additional = additional}
  
  instance Core.FromJSON Instance_Labels where
    parseJSON =
      Core.withObject
        "Instance_Labels"
        (\o -> Instance_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Instance_Labels where
    toJSON Instance_Labels {..} = Core.toJSON additional
  
  -- | A GcRule which deletes cells matching all of the given rules.
  --
  -- /See:/ 'newIntersection' smart constructor.
  newtype Intersection = Intersection
    { -- | Only delete cells which would be deleted by every element of @rules@.
      rules :: (Core.Maybe [GcRule])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Intersection' with the minimum fields required to make a request.
  newIntersection ::
    Intersection
  newIntersection = Intersection {rules = Core.Nothing}
  
  instance Core.FromJSON Intersection where
    parseJSON =
      Core.withObject
        "Intersection"
        (\o -> Intersection Core.<$> (o Core..:? "rules"))
  
  instance Core.ToJSON Intersection where
    toJSON Intersection {..} =
      Core.object (Core.catMaybes [("rules" Core..=) Core.<$> rules])
  
  -- | Response message for BigtableInstanceAdmin.ListAppProfiles.
  --
  -- /See:/ 'newListAppProfilesResponse' smart constructor.
  data ListAppProfilesResponse = ListAppProfilesResponse
    { -- | The list of requested app profiles.
      appProfiles :: (Core.Maybe [AppProfile]),
      -- | Locations from which AppProfile information could not be retrieved, due to an outage or some other transient condition. AppProfiles from these locations may be missing from @app_profiles@. Values are of the form @projects\/\/locations\/@
      failedLocations :: (Core.Maybe [Core.Text]),
      -- | Set if not all app profiles could be returned in a single response. Pass this value to @page_token@ in another request to get the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListAppProfilesResponse' with the minimum fields required to make a request.
  newListAppProfilesResponse ::
    ListAppProfilesResponse
  newListAppProfilesResponse =
    ListAppProfilesResponse
      { appProfiles = Core.Nothing,
        failedLocations = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListAppProfilesResponse where
    parseJSON =
      Core.withObject
        "ListAppProfilesResponse"
        ( \o ->
            ListAppProfilesResponse
              Core.<$> (o Core..:? "appProfiles")
              Core.<*> (o Core..:? "failedLocations")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListAppProfilesResponse where
    toJSON ListAppProfilesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("appProfiles" Core..=) Core.<$> appProfiles,
              ("failedLocations" Core..=) Core.<$> failedLocations,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for google.bigtable.admin.v2.BigtableTableAdmin.ListAuthorizedViews
  --
  -- /See:/ 'newListAuthorizedViewsResponse' smart constructor.
  data ListAuthorizedViewsResponse = ListAuthorizedViewsResponse
    { -- | The AuthorizedViews present in the requested table.
      authorizedViews :: (Core.Maybe [AuthorizedView]),
      -- | Set if not all tables could be returned in a single response. Pass this value to @page_token@ in another request to get the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListAuthorizedViewsResponse' with the minimum fields required to make a request.
  newListAuthorizedViewsResponse ::
    ListAuthorizedViewsResponse
  newListAuthorizedViewsResponse =
    ListAuthorizedViewsResponse
      { authorizedViews = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListAuthorizedViewsResponse where
    parseJSON =
      Core.withObject
        "ListAuthorizedViewsResponse"
        ( \o ->
            ListAuthorizedViewsResponse
              Core.<$> (o Core..:? "authorizedViews")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListAuthorizedViewsResponse where
    toJSON ListAuthorizedViewsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("authorizedViews" Core..=) Core.<$> authorizedViews,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | The response for ListBackups.
  --
  -- /See:/ 'newListBackupsResponse' smart constructor.
  data ListBackupsResponse = ListBackupsResponse
    { -- | The list of matching backups.
      backups :: (Core.Maybe [Backup]),
      -- | @next_page_token@ can be sent in a subsequent ListBackups call to fetch more of the matching backups.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListBackupsResponse' with the minimum fields required to make a request.
  newListBackupsResponse ::
    ListBackupsResponse
  newListBackupsResponse =
    ListBackupsResponse
      { backups = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListBackupsResponse where
    parseJSON =
      Core.withObject
        "ListBackupsResponse"
        ( \o ->
            ListBackupsResponse
              Core.<$> (o Core..:? "backups")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListBackupsResponse where
    toJSON ListBackupsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("backups" Core..=) Core.<$> backups,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for BigtableInstanceAdmin.ListClusters.
  --
  -- /See:/ 'newListClustersResponse' smart constructor.
  data ListClustersResponse = ListClustersResponse
    { -- | The list of requested clusters.
      clusters :: (Core.Maybe [Cluster]),
      -- | Locations from which Cluster information could not be retrieved, due to an outage or some other transient condition. Clusters from these locations may be missing from @clusters@, or may only have partial information returned. Values are of the form @projects\/\/locations\/@
      failedLocations :: (Core.Maybe [Core.Text]),
      -- | DEPRECATED: This field is unused and ignored.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListClustersResponse' with the minimum fields required to make a request.
  newListClustersResponse ::
    ListClustersResponse
  newListClustersResponse =
    ListClustersResponse
      { clusters = Core.Nothing,
        failedLocations = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListClustersResponse where
    parseJSON =
      Core.withObject
        "ListClustersResponse"
        ( \o ->
            ListClustersResponse
              Core.<$> (o Core..:? "clusters")
              Core.<*> (o Core..:? "failedLocations")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListClustersResponse where
    toJSON ListClustersResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("clusters" Core..=) Core.<$> clusters,
              ("failedLocations" Core..=) Core.<$> failedLocations,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for BigtableInstanceAdmin.ListHotTablets.
  --
  -- /See:/ 'newListHotTabletsResponse' smart constructor.
  data ListHotTabletsResponse = ListHotTabletsResponse
    { -- | List of hot tablets in the tables of the requested cluster that fall within the requested time range. Hot tablets are ordered by node cpu usage percent. If there are multiple hot tablets that correspond to the same tablet within a 15-minute interval, only the hot tablet with the highest node cpu usage will be included in the response.
      hotTablets :: (Core.Maybe [HotTablet]),
      -- | Set if not all hot tablets could be returned in a single response. Pass this value to @page_token@ in another request to get the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListHotTabletsResponse' with the minimum fields required to make a request.
  newListHotTabletsResponse ::
    ListHotTabletsResponse
  newListHotTabletsResponse =
    ListHotTabletsResponse
      { hotTablets = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListHotTabletsResponse where
    parseJSON =
      Core.withObject
        "ListHotTabletsResponse"
        ( \o ->
            ListHotTabletsResponse
              Core.<$> (o Core..:? "hotTablets")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListHotTabletsResponse where
    toJSON ListHotTabletsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("hotTablets" Core..=) Core.<$> hotTablets,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for BigtableInstanceAdmin.ListInstances.
  --
  -- /See:/ 'newListInstancesResponse' smart constructor.
  data ListInstancesResponse = ListInstancesResponse
    { -- | Locations from which Instance information could not be retrieved, due to an outage or some other transient condition. Instances whose Clusters are all in one of the failed locations may be missing from @instances@, and Instances with at least one Cluster in a failed location may only have partial information returned. Values are of the form @projects\/\/locations\/@
      failedLocations :: (Core.Maybe [Core.Text]),
      -- | The list of requested instances.
      instances :: (Core.Maybe [Instance]),
      -- | DEPRECATED: This field is unused and ignored.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListInstancesResponse' with the minimum fields required to make a request.
  newListInstancesResponse ::
    ListInstancesResponse
  newListInstancesResponse =
    ListInstancesResponse
      { failedLocations = Core.Nothing,
        instances = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListInstancesResponse where
    parseJSON =
      Core.withObject
        "ListInstancesResponse"
        ( \o ->
            ListInstancesResponse
              Core.<$> (o Core..:? "failedLocations")
              Core.<*> (o Core..:? "instances")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListInstancesResponse where
    toJSON ListInstancesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("failedLocations" Core..=) Core.<$> failedLocations,
              ("instances" Core..=) Core.<$> instances,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | The response message for Locations.ListLocations.
  --
  -- /See:/ 'newListLocationsResponse' smart constructor.
  data ListLocationsResponse = ListLocationsResponse
    { -- | A list of locations that matches the specified filter in the request.
      locations :: (Core.Maybe [Location]),
      -- | The standard List next-page token.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListLocationsResponse' with the minimum fields required to make a request.
  newListLocationsResponse ::
    ListLocationsResponse
  newListLocationsResponse =
    ListLocationsResponse
      { locations = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListLocationsResponse where
    parseJSON =
      Core.withObject
        "ListLocationsResponse"
        ( \o ->
            ListLocationsResponse
              Core.<$> (o Core..:? "locations")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListLocationsResponse where
    toJSON ListLocationsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("locations" Core..=) Core.<$> locations,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | The response message for Operations.ListOperations.
  --
  -- /See:/ 'newListOperationsResponse' smart constructor.
  data ListOperationsResponse = ListOperationsResponse
    { -- | The standard List next-page token.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | A list of operations that matches the specified filter in the request.
      operations :: (Core.Maybe [Operation])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListOperationsResponse' with the minimum fields required to make a request.
  newListOperationsResponse ::
    ListOperationsResponse
  newListOperationsResponse =
    ListOperationsResponse
      { nextPageToken = Core.Nothing,
        operations = Core.Nothing
      }
  
  instance Core.FromJSON ListOperationsResponse where
    parseJSON =
      Core.withObject
        "ListOperationsResponse"
        ( \o ->
            ListOperationsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "operations")
        )
  
  instance Core.ToJSON ListOperationsResponse where
    toJSON ListOperationsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("operations" Core..=) Core.<$> operations
            ]
        )
  
  -- | Response message for google.bigtable.admin.v2.BigtableTableAdmin.ListTables
  --
  -- /See:/ 'newListTablesResponse' smart constructor.
  data ListTablesResponse = ListTablesResponse
    { -- | Set if not all tables could be returned in a single response. Pass this value to @page_token@ in another request to get the next page of results.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The tables present in the requested instance.
      tables :: (Core.Maybe [Table])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListTablesResponse' with the minimum fields required to make a request.
  newListTablesResponse ::
    ListTablesResponse
  newListTablesResponse =
    ListTablesResponse
      { nextPageToken = Core.Nothing,
        tables = Core.Nothing
      }
  
  instance Core.FromJSON ListTablesResponse where
    parseJSON =
      Core.withObject
        "ListTablesResponse"
        ( \o ->
            ListTablesResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "tables")
        )
  
  instance Core.ToJSON ListTablesResponse where
    toJSON ListTablesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("tables" Core..=) Core.<$> tables
            ]
        )
  
  -- | A resource that represents a Google Cloud location.
  --
  -- /See:/ 'newLocation' smart constructor.
  data Location = Location
    { -- | The friendly name for this location, typically a nearby city name. For example, \"Tokyo\".
      displayName :: (Core.Maybe Core.Text),
      -- | Cross-service attributes for the location. For example {\"cloud.googleapis.com\/region\": \"us-east1\"}
      labels :: (Core.Maybe Location_Labels),
      -- | The canonical id for this location. For example: @\"us-east1\"@.
      locationId :: (Core.Maybe Core.Text),
      -- | Service-specific metadata. For example the available capacity at the given location.
      metadata :: (Core.Maybe Location_Metadata),
      -- | Resource name for the location, which may vary between implementations. For example: @\"projects\/example-project\/locations\/us-east1\"@
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Location' with the minimum fields required to make a request.
  newLocation ::
    Location
  newLocation =
    Location
      { displayName = Core.Nothing,
        labels = Core.Nothing,
        locationId = Core.Nothing,
        metadata = Core.Nothing,
        name = Core.Nothing
      }
  
  instance Core.FromJSON Location where
    parseJSON =
      Core.withObject
        "Location"
        ( \o ->
            Location
              Core.<$> (o Core..:? "displayName")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "locationId")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON Location where
    toJSON Location {..} =
      Core.object
        ( Core.catMaybes
            [ ("displayName" Core..=) Core.<$> displayName,
              ("labels" Core..=) Core.<$> labels,
              ("locationId" Core..=) Core.<$> locationId,
              ("metadata" Core..=) Core.<$> metadata,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | Cross-service attributes for the location. For example {\"cloud.googleapis.com\/region\": \"us-east1\"}
  --
  -- /See:/ 'newLocation_Labels' smart constructor.
  newtype Location_Labels = Location_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Location_Labels' with the minimum fields required to make a request.
  newLocation_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Location_Labels
  newLocation_Labels additional =
    Location_Labels {additional = additional}
  
  instance Core.FromJSON Location_Labels where
    parseJSON =
      Core.withObject
        "Location_Labels"
        (\o -> Location_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Location_Labels where
    toJSON Location_Labels {..} = Core.toJSON additional
  
  -- | Service-specific metadata. For example the available capacity at the given location.
  --
  -- /See:/ 'newLocation_Metadata' smart constructor.
  newtype Location_Metadata = Location_Metadata
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Location_Metadata' with the minimum fields required to make a request.
  newLocation_Metadata ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Location_Metadata
  newLocation_Metadata additional =
    Location_Metadata {additional = additional}
  
  instance Core.FromJSON Location_Metadata where
    parseJSON =
      Core.withObject
        "Location_Metadata"
        (\o -> Location_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Location_Metadata where
    toJSON Location_Metadata {..} = Core.toJSON additional
  
  -- | A create, update, or delete of a particular column family.
  --
  -- /See:/ 'newModification' smart constructor.
  data Modification = Modification
    { -- | Create a new column family with the specified schema, or fail if one already exists with the given ID.
      create :: (Core.Maybe ColumnFamily),
      -- | Drop (delete) the column family with the given ID, or fail if no such family exists.
      drop :: (Core.Maybe Core.Bool),
      -- | The ID of the column family to be modified.
      id :: (Core.Maybe Core.Text),
      -- | Update an existing column family to the specified schema, or fail if no column family exists with the given ID.
      update :: (Core.Maybe ColumnFamily),
      -- | Optional. A mask specifying which fields (e.g. @gc_rule@) in the @update@ mod should be updated, ignored for other modification types. If unset or empty, we treat it as updating @gc_rule@ to be backward compatible.
      updateMask :: (Core.Maybe Core.FieldMask)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Modification' with the minimum fields required to make a request.
  newModification ::
    Modification
  newModification =
    Modification
      { create = Core.Nothing,
        drop = Core.Nothing,
        id = Core.Nothing,
        update = Core.Nothing,
        updateMask = Core.Nothing
      }
  
  instance Core.FromJSON Modification where
    parseJSON =
      Core.withObject
        "Modification"
        ( \o ->
            Modification
              Core.<$> (o Core..:? "create")
              Core.<*> (o Core..:? "drop")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "update")
              Core.<*> (o Core..:? "updateMask")
        )
  
  instance Core.ToJSON Modification where
    toJSON Modification {..} =
      Core.object
        ( Core.catMaybes
            [ ("create" Core..=) Core.<$> create,
              ("drop" Core..=) Core.<$> drop,
              ("id" Core..=) Core.<$> id,
              ("update" Core..=) Core.<$> update,
              ("updateMask" Core..=) Core.<$> updateMask
            ]
        )
  
  -- | Request message for google.bigtable.admin.v2.BigtableTableAdmin.ModifyColumnFamilies
  --
  -- /See:/ 'newModifyColumnFamiliesRequest' smart constructor.
  data ModifyColumnFamiliesRequest = ModifyColumnFamiliesRequest
    { -- | Optional. If true, ignore safety checks when modifying the column families.
      ignoreWarnings :: (Core.Maybe Core.Bool),
      -- | Required. Modifications to be atomically applied to the specified table\'s families. Entries are applied in order, meaning that earlier modifications can be masked by later ones (in the case of repeated updates to the same family, for example).
      modifications :: (Core.Maybe [Modification])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ModifyColumnFamiliesRequest' with the minimum fields required to make a request.
  newModifyColumnFamiliesRequest ::
    ModifyColumnFamiliesRequest
  newModifyColumnFamiliesRequest =
    ModifyColumnFamiliesRequest
      { ignoreWarnings = Core.Nothing,
        modifications = Core.Nothing
      }
  
  instance Core.FromJSON ModifyColumnFamiliesRequest where
    parseJSON =
      Core.withObject
        "ModifyColumnFamiliesRequest"
        ( \o ->
            ModifyColumnFamiliesRequest
              Core.<$> (o Core..:? "ignoreWarnings")
              Core.<*> (o Core..:? "modifications")
        )
  
  instance Core.ToJSON ModifyColumnFamiliesRequest where
    toJSON ModifyColumnFamiliesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("ignoreWarnings" Core..=) Core.<$> ignoreWarnings,
              ("modifications" Core..=) Core.<$> modifications
            ]
        )
  
  -- | Read\/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes consistency to improve availability.
  --
  -- /See:/ 'newMultiClusterRoutingUseAny' smart constructor.
  data MultiClusterRoutingUseAny = MultiClusterRoutingUseAny
    { -- | The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
      clusterIds :: (Core.Maybe [Core.Text]),
      -- | Row affinity sticky routing based on the row key of the request. Requests that span multiple rows are routed non-deterministically.
      rowAffinity :: (Core.Maybe RowAffinity)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MultiClusterRoutingUseAny' with the minimum fields required to make a request.
  newMultiClusterRoutingUseAny ::
    MultiClusterRoutingUseAny
  newMultiClusterRoutingUseAny =
    MultiClusterRoutingUseAny
      { clusterIds = Core.Nothing,
        rowAffinity = Core.Nothing
      }
  
  instance Core.FromJSON MultiClusterRoutingUseAny where
    parseJSON =
      Core.withObject
        "MultiClusterRoutingUseAny"
        ( \o ->
            MultiClusterRoutingUseAny
              Core.<$> (o Core..:? "clusterIds")
              Core.<*> (o Core..:? "rowAffinity")
        )
  
  instance Core.ToJSON MultiClusterRoutingUseAny where
    toJSON MultiClusterRoutingUseAny {..} =
      Core.object
        ( Core.catMaybes
            [ ("clusterIds" Core..=) Core.<$> clusterIds,
              ("rowAffinity" Core..=) Core.<$> rowAffinity
            ]
        )
  
  -- | This resource represents a long-running operation that is the result of a network API call.
  --
  -- /See:/ 'newOperation' smart constructor.
  data Operation = Operation
    { -- | If the value is @false@, it means the operation is still in progress. If @true@, the operation is completed, and either @error@ or @response@ is available.
      done :: (Core.Maybe Core.Bool),
      -- | The error result of the operation in case of failure or cancellation.
      error :: (Core.Maybe Status),
      -- | Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
      metadata :: (Core.Maybe Operation_Metadata),
      -- | The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the @name@ should be a resource name ending with @operations\/{unique_id}@.
      name :: (Core.Maybe Core.Text),
      -- | The normal, successful response of the operation. If the original method returns no data on success, such as @Delete@, the response is @google.protobuf.Empty@. If the original method is standard @Get@\/@Create@\/@Update@, the response should be the resource. For other methods, the response should have the type @XxxResponse@, where @Xxx@ is the original method name. For example, if the original method name is @TakeSnapshot()@, the inferred response type is @TakeSnapshotResponse@.
      response :: (Core.Maybe Operation_Response)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Operation' with the minimum fields required to make a request.
  newOperation ::
    Operation
  newOperation =
    Operation
      { done = Core.Nothing,
        error = Core.Nothing,
        metadata = Core.Nothing,
        name = Core.Nothing,
        response = Core.Nothing
      }
  
  instance Core.FromJSON Operation where
    parseJSON =
      Core.withObject
        "Operation"
        ( \o ->
            Operation
              Core.<$> (o Core..:? "done")
              Core.<*> (o Core..:? "error")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "response")
        )
  
  instance Core.ToJSON Operation where
    toJSON Operation {..} =
      Core.object
        ( Core.catMaybes
            [ ("done" Core..=) Core.<$> done,
              ("error" Core..=) Core.<$> error,
              ("metadata" Core..=) Core.<$> metadata,
              ("name" Core..=) Core.<$> name,
              ("response" Core..=) Core.<$> response
            ]
        )
  
  -- | Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
  --
  -- /See:/ 'newOperation_Metadata' smart constructor.
  newtype Operation_Metadata = Operation_Metadata
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Operation_Metadata' with the minimum fields required to make a request.
  newOperation_Metadata ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Operation_Metadata
  newOperation_Metadata additional =
    Operation_Metadata {additional = additional}
  
  instance Core.FromJSON Operation_Metadata where
    parseJSON =
      Core.withObject
        "Operation_Metadata"
        (\o -> Operation_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Operation_Metadata where
    toJSON Operation_Metadata {..} = Core.toJSON additional
  
  -- | The normal, successful response of the operation. If the original method returns no data on success, such as @Delete@, the response is @google.protobuf.Empty@. If the original method is standard @Get@\/@Create@\/@Update@, the response should be the resource. For other methods, the response should have the type @XxxResponse@, where @Xxx@ is the original method name. For example, if the original method name is @TakeSnapshot()@, the inferred response type is @TakeSnapshotResponse@.
  --
  -- /See:/ 'newOperation_Response' smart constructor.
  newtype Operation_Response = Operation_Response
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Operation_Response' with the minimum fields required to make a request.
  newOperation_Response ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Operation_Response
  newOperation_Response additional =
    Operation_Response {additional = additional}
  
  instance Core.FromJSON Operation_Response where
    parseJSON =
      Core.withObject
        "Operation_Response"
        (\o -> Operation_Response Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Operation_Response where
    toJSON Operation_Response {..} = Core.toJSON additional
  
  -- | Encapsulates progress related information for a Cloud Bigtable long running operation.
  --
  -- /See:/ 'newOperationProgress' smart constructor.
  data OperationProgress = OperationProgress
    { -- | If set, the time at which this operation failed or was completed successfully.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Percent completion of the operation. Values are between 0 and 100 inclusive.
      progressPercent :: (Core.Maybe Core.Int32),
      -- | Time the request was received.
      startTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OperationProgress' with the minimum fields required to make a request.
  newOperationProgress ::
    OperationProgress
  newOperationProgress =
    OperationProgress
      { endTime = Core.Nothing,
        progressPercent = Core.Nothing,
        startTime = Core.Nothing
      }
  
  instance Core.FromJSON OperationProgress where
    parseJSON =
      Core.withObject
        "OperationProgress"
        ( \o ->
            OperationProgress
              Core.<$> (o Core..:? "endTime")
              Core.<*> (o Core..:? "progressPercent")
              Core.<*> (o Core..:? "startTime")
        )
  
  instance Core.ToJSON OperationProgress where
    toJSON OperationProgress {..} =
      Core.object
        ( Core.catMaybes
            [ ("endTime" Core..=) Core.<$> endTime,
              ("progressPercent" Core..=) Core.<$> progressPercent,
              ("startTime" Core..=) Core.<$> startTime
            ]
        )
  
  -- | Metadata type for the long-running operation used to track the progress of optimizations performed on a newly restored table. This long-running operation is automatically created by the system after the successful completion of a table restore, and cannot be cancelled.
  --
  -- /See:/ 'newOptimizeRestoredTableMetadata' smart constructor.
  data OptimizeRestoredTableMetadata = OptimizeRestoredTableMetadata
    { -- | Name of the restored table being optimized.
      name :: (Core.Maybe Core.Text),
      -- | The progress of the post-restore optimizations.
      progress :: (Core.Maybe OperationProgress)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OptimizeRestoredTableMetadata' with the minimum fields required to make a request.
  newOptimizeRestoredTableMetadata ::
    OptimizeRestoredTableMetadata
  newOptimizeRestoredTableMetadata =
    OptimizeRestoredTableMetadata
      { name = Core.Nothing,
        progress = Core.Nothing
      }
  
  instance Core.FromJSON OptimizeRestoredTableMetadata where
    parseJSON =
      Core.withObject
        "OptimizeRestoredTableMetadata"
        ( \o ->
            OptimizeRestoredTableMetadata
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "progress")
        )
  
  instance Core.ToJSON OptimizeRestoredTableMetadata where
    toJSON OptimizeRestoredTableMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("progress" Core..=) Core.<$> progress
            ]
        )
  
  -- | The metadata for the Operation returned by PartialUpdateCluster.
  --
  -- /See:/ 'newPartialUpdateClusterMetadata' smart constructor.
  data PartialUpdateClusterMetadata = PartialUpdateClusterMetadata
    { -- | The time at which the operation failed or was completed successfully.
      finishTime :: (Core.Maybe Core.DateTime),
      -- | The original request for PartialUpdateCluster.
      originalRequest :: (Core.Maybe PartialUpdateClusterRequest),
      -- | The time at which the original request was received.
      requestTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PartialUpdateClusterMetadata' with the minimum fields required to make a request.
  newPartialUpdateClusterMetadata ::
    PartialUpdateClusterMetadata
  newPartialUpdateClusterMetadata =
    PartialUpdateClusterMetadata
      { finishTime = Core.Nothing,
        originalRequest = Core.Nothing,
        requestTime = Core.Nothing
      }
  
  instance Core.FromJSON PartialUpdateClusterMetadata where
    parseJSON =
      Core.withObject
        "PartialUpdateClusterMetadata"
        ( \o ->
            PartialUpdateClusterMetadata
              Core.<$> (o Core..:? "finishTime")
              Core.<*> (o Core..:? "originalRequest")
              Core.<*> (o Core..:? "requestTime")
        )
  
  instance Core.ToJSON PartialUpdateClusterMetadata where
    toJSON PartialUpdateClusterMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("finishTime" Core..=) Core.<$> finishTime,
              ("originalRequest" Core..=) Core.<$> originalRequest,
              ("requestTime" Core..=) Core.<$> requestTime
            ]
        )
  
  -- | Request message for BigtableInstanceAdmin.PartialUpdateCluster.
  --
  -- /See:/ 'newPartialUpdateClusterRequest' smart constructor.
  data PartialUpdateClusterRequest = PartialUpdateClusterRequest
    { -- | Required. The Cluster which contains the partial updates to be applied, subject to the update_mask.
      cluster :: (Core.Maybe Cluster),
      -- | Required. The subset of Cluster fields which should be replaced.
      updateMask :: (Core.Maybe Core.FieldMask)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PartialUpdateClusterRequest' with the minimum fields required to make a request.
  newPartialUpdateClusterRequest ::
    PartialUpdateClusterRequest
  newPartialUpdateClusterRequest =
    PartialUpdateClusterRequest
      { cluster = Core.Nothing,
        updateMask = Core.Nothing
      }
  
  instance Core.FromJSON PartialUpdateClusterRequest where
    parseJSON =
      Core.withObject
        "PartialUpdateClusterRequest"
        ( \o ->
            PartialUpdateClusterRequest
              Core.<$> (o Core..:? "cluster")
              Core.<*> (o Core..:? "updateMask")
        )
  
  instance Core.ToJSON PartialUpdateClusterRequest where
    toJSON PartialUpdateClusterRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("cluster" Core..=) Core.<$> cluster,
              ("updateMask" Core..=) Core.<$> updateMask
            ]
        )
  
  -- | Request message for BigtableInstanceAdmin.PartialUpdateInstance.
  --
  -- /See:/ 'newPartialUpdateInstanceRequest' smart constructor.
  data PartialUpdateInstanceRequest = PartialUpdateInstanceRequest
    { -- | Required. The Instance which will (partially) replace the current value.
      instance' :: (Core.Maybe Instance),
      -- | Required. The subset of Instance fields which should be replaced. Must be explicitly set.
      updateMask :: (Core.Maybe Core.FieldMask)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PartialUpdateInstanceRequest' with the minimum fields required to make a request.
  newPartialUpdateInstanceRequest ::
    PartialUpdateInstanceRequest
  newPartialUpdateInstanceRequest =
    PartialUpdateInstanceRequest
      { instance' = Core.Nothing,
        updateMask = Core.Nothing
      }
  
  instance Core.FromJSON PartialUpdateInstanceRequest where
    parseJSON =
      Core.withObject
        "PartialUpdateInstanceRequest"
        ( \o ->
            PartialUpdateInstanceRequest
              Core.<$> (o Core..:? "instance")
              Core.<*> (o Core..:? "updateMask")
        )
  
  instance Core.ToJSON PartialUpdateInstanceRequest where
    toJSON PartialUpdateInstanceRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("instance" Core..=) Core.<$> instance',
              ("updateMask" Core..=) Core.<$> updateMask
            ]
        )
  
  -- | An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A @Policy@ is a collection of @bindings@. A @binding@ binds one or more @members@, or principals, to a single @role@. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A @role@ is a named list of permissions; each @role@ can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a @binding@ can also specify a @condition@, which is a logical expression that allows access to a resource only if the expression evaluates to @true@. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the <https://cloud.google.com/iam/help/conditions/resource-policies IAM documentation>. __JSON example:__
  -- @{ \"bindings\": [ { \"role\": \"roles\/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike\@example.com\", \"group:admins\@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id\@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles\/resourcemanager.organizationViewer\", \"members\": [ \"user:eve\@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time \< timestamp(\'2020-10-01T00:00:00.000Z\')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 }@ __YAML example:__
  -- @bindings: - members: - user:mike\@example.com - group:admins\@example.com - domain:google.com - serviceAccount:my-project-id\@appspot.gserviceaccount.com role: roles\/resourcemanager.organizationAdmin - members: - user:eve\@example.com role: roles\/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time \< timestamp(\'2020-10-01T00:00:00.000Z\') etag: BwWWja0YfJA= version: 3@ For a description of IAM and its features, see the <https://cloud.google.com/iam/docs/ IAM documentation>.
  --
  -- /See:/ 'newPolicy' smart constructor.
  data Policy = Policy
    { -- | Specifies cloud audit logging configuration for this policy.
      auditConfigs :: (Core.Maybe [AuditConfig]),
      -- | Associates a list of @members@, or principals, with a @role@. Optionally, may specify a @condition@ that determines how and when the @bindings@ are applied. Each of the @bindings@ must contain at least one principal. The @bindings@ in a @Policy@ can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a principal counts towards these limits. For example, if the @bindings@ grant 50 different roles to @user:alice\@example.com@, and not to any other principal, then you can add another 1,450 principals to the @bindings@ in the @Policy@.
      bindings :: (Core.Maybe [Binding]),
      -- | @etag@ is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the @etag@ in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An @etag@ is returned in the response to @getIamPolicy@, and systems are expected to put that etag in the request to @setIamPolicy@ to ensure that their change will be applied to the same version of the policy. __Important:__ If you use IAM Conditions, you must include the @etag@ field whenever you call @setIamPolicy@. If you omit this field, then IAM allows you to overwrite a version @3@ policy with a version @1@ policy, and all of the conditions in the version @3@ policy are lost.
      etag :: (Core.Maybe Core.Base64),
      -- | Specifies the format of the policy. Valid values are @0@, @1@, and @3@. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version @3@. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions __Important:__ If you use IAM Conditions, you must include the @etag@ field whenever you call @setIamPolicy@. If you omit this field, then IAM allows you to overwrite a version @3@ policy with a version @1@ policy, and all of the conditions in the version @3@ policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the
      -- <https://cloud.google.com/iam/help/conditions/resource-policies IAM documentation>.
      version :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Policy' with the minimum fields required to make a request.
  newPolicy ::
    Policy
  newPolicy =
    Policy
      { auditConfigs = Core.Nothing,
        bindings = Core.Nothing,
        etag = Core.Nothing,
        version = Core.Nothing
      }
  
  instance Core.FromJSON Policy where
    parseJSON =
      Core.withObject
        "Policy"
        ( \o ->
            Policy
              Core.<$> (o Core..:? "auditConfigs")
              Core.<*> (o Core..:? "bindings")
              Core.<*> (o Core..:? "etag")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON Policy where
    toJSON Policy {..} =
      Core.object
        ( Core.catMaybes
            [ ("auditConfigs" Core..=) Core.<$> auditConfigs,
              ("bindings" Core..=) Core.<$> bindings,
              ("etag" Core..=) Core.<$> etag,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | Information about a table restore.
  --
  -- /See:/ 'newRestoreInfo' smart constructor.
  data RestoreInfo = RestoreInfo
    { -- | Information about the backup used to restore the table. The backup may no longer exist.
      backupInfo :: (Core.Maybe BackupInfo),
      -- | The type of the restore source.
      sourceType :: (Core.Maybe RestoreInfo_SourceType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RestoreInfo' with the minimum fields required to make a request.
  newRestoreInfo ::
    RestoreInfo
  newRestoreInfo =
    RestoreInfo {backupInfo = Core.Nothing, sourceType = Core.Nothing}
  
  instance Core.FromJSON RestoreInfo where
    parseJSON =
      Core.withObject
        "RestoreInfo"
        ( \o ->
            RestoreInfo
              Core.<$> (o Core..:? "backupInfo")
              Core.<*> (o Core..:? "sourceType")
        )
  
  instance Core.ToJSON RestoreInfo where
    toJSON RestoreInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("backupInfo" Core..=) Core.<$> backupInfo,
              ("sourceType" Core..=) Core.<$> sourceType
            ]
        )
  
  -- | Metadata type for the long-running operation returned by RestoreTable.
  --
  -- /See:/ 'newRestoreTableMetadata' smart constructor.
  data RestoreTableMetadata = RestoreTableMetadata
    { backupInfo :: (Core.Maybe BackupInfo),
      -- | Name of the table being created and restored to.
      name :: (Core.Maybe Core.Text),
      -- | If exists, the name of the long-running operation that will be used to track the post-restore optimization process to optimize the performance of the restored table. The metadata type of the long-running operation is OptimizeRestoredTableMetadata. The response type is Empty. This long-running operation may be automatically created by the system if applicable after the RestoreTable long-running operation completes successfully. This operation may not be created if the table is already optimized or the restore was not successful.
      optimizeTableOperationName :: (Core.Maybe Core.Text),
      -- | The progress of the RestoreTable operation.
      progress :: (Core.Maybe OperationProgress),
      -- | The type of the restore source.
      sourceType :: (Core.Maybe RestoreTableMetadata_SourceType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RestoreTableMetadata' with the minimum fields required to make a request.
  newRestoreTableMetadata ::
    RestoreTableMetadata
  newRestoreTableMetadata =
    RestoreTableMetadata
      { backupInfo = Core.Nothing,
        name = Core.Nothing,
        optimizeTableOperationName = Core.Nothing,
        progress = Core.Nothing,
        sourceType = Core.Nothing
      }
  
  instance Core.FromJSON RestoreTableMetadata where
    parseJSON =
      Core.withObject
        "RestoreTableMetadata"
        ( \o ->
            RestoreTableMetadata
              Core.<$> (o Core..:? "backupInfo")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "optimizeTableOperationName")
              Core.<*> (o Core..:? "progress")
              Core.<*> (o Core..:? "sourceType")
        )
  
  instance Core.ToJSON RestoreTableMetadata where
    toJSON RestoreTableMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("backupInfo" Core..=) Core.<$> backupInfo,
              ("name" Core..=) Core.<$> name,
              ("optimizeTableOperationName" Core..=)
                Core.<$> optimizeTableOperationName,
              ("progress" Core..=) Core.<$> progress,
              ("sourceType" Core..=) Core.<$> sourceType
            ]
        )
  
  -- | The request for RestoreTable.
  --
  -- /See:/ 'newRestoreTableRequest' smart constructor.
  data RestoreTableRequest = RestoreTableRequest
    { -- | Name of the backup from which to restore. Values are of the form @projects\/\/instances\/\/clusters\/\/backups\/@.
      backup :: (Core.Maybe Core.Text),
      -- | Required. The id of the table to create and restore to. This table must not already exist. The @table_id@ appended to @parent@ forms the full table name of the form @projects\/\/instances\/\/tables\/@.
      tableId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RestoreTableRequest' with the minimum fields required to make a request.
  newRestoreTableRequest ::
    RestoreTableRequest
  newRestoreTableRequest =
    RestoreTableRequest
      { backup = Core.Nothing,
        tableId = Core.Nothing
      }
  
  instance Core.FromJSON RestoreTableRequest where
    parseJSON =
      Core.withObject
        "RestoreTableRequest"
        ( \o ->
            RestoreTableRequest
              Core.<$> (o Core..:? "backup")
              Core.<*> (o Core..:? "tableId")
        )
  
  instance Core.ToJSON RestoreTableRequest where
    toJSON RestoreTableRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("backup" Core..=) Core.<$> backup,
              ("tableId" Core..=) Core.<$> tableId
            ]
        )
  
  -- | If enabled, Bigtable will route the request based on the row key of the request, rather than randomly. Instead, each row key will be assigned to a cluster, and will stick to that cluster. If clusters are added or removed, then this may affect which row keys stick to which clusters. To avoid this, users can use a cluster group to specify which clusters are to be used. In this case, new clusters that are not a part of the cluster group will not be routed to, and routing will be unaffected by the new cluster. Moreover, clusters specified in the cluster group cannot be deleted unless removed from the cluster group.
  --
  -- /See:/ 'newRowAffinity' smart constructor.
  data RowAffinity = RowAffinity
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RowAffinity' with the minimum fields required to make a request.
  newRowAffinity ::
    RowAffinity
  newRowAffinity = RowAffinity
  
  instance Core.FromJSON RowAffinity where
    parseJSON =
      Core.withObject "RowAffinity" (\o -> Core.pure RowAffinity)
  
  instance Core.ToJSON RowAffinity where
    toJSON = Core.const Core.emptyObject
  
  -- | Request message for @SetIamPolicy@ method.
  --
  -- /See:/ 'newSetIamPolicyRequest' smart constructor.
  data SetIamPolicyRequest = SetIamPolicyRequest
    { -- | REQUIRED: The complete policy to be applied to the @resource@. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them.
      policy :: (Core.Maybe Policy),
      -- | OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: @paths: \"bindings, etag\"@
      updateMask :: (Core.Maybe Core.FieldMask)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SetIamPolicyRequest' with the minimum fields required to make a request.
  newSetIamPolicyRequest ::
    SetIamPolicyRequest
  newSetIamPolicyRequest =
    SetIamPolicyRequest
      { policy = Core.Nothing,
        updateMask = Core.Nothing
      }
  
  instance Core.FromJSON SetIamPolicyRequest where
    parseJSON =
      Core.withObject
        "SetIamPolicyRequest"
        ( \o ->
            SetIamPolicyRequest
              Core.<$> (o Core..:? "policy")
              Core.<*> (o Core..:? "updateMask")
        )
  
  instance Core.ToJSON SetIamPolicyRequest where
    toJSON SetIamPolicyRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("policy" Core..=) Core.<$> policy,
              ("updateMask" Core..=) Core.<$> updateMask
            ]
        )
  
  -- | Unconditionally routes all read\/write requests to a specific cluster. This option preserves read-your-writes consistency but does not improve availability.
  --
  -- /See:/ 'newSingleClusterRouting' smart constructor.
  data SingleClusterRouting = SingleClusterRouting
    { -- | Whether or not @CheckAndMutateRow@ and @ReadModifyWriteRow@ requests are allowed by this app profile. It is unsafe to send these requests to the same table\/row\/column in multiple clusters.
      allowTransactionalWrites :: (Core.Maybe Core.Bool),
      -- | The cluster to which read\/write requests should be routed.
      clusterId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SingleClusterRouting' with the minimum fields required to make a request.
  newSingleClusterRouting ::
    SingleClusterRouting
  newSingleClusterRouting =
    SingleClusterRouting
      { allowTransactionalWrites = Core.Nothing,
        clusterId = Core.Nothing
      }
  
  instance Core.FromJSON SingleClusterRouting where
    parseJSON =
      Core.withObject
        "SingleClusterRouting"
        ( \o ->
            SingleClusterRouting
              Core.<$> (o Core..:? "allowTransactionalWrites")
              Core.<*> (o Core..:? "clusterId")
        )
  
  instance Core.ToJSON SingleClusterRouting where
    toJSON SingleClusterRouting {..} =
      Core.object
        ( Core.catMaybes
            [ ("allowTransactionalWrites" Core..=)
                Core.<$> allowTransactionalWrites,
              ("clusterId" Core..=) Core.<$> clusterId
            ]
        )
  
  -- | An initial split point for a newly created table.
  --
  -- /See:/ 'newSplit' smart constructor.
  newtype Split = Split
    { -- | Row key to use as an initial tablet boundary.
      key :: (Core.Maybe Core.Base64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Split' with the minimum fields required to make a request.
  newSplit ::
    Split
  newSplit = Split {key = Core.Nothing}
  
  instance Core.FromJSON Split where
    parseJSON =
      Core.withObject
        "Split"
        (\o -> Split Core.<$> (o Core..:? "key"))
  
  instance Core.ToJSON Split where
    toJSON Split {..} =
      Core.object (Core.catMaybes [("key" Core..=) Core.<$> key])
  
  -- | Standard options for isolating this app profile\'s traffic from other use cases.
  --
  -- /See:/ 'newStandardIsolation' smart constructor.
  newtype StandardIsolation = StandardIsolation
    { -- | The priority of requests sent using this app profile.
      priority :: (Core.Maybe StandardIsolation_Priority)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StandardIsolation' with the minimum fields required to make a request.
  newStandardIsolation ::
    StandardIsolation
  newStandardIsolation = StandardIsolation {priority = Core.Nothing}
  
  instance Core.FromJSON StandardIsolation where
    parseJSON =
      Core.withObject
        "StandardIsolation"
        (\o -> StandardIsolation Core.<$> (o Core..:? "priority"))
  
  instance Core.ToJSON StandardIsolation where
    toJSON StandardIsolation {..} =
      Core.object
        (Core.catMaybes [("priority" Core..=) Core.<$> priority])
  
  -- | Checks that all writes before the consistency token was generated are replicated in every cluster and readable.
  --
  -- /See:/ 'newStandardReadRemoteWrites' smart constructor.
  data StandardReadRemoteWrites = StandardReadRemoteWrites
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StandardReadRemoteWrites' with the minimum fields required to make a request.
  newStandardReadRemoteWrites ::
    StandardReadRemoteWrites
  newStandardReadRemoteWrites = StandardReadRemoteWrites
  
  instance Core.FromJSON StandardReadRemoteWrites where
    parseJSON =
      Core.withObject
        "StandardReadRemoteWrites"
        (\o -> Core.pure StandardReadRemoteWrites)
  
  instance Core.ToJSON StandardReadRemoteWrites where
    toJSON = Core.const Core.emptyObject
  
  -- | The @Status@ type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by <https://github.com/grpc gRPC>. Each @Status@ message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the <https://cloud.google.com/apis/design/errors API Design Guide>.
  --
  -- /See:/ 'newStatus' smart constructor.
  data Status = Status
    { -- | The status code, which should be an enum value of google.rpc.Code.
      code :: (Core.Maybe Core.Int32),
      -- | A list of messages that carry the error details. There is a common set of message types for APIs to use.
      details :: (Core.Maybe [Status_DetailsItem]),
      -- | A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
      message :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Status' with the minimum fields required to make a request.
  newStatus ::
    Status
  newStatus =
    Status
      { code = Core.Nothing,
        details = Core.Nothing,
        message = Core.Nothing
      }
  
  instance Core.FromJSON Status where
    parseJSON =
      Core.withObject
        "Status"
        ( \o ->
            Status
              Core.<$> (o Core..:? "code")
              Core.<*> (o Core..:? "details")
              Core.<*> (o Core..:? "message")
        )
  
  instance Core.ToJSON Status where
    toJSON Status {..} =
      Core.object
        ( Core.catMaybes
            [ ("code" Core..=) Core.<$> code,
              ("details" Core..=) Core.<$> details,
              ("message" Core..=) Core.<$> message
            ]
        )
  
  --
  -- /See:/ 'newStatus_DetailsItem' smart constructor.
  newtype Status_DetailsItem = Status_DetailsItem
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Status_DetailsItem' with the minimum fields required to make a request.
  newStatus_DetailsItem ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Status_DetailsItem
  newStatus_DetailsItem additional =
    Status_DetailsItem {additional = additional}
  
  instance Core.FromJSON Status_DetailsItem where
    parseJSON =
      Core.withObject
        "Status_DetailsItem"
        (\o -> Status_DetailsItem Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Status_DetailsItem where
    toJSON Status_DetailsItem {..} = Core.toJSON additional
  
  -- | A collection of user data indexed by row, column, and timestamp. Each table is served using the resources of its parent cluster.
  --
  -- /See:/ 'newTable' smart constructor.
  data Table = Table
    { -- | If specified, automated backups are enabled for this table. Otherwise, automated backups are disabled.
      automatedBackupPolicy :: (Core.Maybe AutomatedBackupPolicy),
      -- | If specified, enable the change stream on this table. Otherwise, the change stream is disabled and the change stream is not retained.
      changeStreamConfig :: (Core.Maybe ChangeStreamConfig),
      -- | Output only. Map from cluster ID to per-cluster table state. If it could not be determined whether or not the table has data in a particular cluster (for example, if its zone is unavailable), then there will be an entry for the cluster with UNKNOWN @replication_status@. Views: @REPLICATION_VIEW@, @ENCRYPTION_VIEW@, @FULL@
      clusterStates :: (Core.Maybe Table_ClusterStates),
      -- | The column families configured for this table, mapped by column family ID. Views: @SCHEMA_VIEW@, @STATS_VIEW@, @FULL@
      columnFamilies :: (Core.Maybe Table_ColumnFamilies),
      -- | Set to true to make the table protected against data loss. i.e. deleting the following resources through Admin APIs are prohibited: * The table. * The column families in the table. * The instance containing the table. Note one can still delete the data stored in the table through Data APIs.
      deletionProtection :: (Core.Maybe Core.Bool),
      -- | Immutable. The granularity (i.e. @MILLIS@) at which timestamps are stored in this table. Timestamps not matching the granularity will be rejected. If unspecified at creation time, the value will be set to @MILLIS@. Views: @SCHEMA_VIEW@, @FULL@.
      granularity :: (Core.Maybe Table_Granularity),
      -- | The unique name of the table. Values are of the form @projects\/{project}\/instances\/{instance}\/tables\/_a-zA-Z0-9*@. Views: @NAME_ONLY@, @SCHEMA_VIEW@, @REPLICATION_VIEW@, @STATS_VIEW@, @FULL@
      name :: (Core.Maybe Core.Text),
      -- | Output only. If this table was restored from another data source (e.g. a backup), this field will be populated with information about the restore.
      restoreInfo :: (Core.Maybe RestoreInfo),
      -- | Output only. Only available with STATS_VIEW, this includes summary statistics about the entire table contents. For statistics about a specific column family, see ColumnFamilyStats in the mapped ColumnFamily collection above.
      stats :: (Core.Maybe TableStats)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Table' with the minimum fields required to make a request.
  newTable ::
    Table
  newTable =
    Table
      { automatedBackupPolicy = Core.Nothing,
        changeStreamConfig = Core.Nothing,
        clusterStates = Core.Nothing,
        columnFamilies = Core.Nothing,
        deletionProtection = Core.Nothing,
        granularity = Core.Nothing,
        name = Core.Nothing,
        restoreInfo = Core.Nothing,
        stats = Core.Nothing
      }
  
  instance Core.FromJSON Table where
    parseJSON =
      Core.withObject
        "Table"
        ( \o ->
            Table
              Core.<$> (o Core..:? "automatedBackupPolicy")
              Core.<*> (o Core..:? "changeStreamConfig")
              Core.<*> (o Core..:? "clusterStates")
              Core.<*> (o Core..:? "columnFamilies")
              Core.<*> (o Core..:? "deletionProtection")
              Core.<*> (o Core..:? "granularity")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "restoreInfo")
              Core.<*> (o Core..:? "stats")
        )
  
  instance Core.ToJSON Table where
    toJSON Table {..} =
      Core.object
        ( Core.catMaybes
            [ ("automatedBackupPolicy" Core..=) Core.<$> automatedBackupPolicy,
              ("changeStreamConfig" Core..=) Core.<$> changeStreamConfig,
              ("clusterStates" Core..=) Core.<$> clusterStates,
              ("columnFamilies" Core..=) Core.<$> columnFamilies,
              ("deletionProtection" Core..=) Core.<$> deletionProtection,
              ("granularity" Core..=) Core.<$> granularity,
              ("name" Core..=) Core.<$> name,
              ("restoreInfo" Core..=) Core.<$> restoreInfo,
              ("stats" Core..=) Core.<$> stats
            ]
        )
  
  -- | Output only. Map from cluster ID to per-cluster table state. If it could not be determined whether or not the table has data in a particular cluster (for example, if its zone is unavailable), then there will be an entry for the cluster with UNKNOWN @replication_status@. Views: @REPLICATION_VIEW@, @ENCRYPTION_VIEW@, @FULL@
  --
  -- /See:/ 'newTable_ClusterStates' smart constructor.
  newtype Table_ClusterStates = Table_ClusterStates
    { additional :: (Core.HashMap Core.Text ClusterState)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Table_ClusterStates' with the minimum fields required to make a request.
  newTable_ClusterStates ::
    -- |  See 'additional'.
    Core.HashMap Core.Text ClusterState ->
    Table_ClusterStates
  newTable_ClusterStates additional =
    Table_ClusterStates {additional = additional}
  
  instance Core.FromJSON Table_ClusterStates where
    parseJSON =
      Core.withObject
        "Table_ClusterStates"
        (\o -> Table_ClusterStates Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Table_ClusterStates where
    toJSON Table_ClusterStates {..} = Core.toJSON additional
  
  -- | The column families configured for this table, mapped by column family ID. Views: @SCHEMA_VIEW@, @STATS_VIEW@, @FULL@
  --
  -- /See:/ 'newTable_ColumnFamilies' smart constructor.
  newtype Table_ColumnFamilies = Table_ColumnFamilies
    { additional :: (Core.HashMap Core.Text ColumnFamily)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Table_ColumnFamilies' with the minimum fields required to make a request.
  newTable_ColumnFamilies ::
    -- |  See 'additional'.
    Core.HashMap Core.Text ColumnFamily ->
    Table_ColumnFamilies
  newTable_ColumnFamilies additional =
    Table_ColumnFamilies {additional = additional}
  
  instance Core.FromJSON Table_ColumnFamilies where
    parseJSON =
      Core.withObject
        "Table_ColumnFamilies"
        (\o -> Table_ColumnFamilies Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Table_ColumnFamilies where
    toJSON Table_ColumnFamilies {..} = Core.toJSON additional
  
  -- | Progress info for copying a table\'s data to the new cluster.
  --
  -- /See:/ 'newTableProgress' smart constructor.
  data TableProgress = TableProgress
    { -- | Estimate of the number of bytes copied so far for this table. This will eventually reach \'estimated/size/bytes\' unless the table copy is CANCELLED.
      estimatedCopiedBytes :: (Core.Maybe Core.Int64),
      -- | Estimate of the size of the table to be copied.
      estimatedSizeBytes :: (Core.Maybe Core.Int64),
      state :: (Core.Maybe TableProgress_State)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TableProgress' with the minimum fields required to make a request.
  newTableProgress ::
    TableProgress
  newTableProgress =
    TableProgress
      { estimatedCopiedBytes = Core.Nothing,
        estimatedSizeBytes = Core.Nothing,
        state = Core.Nothing
      }
  
  instance Core.FromJSON TableProgress where
    parseJSON =
      Core.withObject
        "TableProgress"
        ( \o ->
            TableProgress
              Core.<$> ( o
                           Core..:? "estimatedCopiedBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "estimatedSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "state")
        )
  
  instance Core.ToJSON TableProgress where
    toJSON TableProgress {..} =
      Core.object
        ( Core.catMaybes
            [ ("estimatedCopiedBytes" Core..=)
                Core.. Core.AsText
                Core.<$> estimatedCopiedBytes,
              ("estimatedSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> estimatedSizeBytes,
              ("state" Core..=) Core.<$> state
            ]
        )
  
  -- | Approximate statistics related to a table. These statistics are calculated infrequently, while simultaneously, data in the table can change rapidly. Thus the values reported here (e.g. row count) are very likely out-of date, even the instant they are received in this API. Thus, only treat these values as approximate. IMPORTANT: Everything below is approximate, unless otherwise specified.
  --
  -- /See:/ 'newTableStats' smart constructor.
  data TableStats = TableStats
    { -- | How many cells are present per column (column family, column qualifier) combinations, averaged over all columns in all rows in the table. e.g. A table with 2 rows: * A row with 3 cells in \"family:col\" and 1 cell in \"other:col\" (4 cells \/ 2 columns) * A row with 1 cell in \"family:col\", 7 cells in \"family:other_col\", and 7 cells in \"other:data\" (15 cells \/ 3 columns) would report (4 + 15)\/(2 + 3) = 3.8 in this field.
      averageCellsPerColumn :: (Core.Maybe Core.Double),
      -- | How many (column family, column qualifier) combinations are present per row in the table, averaged over all rows in the table. e.g. A table with 2 rows: * A row with cells in \"family:col\" and \"other:col\" (2 distinct columns) * A row with cells in \"family:col\", \"family:other_col\", and \"other:data\" (3 distinct columns) would report (2 + 3)\/2 = 2.5 in this field.
      averageColumnsPerRow :: (Core.Maybe Core.Double),
      -- | This is roughly how many bytes would be needed to read the entire table (e.g. by streaming all contents out).
      logicalDataBytes :: (Core.Maybe Core.Int64),
      -- | How many rows are in the table.
      rowCount :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TableStats' with the minimum fields required to make a request.
  newTableStats ::
    TableStats
  newTableStats =
    TableStats
      { averageCellsPerColumn = Core.Nothing,
        averageColumnsPerRow = Core.Nothing,
        logicalDataBytes = Core.Nothing,
        rowCount = Core.Nothing
      }
  
  instance Core.FromJSON TableStats where
    parseJSON =
      Core.withObject
        "TableStats"
        ( \o ->
            TableStats
              Core.<$> (o Core..:? "averageCellsPerColumn")
              Core.<*> (o Core..:? "averageColumnsPerRow")
              Core.<*> (o Core..:? "logicalDataBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "rowCount" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON TableStats where
    toJSON TableStats {..} =
      Core.object
        ( Core.catMaybes
            [ ("averageCellsPerColumn" Core..=) Core.<$> averageCellsPerColumn,
              ("averageColumnsPerRow" Core..=) Core.<$> averageColumnsPerRow,
              ("logicalDataBytes" Core..=)
                Core.. Core.AsText
                Core.<$> logicalDataBytes,
              ("rowCount" Core..=) Core.. Core.AsText Core.<$> rowCount
            ]
        )
  
  -- | Request message for @TestIamPermissions@ method.
  --
  -- /See:/ 'newTestIamPermissionsRequest' smart constructor.
  newtype TestIamPermissionsRequest = TestIamPermissionsRequest
    { -- | The set of permissions to check for the @resource@. Permissions with wildcards (such as @*@ or @storage.*@) are not allowed. For more information see <https://cloud.google.com/iam/docs/overview#permissions IAM Overview>.
      permissions :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TestIamPermissionsRequest' with the minimum fields required to make a request.
  newTestIamPermissionsRequest ::
    TestIamPermissionsRequest
  newTestIamPermissionsRequest =
    TestIamPermissionsRequest {permissions = Core.Nothing}
  
  instance Core.FromJSON TestIamPermissionsRequest where
    parseJSON =
      Core.withObject
        "TestIamPermissionsRequest"
        ( \o ->
            TestIamPermissionsRequest Core.<$> (o Core..:? "permissions")
        )
  
  instance Core.ToJSON TestIamPermissionsRequest where
    toJSON TestIamPermissionsRequest {..} =
      Core.object
        (Core.catMaybes [("permissions" Core..=) Core.<$> permissions])
  
  -- | Response message for @TestIamPermissions@ method.
  --
  -- /See:/ 'newTestIamPermissionsResponse' smart constructor.
  newtype TestIamPermissionsResponse = TestIamPermissionsResponse
    { -- | A subset of @TestPermissionsRequest.permissions@ that the caller is allowed.
      permissions :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TestIamPermissionsResponse' with the minimum fields required to make a request.
  newTestIamPermissionsResponse ::
    TestIamPermissionsResponse
  newTestIamPermissionsResponse =
    TestIamPermissionsResponse {permissions = Core.Nothing}
  
  instance Core.FromJSON TestIamPermissionsResponse where
    parseJSON =
      Core.withObject
        "TestIamPermissionsResponse"
        ( \o ->
            TestIamPermissionsResponse Core.<$> (o Core..:? "permissions")
        )
  
  instance Core.ToJSON TestIamPermissionsResponse where
    toJSON TestIamPermissionsResponse {..} =
      Core.object
        (Core.catMaybes [("permissions" Core..=) Core.<$> permissions])
  
  -- | @Type@ represents the type of data that is written to, read from, or stored in Bigtable. It is heavily based on the GoogleSQL standard to help maintain familiarity and consistency across products and features. For compatibility with Bigtable\'s existing untyped APIs, each @Type@ includes an @Encoding@ which describes how to convert to or from the underlying data. Each encoding can operate in one of two modes: - Sorted: In this mode, Bigtable guarantees that @Encode(X) \<= Encode(Y)@ if and only if @X \<= Y@. This is useful anywhere sort order is important, for example when encoding keys. - Distinct: In this mode, Bigtable guarantees that if @X != Y@ then @Encode(X) != Encode(Y)@. However, the converse is not guaranteed. For example, both \"{\'foo\': \'1\', \'bar\': \'2\'}\" and \"{\'bar\': \'2\', \'foo\': \'1\'}\" are valid encodings of the same JSON value. The API clearly documents which mode is used wherever an encoding can be configured. Each encoding also documents which values are supported in which
  -- modes. For example, when encoding INT64 as a numeric STRING, negative numbers cannot be encoded in sorted mode. This is because @INT64(1) > INT64(-1)@, but @STRING(\"-00001\") > STRING(\"00001\")@.
  --
  -- /See:/ 'newType' smart constructor.
  data Type = Type
    { -- | Aggregate
      aggregateType :: (Core.Maybe GoogleBigtableAdminV2TypeAggregate),
      -- | Array
      arrayType :: (Core.Maybe GoogleBigtableAdminV2TypeArray),
      -- | Bool
      boolType :: (Core.Maybe GoogleBigtableAdminV2TypeBool),
      -- | Bytes
      bytesType :: (Core.Maybe GoogleBigtableAdminV2TypeBytes),
      -- | Date
      dateType :: (Core.Maybe GoogleBigtableAdminV2TypeDate),
      -- | Float32
      float32Type :: (Core.Maybe GoogleBigtableAdminV2TypeFloat32),
      -- | Float64
      float64Type :: (Core.Maybe GoogleBigtableAdminV2TypeFloat64),
      -- | Int64
      int64Type :: (Core.Maybe GoogleBigtableAdminV2TypeInt64),
      -- | Map
      mapType :: (Core.Maybe GoogleBigtableAdminV2TypeMap),
      -- | String
      stringType :: (Core.Maybe GoogleBigtableAdminV2TypeString),
      -- | Struct
      structType :: (Core.Maybe GoogleBigtableAdminV2TypeStruct),
      -- | Timestamp
      timestampType :: (Core.Maybe GoogleBigtableAdminV2TypeTimestamp)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Type' with the minimum fields required to make a request.
  newType ::
    Type
  newType =
    Type
      { aggregateType = Core.Nothing,
        arrayType = Core.Nothing,
        boolType = Core.Nothing,
        bytesType = Core.Nothing,
        dateType = Core.Nothing,
        float32Type = Core.Nothing,
        float64Type = Core.Nothing,
        int64Type = Core.Nothing,
        mapType = Core.Nothing,
        stringType = Core.Nothing,
        structType = Core.Nothing,
        timestampType = Core.Nothing
      }
  
  instance Core.FromJSON Type where
    parseJSON =
      Core.withObject
        "Type"
        ( \o ->
            Type
              Core.<$> (o Core..:? "aggregateType")
              Core.<*> (o Core..:? "arrayType")
              Core.<*> (o Core..:? "boolType")
              Core.<*> (o Core..:? "bytesType")
              Core.<*> (o Core..:? "dateType")
              Core.<*> (o Core..:? "float32Type")
              Core.<*> (o Core..:? "float64Type")
              Core.<*> (o Core..:? "int64Type")
              Core.<*> (o Core..:? "mapType")
              Core.<*> (o Core..:? "stringType")
              Core.<*> (o Core..:? "structType")
              Core.<*> (o Core..:? "timestampType")
        )
  
  instance Core.ToJSON Type where
    toJSON Type {..} =
      Core.object
        ( Core.catMaybes
            [ ("aggregateType" Core..=) Core.<$> aggregateType,
              ("arrayType" Core..=) Core.<$> arrayType,
              ("boolType" Core..=) Core.<$> boolType,
              ("bytesType" Core..=) Core.<$> bytesType,
              ("dateType" Core..=) Core.<$> dateType,
              ("float32Type" Core..=) Core.<$> float32Type,
              ("float64Type" Core..=) Core.<$> float64Type,
              ("int64Type" Core..=) Core.<$> int64Type,
              ("mapType" Core..=) Core.<$> mapType,
              ("stringType" Core..=) Core.<$> stringType,
              ("structType" Core..=) Core.<$> structType,
              ("timestampType" Core..=) Core.<$> timestampType
            ]
        )
  
  -- | Metadata type for the operation returned by google.bigtable.admin.v2.BigtableTableAdmin.UndeleteTable.
  --
  -- /See:/ 'newUndeleteTableMetadata' smart constructor.
  data UndeleteTableMetadata = UndeleteTableMetadata
    { -- | If set, the time at which this operation finished or was cancelled.
      endTime :: (Core.Maybe Core.DateTime),
      -- | The name of the table being restored.
      name :: (Core.Maybe Core.Text),
      -- | The time at which this operation started.
      startTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UndeleteTableMetadata' with the minimum fields required to make a request.
  newUndeleteTableMetadata ::
    UndeleteTableMetadata
  newUndeleteTableMetadata =
    UndeleteTableMetadata
      { endTime = Core.Nothing,
        name = Core.Nothing,
        startTime = Core.Nothing
      }
  
  instance Core.FromJSON UndeleteTableMetadata where
    parseJSON =
      Core.withObject
        "UndeleteTableMetadata"
        ( \o ->
            UndeleteTableMetadata
              Core.<$> (o Core..:? "endTime")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "startTime")
        )
  
  instance Core.ToJSON UndeleteTableMetadata where
    toJSON UndeleteTableMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("endTime" Core..=) Core.<$> endTime,
              ("name" Core..=) Core.<$> name,
              ("startTime" Core..=) Core.<$> startTime
            ]
        )
  
  -- | Request message for google.bigtable.admin.v2.BigtableTableAdmin.UndeleteTable
  --
  -- /See:/ 'newUndeleteTableRequest' smart constructor.
  data UndeleteTableRequest = UndeleteTableRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UndeleteTableRequest' with the minimum fields required to make a request.
  newUndeleteTableRequest ::
    UndeleteTableRequest
  newUndeleteTableRequest = UndeleteTableRequest
  
  instance Core.FromJSON UndeleteTableRequest where
    parseJSON =
      Core.withObject
        "UndeleteTableRequest"
        (\o -> Core.pure UndeleteTableRequest)
  
  instance Core.ToJSON UndeleteTableRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | A GcRule which deletes cells matching any of the given rules.
  --
  -- /See:/ 'newUnion' smart constructor.
  newtype Union = Union
    { -- | Delete cells which would be deleted by any element of @rules@.
      rules :: (Core.Maybe [GcRule])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Union' with the minimum fields required to make a request.
  newUnion ::
    Union
  newUnion = Union {rules = Core.Nothing}
  
  instance Core.FromJSON Union where
    parseJSON =
      Core.withObject
        "Union"
        (\o -> Union Core.<$> (o Core..:? "rules"))
  
  instance Core.ToJSON Union where
    toJSON Union {..} =
      Core.object (Core.catMaybes [("rules" Core..=) Core.<$> rules])
  
  -- | The metadata for the Operation returned by UpdateAppProfile.
  --
  -- /See:/ 'newUpdateAppProfileMetadata' smart constructor.
  data UpdateAppProfileMetadata = UpdateAppProfileMetadata
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UpdateAppProfileMetadata' with the minimum fields required to make a request.
  newUpdateAppProfileMetadata ::
    UpdateAppProfileMetadata
  newUpdateAppProfileMetadata = UpdateAppProfileMetadata
  
  instance Core.FromJSON UpdateAppProfileMetadata where
    parseJSON =
      Core.withObject
        "UpdateAppProfileMetadata"
        (\o -> Core.pure UpdateAppProfileMetadata)
  
  instance Core.ToJSON UpdateAppProfileMetadata where
    toJSON = Core.const Core.emptyObject
  
  -- | Metadata for the google.longrunning.Operation returned by UpdateAuthorizedView.
  --
  -- /See:/ 'newUpdateAuthorizedViewMetadata' smart constructor.
  data UpdateAuthorizedViewMetadata = UpdateAuthorizedViewMetadata
    { -- | The time at which the operation failed or was completed successfully.
      finishTime :: (Core.Maybe Core.DateTime),
      -- | The request that prompted the initiation of this UpdateAuthorizedView operation.
      originalRequest :: (Core.Maybe UpdateAuthorizedViewRequest),
      -- | The time at which the original request was received.
      requestTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UpdateAuthorizedViewMetadata' with the minimum fields required to make a request.
  newUpdateAuthorizedViewMetadata ::
    UpdateAuthorizedViewMetadata
  newUpdateAuthorizedViewMetadata =
    UpdateAuthorizedViewMetadata
      { finishTime = Core.Nothing,
        originalRequest = Core.Nothing,
        requestTime = Core.Nothing
      }
  
  instance Core.FromJSON UpdateAuthorizedViewMetadata where
    parseJSON =
      Core.withObject
        "UpdateAuthorizedViewMetadata"
        ( \o ->
            UpdateAuthorizedViewMetadata
              Core.<$> (o Core..:? "finishTime")
              Core.<*> (o Core..:? "originalRequest")
              Core.<*> (o Core..:? "requestTime")
        )
  
  instance Core.ToJSON UpdateAuthorizedViewMetadata where
    toJSON UpdateAuthorizedViewMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("finishTime" Core..=) Core.<$> finishTime,
              ("originalRequest" Core..=) Core.<$> originalRequest,
              ("requestTime" Core..=) Core.<$> requestTime
            ]
        )
  
  -- | The request for UpdateAuthorizedView.
  --
  -- /See:/ 'newUpdateAuthorizedViewRequest' smart constructor.
  data UpdateAuthorizedViewRequest = UpdateAuthorizedViewRequest
    { -- | Required. The AuthorizedView to update. The @name@ in @authorized_view@ is used to identify the AuthorizedView. AuthorizedView name must in this format: @projects\/{project}\/instances\/{instance}\/tables\/{table}\/authorizedViews\/{authorized_view}@.
      authorizedView :: (Core.Maybe AuthorizedView),
      -- | Optional. If true, ignore the safety checks when updating the AuthorizedView.
      ignoreWarnings :: (Core.Maybe Core.Bool),
      -- | Optional. The list of fields to update. A mask specifying which fields in the AuthorizedView resource should be updated. This mask is relative to the AuthorizedView resource, not to the request message. A field will be overwritten if it is in the mask. If empty, all fields set in the request will be overwritten. A special value @*@ means to overwrite all fields (including fields not set in the request).
      updateMask :: (Core.Maybe Core.FieldMask)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UpdateAuthorizedViewRequest' with the minimum fields required to make a request.
  newUpdateAuthorizedViewRequest ::
    UpdateAuthorizedViewRequest
  newUpdateAuthorizedViewRequest =
    UpdateAuthorizedViewRequest
      { authorizedView = Core.Nothing,
        ignoreWarnings = Core.Nothing,
        updateMask = Core.Nothing
      }
  
  instance Core.FromJSON UpdateAuthorizedViewRequest where
    parseJSON =
      Core.withObject
        "UpdateAuthorizedViewRequest"
        ( \o ->
            UpdateAuthorizedViewRequest
              Core.<$> (o Core..:? "authorizedView")
              Core.<*> (o Core..:? "ignoreWarnings")
              Core.<*> (o Core..:? "updateMask")
        )
  
  instance Core.ToJSON UpdateAuthorizedViewRequest where
    toJSON UpdateAuthorizedViewRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("authorizedView" Core..=) Core.<$> authorizedView,
              ("ignoreWarnings" Core..=) Core.<$> ignoreWarnings,
              ("updateMask" Core..=) Core.<$> updateMask
            ]
        )
  
  -- | The metadata for the Operation returned by UpdateCluster.
  --
  -- /See:/ 'newUpdateClusterMetadata' smart constructor.
  data UpdateClusterMetadata = UpdateClusterMetadata
    { -- | The time at which the operation failed or was completed successfully.
      finishTime :: (Core.Maybe Core.DateTime),
      -- | The request that prompted the initiation of this UpdateCluster operation.
      originalRequest :: (Core.Maybe Cluster),
      -- | The time at which the original request was received.
      requestTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UpdateClusterMetadata' with the minimum fields required to make a request.
  newUpdateClusterMetadata ::
    UpdateClusterMetadata
  newUpdateClusterMetadata =
    UpdateClusterMetadata
      { finishTime = Core.Nothing,
        originalRequest = Core.Nothing,
        requestTime = Core.Nothing
      }
  
  instance Core.FromJSON UpdateClusterMetadata where
    parseJSON =
      Core.withObject
        "UpdateClusterMetadata"
        ( \o ->
            UpdateClusterMetadata
              Core.<$> (o Core..:? "finishTime")
              Core.<*> (o Core..:? "originalRequest")
              Core.<*> (o Core..:? "requestTime")
        )
  
  instance Core.ToJSON UpdateClusterMetadata where
    toJSON UpdateClusterMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("finishTime" Core..=) Core.<$> finishTime,
              ("originalRequest" Core..=) Core.<$> originalRequest,
              ("requestTime" Core..=) Core.<$> requestTime
            ]
        )
  
  -- | The metadata for the Operation returned by UpdateInstance.
  --
  -- /See:/ 'newUpdateInstanceMetadata' smart constructor.
  data UpdateInstanceMetadata = UpdateInstanceMetadata
    { -- | The time at which the operation failed or was completed successfully.
      finishTime :: (Core.Maybe Core.DateTime),
      -- | The request that prompted the initiation of this UpdateInstance operation.
      originalRequest :: (Core.Maybe PartialUpdateInstanceRequest),
      -- | The time at which the original request was received.
      requestTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UpdateInstanceMetadata' with the minimum fields required to make a request.
  newUpdateInstanceMetadata ::
    UpdateInstanceMetadata
  newUpdateInstanceMetadata =
    UpdateInstanceMetadata
      { finishTime = Core.Nothing,
        originalRequest = Core.Nothing,
        requestTime = Core.Nothing
      }
  
  instance Core.FromJSON UpdateInstanceMetadata where
    parseJSON =
      Core.withObject
        "UpdateInstanceMetadata"
        ( \o ->
            UpdateInstanceMetadata
              Core.<$> (o Core..:? "finishTime")
              Core.<*> (o Core..:? "originalRequest")
              Core.<*> (o Core..:? "requestTime")
        )
  
  instance Core.ToJSON UpdateInstanceMetadata where
    toJSON UpdateInstanceMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("finishTime" Core..=) Core.<$> finishTime,
              ("originalRequest" Core..=) Core.<$> originalRequest,
              ("requestTime" Core..=) Core.<$> requestTime
            ]
        )
  
  -- | Metadata type for the operation returned by UpdateTable.
  --
  -- /See:/ 'newUpdateTableMetadata' smart constructor.
  data UpdateTableMetadata = UpdateTableMetadata
    { -- | If set, the time at which this operation finished or was canceled.
      endTime :: (Core.Maybe Core.DateTime),
      -- | The name of the table being updated.
      name :: (Core.Maybe Core.Text),
      -- | The time at which this operation started.
      startTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UpdateTableMetadata' with the minimum fields required to make a request.
  newUpdateTableMetadata ::
    UpdateTableMetadata
  newUpdateTableMetadata =
    UpdateTableMetadata
      { endTime = Core.Nothing,
        name = Core.Nothing,
        startTime = Core.Nothing
      }
  
  instance Core.FromJSON UpdateTableMetadata where
    parseJSON =
      Core.withObject
        "UpdateTableMetadata"
        ( \o ->
            UpdateTableMetadata
              Core.<$> (o Core..:? "endTime")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "startTime")
        )
  
  instance Core.ToJSON UpdateTableMetadata where
    toJSON UpdateTableMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("endTime" Core..=) Core.<$> endTime,
              ("name" Core..=) Core.<$> name,
              ("startTime" Core..=) Core.<$> startTime
            ]
        )
  