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.Healthcare.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.Healthcare.Internal.Product
    ( -- * AccessDeterminationLogConfig
      AccessDeterminationLogConfig (..),
      newAccessDeterminationLogConfig,
  
      -- * ActivateConsentRequest
      ActivateConsentRequest (..),
      newActivateConsentRequest,
  
      -- * AdminConsents
      AdminConsents (..),
      newAdminConsents,
  
      -- * AnalyzeEntitiesRequest
      AnalyzeEntitiesRequest (..),
      newAnalyzeEntitiesRequest,
  
      -- * AnalyzeEntitiesResponse
      AnalyzeEntitiesResponse (..),
      newAnalyzeEntitiesResponse,
  
      -- * ApplyAdminConsentsErrorDetail
      ApplyAdminConsentsErrorDetail (..),
      newApplyAdminConsentsErrorDetail,
  
      -- * ApplyAdminConsentsRequest
      ApplyAdminConsentsRequest (..),
      newApplyAdminConsentsRequest,
  
      -- * ApplyAdminConsentsResponse
      ApplyAdminConsentsResponse (..),
      newApplyAdminConsentsResponse,
  
      -- * ApplyConsentsRequest
      ApplyConsentsRequest (..),
      newApplyConsentsRequest,
  
      -- * ApplyConsentsResponse
      ApplyConsentsResponse (..),
      newApplyConsentsResponse,
  
      -- * ArchiveUserDataMappingRequest
      ArchiveUserDataMappingRequest (..),
      newArchiveUserDataMappingRequest,
  
      -- * ArchiveUserDataMappingResponse
      ArchiveUserDataMappingResponse (..),
      newArchiveUserDataMappingResponse,
  
      -- * Attribute
      Attribute (..),
      newAttribute,
  
      -- * AttributeDefinition
      AttributeDefinition (..),
      newAttributeDefinition,
  
      -- * AuditConfig
      AuditConfig (..),
      newAuditConfig,
  
      -- * AuditLogConfig
      AuditLogConfig (..),
      newAuditLogConfig,
  
      -- * Binding
      Binding (..),
      newBinding,
  
      -- * BlobStorageInfo
      BlobStorageInfo (..),
      newBlobStorageInfo,
  
      -- * BlobStorageSettings
      BlobStorageSettings (..),
      newBlobStorageSettings,
  
      -- * BulkExportGcsDestination
      BulkExportGcsDestination (..),
      newBulkExportGcsDestination,
  
      -- * CancelOperationRequest
      CancelOperationRequest (..),
      newCancelOperationRequest,
  
      -- * CharacterMaskConfig
      CharacterMaskConfig (..),
      newCharacterMaskConfig,
  
      -- * CheckDataAccessRequest
      CheckDataAccessRequest (..),
      newCheckDataAccessRequest,
  
      -- * CheckDataAccessRequest_RequestAttributes
      CheckDataAccessRequest_RequestAttributes (..),
      newCheckDataAccessRequest_RequestAttributes,
  
      -- * CheckDataAccessResponse
      CheckDataAccessResponse (..),
      newCheckDataAccessResponse,
  
      -- * CheckDataAccessResponse_ConsentDetails
      CheckDataAccessResponse_ConsentDetails (..),
      newCheckDataAccessResponse_ConsentDetails,
  
      -- * Consent
      Consent (..),
      newConsent,
  
      -- * Consent_Metadata
      Consent_Metadata (..),
      newConsent_Metadata,
  
      -- * ConsentAccessorScope
      ConsentAccessorScope (..),
      newConsentAccessorScope,
  
      -- * ConsentArtifact
      ConsentArtifact (..),
      newConsentArtifact,
  
      -- * ConsentArtifact_Metadata
      ConsentArtifact_Metadata (..),
      newConsentArtifact_Metadata,
  
      -- * ConsentConfig
      ConsentConfig (..),
      newConsentConfig,
  
      -- * ConsentErrors
      ConsentErrors (..),
      newConsentErrors,
  
      -- * ConsentEvaluation
      ConsentEvaluation (..),
      newConsentEvaluation,
  
      -- * ConsentHeaderHandling
      ConsentHeaderHandling (..),
      newConsentHeaderHandling,
  
      -- * ConsentList
      ConsentList (..),
      newConsentList,
  
      -- * ConsentStore
      ConsentStore (..),
      newConsentStore,
  
      -- * ConsentStore_Labels
      ConsentStore_Labels (..),
      newConsentStore_Labels,
  
      -- * CreateMessageRequest
      CreateMessageRequest (..),
      newCreateMessageRequest,
  
      -- * CryptoHashConfig
      CryptoHashConfig (..),
      newCryptoHashConfig,
  
      -- * Dataset
      Dataset (..),
      newDataset,
  
      -- * DateShiftConfig
      DateShiftConfig (..),
      newDateShiftConfig,
  
      -- * DeidentifiedStoreDestination
      DeidentifiedStoreDestination (..),
      newDeidentifiedStoreDestination,
  
      -- * DeidentifyConfig
      DeidentifyConfig (..),
      newDeidentifyConfig,
  
      -- * DeidentifyDatasetRequest
      DeidentifyDatasetRequest (..),
      newDeidentifyDatasetRequest,
  
      -- * DeidentifyDicomStoreRequest
      DeidentifyDicomStoreRequest (..),
      newDeidentifyDicomStoreRequest,
  
      -- * DeidentifyFhirStoreRequest
      DeidentifyFhirStoreRequest (..),
      newDeidentifyFhirStoreRequest,
  
      -- * DeidentifySummary
      DeidentifySummary (..),
      newDeidentifySummary,
  
      -- * DicomConfig
      DicomConfig (..),
      newDicomConfig,
  
      -- * DicomFilterConfig
      DicomFilterConfig (..),
      newDicomFilterConfig,
  
      -- * DicomStore
      DicomStore (..),
      newDicomStore,
  
      -- * DicomStore_Labels
      DicomStore_Labels (..),
      newDicomStore_Labels,
  
      -- * DicomStoreMetrics
      DicomStoreMetrics (..),
      newDicomStoreMetrics,
  
      -- * Empty
      Empty (..),
      newEmpty,
  
      -- * EncryptionSpec
      EncryptionSpec (..),
      newEncryptionSpec,
  
      -- * Entity
      Entity (..),
      newEntity,
  
      -- * EntityMention
      EntityMention (..),
      newEntityMention,
  
      -- * EntityMentionRelationship
      EntityMentionRelationship (..),
      newEntityMentionRelationship,
  
      -- * EvaluateUserConsentsRequest
      EvaluateUserConsentsRequest (..),
      newEvaluateUserConsentsRequest,
  
      -- * EvaluateUserConsentsRequest_RequestAttributes
      EvaluateUserConsentsRequest_RequestAttributes (..),
      newEvaluateUserConsentsRequest_RequestAttributes,
  
      -- * EvaluateUserConsentsRequest_ResourceAttributes
      EvaluateUserConsentsRequest_ResourceAttributes (..),
      newEvaluateUserConsentsRequest_ResourceAttributes,
  
      -- * EvaluateUserConsentsResponse
      EvaluateUserConsentsResponse (..),
      newEvaluateUserConsentsResponse,
  
      -- * ExplainDataAccessConsentInfo
      ExplainDataAccessConsentInfo (..),
      newExplainDataAccessConsentInfo,
  
      -- * ExplainDataAccessConsentScope
      ExplainDataAccessConsentScope (..),
      newExplainDataAccessConsentScope,
  
      -- * ExplainDataAccessResponse
      ExplainDataAccessResponse (..),
      newExplainDataAccessResponse,
  
      -- * ExportDicomDataRequest
      ExportDicomDataRequest (..),
      newExportDicomDataRequest,
  
      -- * ExportDicomDataResponse
      ExportDicomDataResponse (..),
      newExportDicomDataResponse,
  
      -- * ExportMessagesRequest
      ExportMessagesRequest (..),
      newExportMessagesRequest,
  
      -- * ExportMessagesResponse
      ExportMessagesResponse (..),
      newExportMessagesResponse,
  
      -- * ExportResourcesRequest
      ExportResourcesRequest (..),
      newExportResourcesRequest,
  
      -- * ExportResourcesResponse
      ExportResourcesResponse (..),
      newExportResourcesResponse,
  
      -- * Expr
      Expr (..),
      newExpr,
  
      -- * Feature
      Feature (..),
      newFeature,
  
      -- * FhirConfig
      FhirConfig (..),
      newFhirConfig,
  
      -- * FhirFilter
      FhirFilter (..),
      newFhirFilter,
  
      -- * FhirNotificationConfig
      FhirNotificationConfig (..),
      newFhirNotificationConfig,
  
      -- * FhirStore
      FhirStore (..),
      newFhirStore,
  
      -- * FhirStore_Labels
      FhirStore_Labels (..),
      newFhirStore_Labels,
  
      -- * FhirStoreMetric
      FhirStoreMetric (..),
      newFhirStoreMetric,
  
      -- * FhirStoreMetrics
      FhirStoreMetrics (..),
      newFhirStoreMetrics,
  
      -- * Field
      Field (..),
      newField,
  
      -- * FieldMetadata
      FieldMetadata (..),
      newFieldMetadata,
  
      -- * GcsDestination
      GcsDestination (..),
      newGcsDestination,
  
      -- * GcsSource
      GcsSource (..),
      newGcsSource,
  
      -- * GoogleCloudHealthcareV1ConsentGcsDestination
      GoogleCloudHealthcareV1ConsentGcsDestination (..),
      newGoogleCloudHealthcareV1ConsentGcsDestination,
  
      -- * GoogleCloudHealthcareV1ConsentPolicy
      GoogleCloudHealthcareV1ConsentPolicy (..),
      newGoogleCloudHealthcareV1ConsentPolicy,
  
      -- * GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary
      GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary (..),
      newGoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary,
  
      -- * GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary
      GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary (..),
      newGoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary,
  
      -- * GoogleCloudHealthcareV1DicomBigQueryDestination
      GoogleCloudHealthcareV1DicomBigQueryDestination (..),
      newGoogleCloudHealthcareV1DicomBigQueryDestination,
  
      -- * GoogleCloudHealthcareV1DicomGcsDestination
      GoogleCloudHealthcareV1DicomGcsDestination (..),
      newGoogleCloudHealthcareV1DicomGcsDestination,
  
      -- * GoogleCloudHealthcareV1DicomGcsSource
      GoogleCloudHealthcareV1DicomGcsSource (..),
      newGoogleCloudHealthcareV1DicomGcsSource,
  
      -- * GoogleCloudHealthcareV1DicomStreamConfig
      GoogleCloudHealthcareV1DicomStreamConfig (..),
      newGoogleCloudHealthcareV1DicomStreamConfig,
  
      -- * GoogleCloudHealthcareV1FhirBigQueryDestination
      GoogleCloudHealthcareV1FhirBigQueryDestination (..),
      newGoogleCloudHealthcareV1FhirBigQueryDestination,
  
      -- * GoogleCloudHealthcareV1FhirGcsDestination
      GoogleCloudHealthcareV1FhirGcsDestination (..),
      newGoogleCloudHealthcareV1FhirGcsDestination,
  
      -- * GoogleCloudHealthcareV1FhirGcsSource
      GoogleCloudHealthcareV1FhirGcsSource (..),
      newGoogleCloudHealthcareV1FhirGcsSource,
  
      -- * GroupOrSegment
      GroupOrSegment (..),
      newGroupOrSegment,
  
      -- * Hl7SchemaConfig
      Hl7SchemaConfig (..),
      newHl7SchemaConfig,
  
      -- * Hl7SchemaConfig_MessageSchemaConfigs
      Hl7SchemaConfig_MessageSchemaConfigs (..),
      newHl7SchemaConfig_MessageSchemaConfigs,
  
      -- * Hl7TypesConfig
      Hl7TypesConfig (..),
      newHl7TypesConfig,
  
      -- * Hl7V2NotificationConfig
      Hl7V2NotificationConfig (..),
      newHl7V2NotificationConfig,
  
      -- * Hl7V2Store
      Hl7V2Store (..),
      newHl7V2Store,
  
      -- * Hl7V2Store_Labels
      Hl7V2Store_Labels (..),
      newHl7V2Store_Labels,
  
      -- * Hl7V2StoreMetric
      Hl7V2StoreMetric (..),
      newHl7V2StoreMetric,
  
      -- * Hl7V2StoreMetrics
      Hl7V2StoreMetrics (..),
      newHl7V2StoreMetrics,
  
      -- * HttpBody
      HttpBody (..),
      newHttpBody,
  
      -- * HttpBody_ExtensionsItem
      HttpBody_ExtensionsItem (..),
      newHttpBody_ExtensionsItem,
  
      -- * Image
      Image (..),
      newImage,
  
      -- * ImageConfig
      ImageConfig (..),
      newImageConfig,
  
      -- * ImportDicomDataRequest
      ImportDicomDataRequest (..),
      newImportDicomDataRequest,
  
      -- * ImportDicomDataResponse
      ImportDicomDataResponse (..),
      newImportDicomDataResponse,
  
      -- * ImportMessagesRequest
      ImportMessagesRequest (..),
      newImportMessagesRequest,
  
      -- * ImportMessagesResponse
      ImportMessagesResponse (..),
      newImportMessagesResponse,
  
      -- * ImportResourcesRequest
      ImportResourcesRequest (..),
      newImportResourcesRequest,
  
      -- * ImportResourcesResponse
      ImportResourcesResponse (..),
      newImportResourcesResponse,
  
      -- * InfoTypeTransformation
      InfoTypeTransformation (..),
      newInfoTypeTransformation,
  
      -- * IngestMessageRequest
      IngestMessageRequest (..),
      newIngestMessageRequest,
  
      -- * IngestMessageResponse
      IngestMessageResponse (..),
      newIngestMessageResponse,
  
      -- * KmsWrappedCryptoKey
      KmsWrappedCryptoKey (..),
      newKmsWrappedCryptoKey,
  
      -- * LinkedEntity
      LinkedEntity (..),
      newLinkedEntity,
  
      -- * ListAttributeDefinitionsResponse
      ListAttributeDefinitionsResponse (..),
      newListAttributeDefinitionsResponse,
  
      -- * ListConsentArtifactsResponse
      ListConsentArtifactsResponse (..),
      newListConsentArtifactsResponse,
  
      -- * ListConsentRevisionsResponse
      ListConsentRevisionsResponse (..),
      newListConsentRevisionsResponse,
  
      -- * ListConsentStoresResponse
      ListConsentStoresResponse (..),
      newListConsentStoresResponse,
  
      -- * ListConsentsResponse
      ListConsentsResponse (..),
      newListConsentsResponse,
  
      -- * ListDatasetsResponse
      ListDatasetsResponse (..),
      newListDatasetsResponse,
  
      -- * ListDicomStoresResponse
      ListDicomStoresResponse (..),
      newListDicomStoresResponse,
  
      -- * ListFhirStoresResponse
      ListFhirStoresResponse (..),
      newListFhirStoresResponse,
  
      -- * ListHl7V2StoresResponse
      ListHl7V2StoresResponse (..),
      newListHl7V2StoresResponse,
  
      -- * ListLocationsResponse
      ListLocationsResponse (..),
      newListLocationsResponse,
  
      -- * ListMessagesResponse
      ListMessagesResponse (..),
      newListMessagesResponse,
  
      -- * ListOperationsResponse
      ListOperationsResponse (..),
      newListOperationsResponse,
  
      -- * ListUserDataMappingsResponse
      ListUserDataMappingsResponse (..),
      newListUserDataMappingsResponse,
  
      -- * Location
      Location (..),
      newLocation,
  
      -- * Location_Labels
      Location_Labels (..),
      newLocation_Labels,
  
      -- * Location_Metadata
      Location_Metadata (..),
      newLocation_Metadata,
  
      -- * Message
      Message (..),
      newMessage,
  
      -- * Message_Labels
      Message_Labels (..),
      newMessage_Labels,
  
      -- * NotificationConfig
      NotificationConfig (..),
      newNotificationConfig,
  
      -- * Operation
      Operation (..),
      newOperation,
  
      -- * Operation_Metadata
      Operation_Metadata (..),
      newOperation_Metadata,
  
      -- * Operation_Response
      Operation_Response (..),
      newOperation_Response,
  
      -- * OperationMetadata
      OperationMetadata (..),
      newOperationMetadata,
  
      -- * ParsedData
      ParsedData (..),
      newParsedData,
  
      -- * ParserConfig
      ParserConfig (..),
      newParserConfig,
  
      -- * PatientId
      PatientId (..),
      newPatientId,
  
      -- * PatientScope
      PatientScope (..),
      newPatientScope,
  
      -- * Policy
      Policy (..),
      newPolicy,
  
      -- * ProgressCounter
      ProgressCounter (..),
      newProgressCounter,
  
      -- * PubsubDestination
      PubsubDestination (..),
      newPubsubDestination,
  
      -- * QueryAccessibleDataRequest
      QueryAccessibleDataRequest (..),
      newQueryAccessibleDataRequest,
  
      -- * QueryAccessibleDataRequest_RequestAttributes
      QueryAccessibleDataRequest_RequestAttributes (..),
      newQueryAccessibleDataRequest_RequestAttributes,
  
      -- * QueryAccessibleDataRequest_ResourceAttributes
      QueryAccessibleDataRequest_ResourceAttributes (..),
      newQueryAccessibleDataRequest_ResourceAttributes,
  
      -- * QueryAccessibleDataResponse
      QueryAccessibleDataResponse (..),
      newQueryAccessibleDataResponse,
  
      -- * RedactConfig
      RedactConfig (..),
      newRedactConfig,
  
      -- * RejectConsentRequest
      RejectConsentRequest (..),
      newRejectConsentRequest,
  
      -- * ReplaceWithInfoTypeConfig
      ReplaceWithInfoTypeConfig (..),
      newReplaceWithInfoTypeConfig,
  
      -- * Resources
      Resources (..),
      newResources,
  
      -- * Result
      Result (..),
      newResult,
  
      -- * Result_ConsentDetails
      Result_ConsentDetails (..),
      newResult_ConsentDetails,
  
      -- * RevokeConsentRequest
      RevokeConsentRequest (..),
      newRevokeConsentRequest,
  
      -- * RollbackFhirResourceFilteringFields
      RollbackFhirResourceFilteringFields (..),
      newRollbackFhirResourceFilteringFields,
  
      -- * RollbackFhirResourcesRequest
      RollbackFhirResourcesRequest (..),
      newRollbackFhirResourcesRequest,
  
      -- * RollbackFhirResourcesResponse
      RollbackFhirResourcesResponse (..),
      newRollbackFhirResourcesResponse,
  
      -- * RollbackHL7MessagesFilteringFields
      RollbackHL7MessagesFilteringFields (..),
      newRollbackHL7MessagesFilteringFields,
  
      -- * RollbackHl7V2MessagesRequest
      RollbackHl7V2MessagesRequest (..),
      newRollbackHl7V2MessagesRequest,
  
      -- * RollbackHl7V2MessagesResponse
      RollbackHl7V2MessagesResponse (..),
      newRollbackHl7V2MessagesResponse,
  
      -- * SchemaConfig
      SchemaConfig (..),
      newSchemaConfig,
  
      -- * SchemaGroup
      SchemaGroup (..),
      newSchemaGroup,
  
      -- * SchemaPackage
      SchemaPackage (..),
      newSchemaPackage,
  
      -- * SchemaSegment
      SchemaSegment (..),
      newSchemaSegment,
  
      -- * SchematizedData
      SchematizedData (..),
      newSchematizedData,
  
      -- * SearchResourcesRequest
      SearchResourcesRequest (..),
      newSearchResourcesRequest,
  
      -- * Segment
      Segment (..),
      newSegment,
  
      -- * Segment_Fields
      Segment_Fields (..),
      newSegment_Fields,
  
      -- * SeriesMetrics
      SeriesMetrics (..),
      newSeriesMetrics,
  
      -- * SetBlobStorageSettingsRequest
      SetBlobStorageSettingsRequest (..),
      newSetBlobStorageSettingsRequest,
  
      -- * SetBlobStorageSettingsResponse
      SetBlobStorageSettingsResponse (..),
      newSetBlobStorageSettingsResponse,
  
      -- * SetIamPolicyRequest
      SetIamPolicyRequest (..),
      newSetIamPolicyRequest,
  
      -- * Signature
      Signature (..),
      newSignature,
  
      -- * Signature_Metadata
      Signature_Metadata (..),
      newSignature_Metadata,
  
      -- * Status
      Status (..),
      newStatus,
  
      -- * Status_DetailsItem
      Status_DetailsItem (..),
      newStatus_DetailsItem,
  
      -- * StorageInfo
      StorageInfo (..),
      newStorageInfo,
  
      -- * StreamConfig
      StreamConfig (..),
      newStreamConfig,
  
      -- * StructuredStorageInfo
      StructuredStorageInfo (..),
      newStructuredStorageInfo,
  
      -- * StudyMetrics
      StudyMetrics (..),
      newStudyMetrics,
  
      -- * TagFilterList
      TagFilterList (..),
      newTagFilterList,
  
      -- * TestIamPermissionsRequest
      TestIamPermissionsRequest (..),
      newTestIamPermissionsRequest,
  
      -- * TestIamPermissionsResponse
      TestIamPermissionsResponse (..),
      newTestIamPermissionsResponse,
  
      -- * TextConfig
      TextConfig (..),
      newTextConfig,
  
      -- * TextSpan
      TextSpan (..),
      newTextSpan,
  
      -- * TimePartitioning
      TimePartitioning (..),
      newTimePartitioning,
  
      -- * TimeRange
      TimeRange (..),
      newTimeRange,
  
      -- * Type
      Type (..),
      newType,
  
      -- * UserDataMapping
      UserDataMapping (..),
      newUserDataMapping,
  
      -- * ValidationConfig
      ValidationConfig (..),
      newValidationConfig,
  
      -- * VersionSource
      VersionSource (..),
      newVersionSource,
    )
  where
  
  import Gogol.Healthcare.Internal.Sum
  import Gogol.Prelude qualified as Core
  
  -- | Configures consent audit log config for FHIR create, read, update, and delete (CRUD) operations. Cloud audit log for healthcare API must be <https://cloud.google.com/logging/docs/audit/configure-data-access#config-console-enable enabled>. The consent-related logs are included as part of @protoPayload.metadata@.
  --
  -- /See:/ 'newAccessDeterminationLogConfig' smart constructor.
  newtype AccessDeterminationLogConfig = AccessDeterminationLogConfig
    { -- | Optional. Controls the amount of detail to include as part of the audit logs.
      logLevel :: (Core.Maybe AccessDeterminationLogConfig_LogLevel)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AccessDeterminationLogConfig' with the minimum fields required to make a request.
  newAccessDeterminationLogConfig ::
    AccessDeterminationLogConfig
  newAccessDeterminationLogConfig =
    AccessDeterminationLogConfig {logLevel = Core.Nothing}
  
  instance Core.FromJSON AccessDeterminationLogConfig where
    parseJSON =
      Core.withObject
        "AccessDeterminationLogConfig"
        ( \o ->
            AccessDeterminationLogConfig Core.<$> (o Core..:? "logLevel")
        )
  
  instance Core.ToJSON AccessDeterminationLogConfig where
    toJSON AccessDeterminationLogConfig {..} =
      Core.object
        (Core.catMaybes [("logLevel" Core..=) Core.<$> logLevel])
  
  -- | Activates the latest revision of the specified Consent by committing a new revision with @state@ updated to @ACTIVE@. If the latest revision of the given Consent is in the @ACTIVE@ state, no new revision is committed. A FAILED_PRECONDITION error occurs if the latest revision of the given consent is in the @REJECTED@ or @REVOKED@ state.
  --
  -- /See:/ 'newActivateConsentRequest' smart constructor.
  data ActivateConsentRequest = ActivateConsentRequest
    { -- | Required. The resource name of the Consent artifact that contains documentation of the user\'s consent, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/consentArtifacts\/{consent_artifact_id}@. If the draft Consent had a Consent artifact, this Consent artifact overwrites it.
      consentArtifact :: (Core.Maybe Core.Text),
      -- | Timestamp in UTC of when this Consent is considered expired.
      expireTime :: (Core.Maybe Core.DateTime),
      -- | The time to live for this Consent from when it is marked as active.
      ttl :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ActivateConsentRequest' with the minimum fields required to make a request.
  newActivateConsentRequest ::
    ActivateConsentRequest
  newActivateConsentRequest =
    ActivateConsentRequest
      { consentArtifact = Core.Nothing,
        expireTime = Core.Nothing,
        ttl = Core.Nothing
      }
  
  instance Core.FromJSON ActivateConsentRequest where
    parseJSON =
      Core.withObject
        "ActivateConsentRequest"
        ( \o ->
            ActivateConsentRequest
              Core.<$> (o Core..:? "consentArtifact")
              Core.<*> (o Core..:? "expireTime")
              Core.<*> (o Core..:? "ttl")
        )
  
  instance Core.ToJSON ActivateConsentRequest where
    toJSON ActivateConsentRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentArtifact" Core..=) Core.<$> consentArtifact,
              ("expireTime" Core..=) Core.<$> expireTime,
              ("ttl" Core..=) Core.<$> ttl
            ]
        )
  
  -- | List of admin Consent resources to be applied.
  --
  -- /See:/ 'newAdminConsents' smart constructor.
  newtype AdminConsents = AdminConsents
    { -- | Optional. The versioned names of the admin Consent resource(s), in the format @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Consent\/{resource_id}\/_history\/{version_id}@. For FHIR stores with @disable_resource_versioning=true@, the format is @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Consent\/{resource_id}@.
      names :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AdminConsents' with the minimum fields required to make a request.
  newAdminConsents ::
    AdminConsents
  newAdminConsents = AdminConsents {names = Core.Nothing}
  
  instance Core.FromJSON AdminConsents where
    parseJSON =
      Core.withObject
        "AdminConsents"
        (\o -> AdminConsents Core.<$> (o Core..:? "names"))
  
  instance Core.ToJSON AdminConsents where
    toJSON AdminConsents {..} =
      Core.object (Core.catMaybes [("names" Core..=) Core.<$> names])
  
  -- | The request to analyze healthcare entities in a document.
  --
  -- /See:/ 'newAnalyzeEntitiesRequest' smart constructor.
  data AnalyzeEntitiesRequest = AnalyzeEntitiesRequest
    { -- | Optional. Alternative output format to be generated based on the results of analysis.
      alternativeOutputFormat :: (Core.Maybe AnalyzeEntitiesRequest_AlternativeOutputFormat),
      -- | document_content is a document to be annotated.
      documentContent :: (Core.Maybe Core.Text),
      -- | A list of licensed vocabularies to use in the request, in addition to the default unlicensed vocabularies.
      licensedVocabularies :: (Core.Maybe [AnalyzeEntitiesRequest_LicensedVocabulariesItem])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AnalyzeEntitiesRequest' with the minimum fields required to make a request.
  newAnalyzeEntitiesRequest ::
    AnalyzeEntitiesRequest
  newAnalyzeEntitiesRequest =
    AnalyzeEntitiesRequest
      { alternativeOutputFormat = Core.Nothing,
        documentContent = Core.Nothing,
        licensedVocabularies = Core.Nothing
      }
  
  instance Core.FromJSON AnalyzeEntitiesRequest where
    parseJSON =
      Core.withObject
        "AnalyzeEntitiesRequest"
        ( \o ->
            AnalyzeEntitiesRequest
              Core.<$> (o Core..:? "alternativeOutputFormat")
              Core.<*> (o Core..:? "documentContent")
              Core.<*> (o Core..:? "licensedVocabularies")
        )
  
  instance Core.ToJSON AnalyzeEntitiesRequest where
    toJSON AnalyzeEntitiesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("alternativeOutputFormat" Core..=)
                Core.<$> alternativeOutputFormat,
              ("documentContent" Core..=) Core.<$> documentContent,
              ("licensedVocabularies" Core..=) Core.<$> licensedVocabularies
            ]
        )
  
  -- | Includes recognized entity mentions and relationships between them.
  --
  -- /See:/ 'newAnalyzeEntitiesResponse' smart constructor.
  data AnalyzeEntitiesResponse = AnalyzeEntitiesResponse
    { -- | The union of all the candidate entities that the entity_mentions in this response could link to. These are UMLS concepts or normalized mention content.
      entities :: (Core.Maybe [Entity]),
      -- | The @entity_mentions@ field contains all the annotated medical entities that were mentioned in the provided document.
      entityMentions :: (Core.Maybe [EntityMention]),
      -- | The FHIR bundle (<http://hl7.org/fhir/R4/bundle.html R4>) that includes all the entities, the entity mentions, and the relationships in JSON format.
      fhirBundle :: (Core.Maybe Core.Text),
      -- | relationships contains all the binary relationships that were identified between entity mentions within the provided document.
      relationships :: (Core.Maybe [EntityMentionRelationship])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AnalyzeEntitiesResponse' with the minimum fields required to make a request.
  newAnalyzeEntitiesResponse ::
    AnalyzeEntitiesResponse
  newAnalyzeEntitiesResponse =
    AnalyzeEntitiesResponse
      { entities = Core.Nothing,
        entityMentions = Core.Nothing,
        fhirBundle = Core.Nothing,
        relationships = Core.Nothing
      }
  
  instance Core.FromJSON AnalyzeEntitiesResponse where
    parseJSON =
      Core.withObject
        "AnalyzeEntitiesResponse"
        ( \o ->
            AnalyzeEntitiesResponse
              Core.<$> (o Core..:? "entities")
              Core.<*> (o Core..:? "entityMentions")
              Core.<*> (o Core..:? "fhirBundle")
              Core.<*> (o Core..:? "relationships")
        )
  
  instance Core.ToJSON AnalyzeEntitiesResponse where
    toJSON AnalyzeEntitiesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("entities" Core..=) Core.<$> entities,
              ("entityMentions" Core..=) Core.<$> entityMentions,
              ("fhirBundle" Core..=) Core.<$> fhirBundle,
              ("relationships" Core..=) Core.<$> relationships
            ]
        )
  
  -- | Contains the error details of the unsupported admin Consent resources for when the ApplyAdminConsents method fails to apply one or more Consent resources.
  --
  -- /See:/ 'newApplyAdminConsentsErrorDetail' smart constructor.
  data ApplyAdminConsentsErrorDetail = ApplyAdminConsentsErrorDetail
    { -- | The list of Consent resources that are unsupported or cannot be applied and the error associated with each of them.
      consentErrors :: (Core.Maybe [ConsentErrors]),
      -- | The currently in progress non-validate-only ApplyAdminConsents operation ID if exist.
      existingOperationId :: (Core.Maybe Core.Word64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApplyAdminConsentsErrorDetail' with the minimum fields required to make a request.
  newApplyAdminConsentsErrorDetail ::
    ApplyAdminConsentsErrorDetail
  newApplyAdminConsentsErrorDetail =
    ApplyAdminConsentsErrorDetail
      { consentErrors = Core.Nothing,
        existingOperationId = Core.Nothing
      }
  
  instance Core.FromJSON ApplyAdminConsentsErrorDetail where
    parseJSON =
      Core.withObject
        "ApplyAdminConsentsErrorDetail"
        ( \o ->
            ApplyAdminConsentsErrorDetail
              Core.<$> (o Core..:? "consentErrors")
              Core.<*> ( o
                           Core..:? "existingOperationId"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON ApplyAdminConsentsErrorDetail where
    toJSON ApplyAdminConsentsErrorDetail {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentErrors" Core..=) Core.<$> consentErrors,
              ("existingOperationId" Core..=)
                Core.. Core.AsText
                Core.<$> existingOperationId
            ]
        )
  
  -- | Request to apply the admin Consent resources for the specified FHIR store.
  --
  -- /See:/ 'newApplyAdminConsentsRequest' smart constructor.
  data ApplyAdminConsentsRequest = ApplyAdminConsentsRequest
    { -- | A new list of admin Consent resources to be applied. Any existing enforced Consents, which are specified in @consent_config.enforced_admin_consents@ of the FhirStore, that are not part of this list will be disabled. An empty list is equivalent to clearing or disabling all Consents enforced on the FHIR store. When a FHIR store has @disable_resource_versioning=true@ and this list contains a Consent resource that exists in @consent_config.enforced_admin_consents@, the method enforces any updates to the existing resource since the last enforcement. If the existing resource hasn\'t been updated since the last enforcement, the resource is unaffected. After the method finishes, the resulting consent enforcement model is determined by the contents of the Consent resource(s) when the method was called: * When @disable_resource_versioning=true@, the result is identical to the current resource(s) in the FHIR store. * When @disable_resource_versioning=false@, the result is based on the historical version(s) of the
      -- Consent resource(s) at the point in time when the method was called. At most 200 Consents can be specified.
      newConsentsList' :: (Core.Maybe AdminConsents),
      -- | Optional. If true, the method only validates Consent resources to make sure they are supported. Otherwise, the method applies the aggregate consent information to update the enforcement model and reindex the FHIR resources. If all Consent resources can be applied successfully, the ApplyAdminConsentsResponse is returned containing the following fields: * @consent_apply_success@ to indicate the number of Consent resources applied. * @affected_resources@ to indicate the number of resources that might have had their consent access changed. If, however, one or more Consent resources are unsupported or cannot be applied, the method fails and ApplyAdminConsentsErrorDetail is is returned with details about the unsupported Consent resources.
      validateOnly :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApplyAdminConsentsRequest' with the minimum fields required to make a request.
  newApplyAdminConsentsRequest ::
    ApplyAdminConsentsRequest
  newApplyAdminConsentsRequest =
    ApplyAdminConsentsRequest
      { newConsentsList' = Core.Nothing,
        validateOnly = Core.Nothing
      }
  
  instance Core.FromJSON ApplyAdminConsentsRequest where
    parseJSON =
      Core.withObject
        "ApplyAdminConsentsRequest"
        ( \o ->
            ApplyAdminConsentsRequest
              Core.<$> (o Core..:? "newConsentsList")
              Core.<*> (o Core..:? "validateOnly")
        )
  
  instance Core.ToJSON ApplyAdminConsentsRequest where
    toJSON ApplyAdminConsentsRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("newConsentsList" Core..=) Core.<$> newConsentsList',
              ("validateOnly" Core..=) Core.<$> validateOnly
            ]
        )
  
  -- | Response when all admin Consent resources in scope were processed and all affected resources were reindexed successfully. This structure will be included in the response when the operation finishes successfully.
  --
  -- /See:/ 'newApplyAdminConsentsResponse' smart constructor.
  data ApplyAdminConsentsResponse = ApplyAdminConsentsResponse
    { -- | The number of resources (including the Consent resources) that may have consent access change.
      affectedResources :: (Core.Maybe Core.Int64),
      -- | If @validate_only=false@ in ApplyAdminConsentsRequest, this counter contains the number of Consent resources that were successfully applied. Otherwise, it is the number of Consent resources that are supported.
      consentApplySuccess :: (Core.Maybe Core.Int64),
      -- | The number of resources (including the Consent resources) that ApplyAdminConsents failed to re-index.
      failedResources :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApplyAdminConsentsResponse' with the minimum fields required to make a request.
  newApplyAdminConsentsResponse ::
    ApplyAdminConsentsResponse
  newApplyAdminConsentsResponse =
    ApplyAdminConsentsResponse
      { affectedResources = Core.Nothing,
        consentApplySuccess = Core.Nothing,
        failedResources = Core.Nothing
      }
  
  instance Core.FromJSON ApplyAdminConsentsResponse where
    parseJSON =
      Core.withObject
        "ApplyAdminConsentsResponse"
        ( \o ->
            ApplyAdminConsentsResponse
              Core.<$> (o Core..:? "affectedResources" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> ( o
                           Core..:? "consentApplySuccess"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "failedResources" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON ApplyAdminConsentsResponse where
    toJSON ApplyAdminConsentsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("affectedResources" Core..=)
                Core.. Core.AsText
                Core.<$> affectedResources,
              ("consentApplySuccess" Core..=)
                Core.. Core.AsText
                Core.<$> consentApplySuccess,
              ("failedResources" Core..=)
                Core.. Core.AsText
                Core.<$> failedResources
            ]
        )
  
  -- | Request to apply the Consent resources for the specified FHIR store.
  --
  -- /See:/ 'newApplyConsentsRequest' smart constructor.
  data ApplyConsentsRequest = ApplyConsentsRequest
    { -- | Optional. Scope down to a list of patients.
      patientScope :: (Core.Maybe PatientScope),
      -- | Optional. Scope down to patients whose most recent consent changes are in the time range. Can only be used with a versioning store (i.e. when disable/resource/versioning is set to false).
      timeRange :: (Core.Maybe TimeRange),
      -- | Optional. If true, the method only validates Consent resources to make sure they are supported. When the operation completes, ApplyConsentsResponse is returned where @consent_apply_success@ and @consent_apply_failure@ indicate supported and unsupported (or invalid) Consent resources, respectively. Otherwise, the method propagates the aggregate consensual information to the patient\'s resources. Upon success, @affected_resources@ in the ApplyConsentsResponse indicates the number of resources that may have consensual access changed.
      validateOnly :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApplyConsentsRequest' with the minimum fields required to make a request.
  newApplyConsentsRequest ::
    ApplyConsentsRequest
  newApplyConsentsRequest =
    ApplyConsentsRequest
      { patientScope = Core.Nothing,
        timeRange = Core.Nothing,
        validateOnly = Core.Nothing
      }
  
  instance Core.FromJSON ApplyConsentsRequest where
    parseJSON =
      Core.withObject
        "ApplyConsentsRequest"
        ( \o ->
            ApplyConsentsRequest
              Core.<$> (o Core..:? "patientScope")
              Core.<*> (o Core..:? "timeRange")
              Core.<*> (o Core..:? "validateOnly")
        )
  
  instance Core.ToJSON ApplyConsentsRequest where
    toJSON ApplyConsentsRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("patientScope" Core..=) Core.<$> patientScope,
              ("timeRange" Core..=) Core.<$> timeRange,
              ("validateOnly" Core..=) Core.<$> validateOnly
            ]
        )
  
  -- | Response when all Consent resources in scope were processed and all affected resources were reindexed successfully. This structure is included in the response when the operation finishes successfully.
  --
  -- /See:/ 'newApplyConsentsResponse' smart constructor.
  data ApplyConsentsResponse = ApplyConsentsResponse
    { -- | The number of resources (including the Consent resources) that may have consensual access change.
      affectedResources :: (Core.Maybe Core.Int64),
      -- | If @validate_only = false@ in ApplyConsentsRequest, this counter is the number of Consent resources that were failed to apply. Otherwise, it is the number of Consent resources that are not supported or invalid.
      consentApplyFailure :: (Core.Maybe Core.Int64),
      -- | If @validate_only = false@ in ApplyConsentsRequest, this counter is the number of Consent resources that were successfully applied. Otherwise, it is the number of Consent resources that are supported.
      consentApplySuccess :: (Core.Maybe Core.Int64),
      -- | The number of resources (including the Consent resources) that ApplyConsents failed to re-index.
      failedResources :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApplyConsentsResponse' with the minimum fields required to make a request.
  newApplyConsentsResponse ::
    ApplyConsentsResponse
  newApplyConsentsResponse =
    ApplyConsentsResponse
      { affectedResources = Core.Nothing,
        consentApplyFailure = Core.Nothing,
        consentApplySuccess = Core.Nothing,
        failedResources = Core.Nothing
      }
  
  instance Core.FromJSON ApplyConsentsResponse where
    parseJSON =
      Core.withObject
        "ApplyConsentsResponse"
        ( \o ->
            ApplyConsentsResponse
              Core.<$> (o Core..:? "affectedResources" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> ( o
                           Core..:? "consentApplyFailure"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "consentApplySuccess"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "failedResources" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON ApplyConsentsResponse where
    toJSON ApplyConsentsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("affectedResources" Core..=)
                Core.. Core.AsText
                Core.<$> affectedResources,
              ("consentApplyFailure" Core..=)
                Core.. Core.AsText
                Core.<$> consentApplyFailure,
              ("consentApplySuccess" Core..=)
                Core.. Core.AsText
                Core.<$> consentApplySuccess,
              ("failedResources" Core..=)
                Core.. Core.AsText
                Core.<$> failedResources
            ]
        )
  
  -- | Archives the specified User data mapping.
  --
  -- /See:/ 'newArchiveUserDataMappingRequest' smart constructor.
  data ArchiveUserDataMappingRequest = ArchiveUserDataMappingRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ArchiveUserDataMappingRequest' with the minimum fields required to make a request.
  newArchiveUserDataMappingRequest ::
    ArchiveUserDataMappingRequest
  newArchiveUserDataMappingRequest = ArchiveUserDataMappingRequest
  
  instance Core.FromJSON ArchiveUserDataMappingRequest where
    parseJSON =
      Core.withObject
        "ArchiveUserDataMappingRequest"
        (\o -> Core.pure ArchiveUserDataMappingRequest)
  
  instance Core.ToJSON ArchiveUserDataMappingRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | Archives the specified User data mapping.
  --
  -- /See:/ 'newArchiveUserDataMappingResponse' smart constructor.
  data ArchiveUserDataMappingResponse = ArchiveUserDataMappingResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ArchiveUserDataMappingResponse' with the minimum fields required to make a request.
  newArchiveUserDataMappingResponse ::
    ArchiveUserDataMappingResponse
  newArchiveUserDataMappingResponse = ArchiveUserDataMappingResponse
  
  instance Core.FromJSON ArchiveUserDataMappingResponse where
    parseJSON =
      Core.withObject
        "ArchiveUserDataMappingResponse"
        (\o -> Core.pure ArchiveUserDataMappingResponse)
  
  instance Core.ToJSON ArchiveUserDataMappingResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | An attribute value for a Consent or User data mapping. Each Attribute must have a corresponding AttributeDefinition in the consent store that defines the default and allowed values.
  --
  -- /See:/ 'newAttribute' smart constructor.
  data Attribute = Attribute
    { -- | Indicates the name of an attribute defined in the consent store.
      attributeDefinitionId :: (Core.Maybe Core.Text),
      -- | Required. The value of the attribute. Must be an acceptable value as defined in the consent store. For example, if the consent store defines \"data type\" with acceptable values \"questionnaire\" and \"step-count\", when the attribute name is data type, this field must contain one of those values.
      values :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Attribute' with the minimum fields required to make a request.
  newAttribute ::
    Attribute
  newAttribute =
    Attribute
      { attributeDefinitionId = Core.Nothing,
        values = Core.Nothing
      }
  
  instance Core.FromJSON Attribute where
    parseJSON =
      Core.withObject
        "Attribute"
        ( \o ->
            Attribute
              Core.<$> (o Core..:? "attributeDefinitionId")
              Core.<*> (o Core..:? "values")
        )
  
  instance Core.ToJSON Attribute where
    toJSON Attribute {..} =
      Core.object
        ( Core.catMaybes
            [ ("attributeDefinitionId" Core..=) Core.<$> attributeDefinitionId,
              ("values" Core..=) Core.<$> values
            ]
        )
  
  -- | A client-defined consent attribute.
  --
  -- /See:/ 'newAttributeDefinition' smart constructor.
  data AttributeDefinition = AttributeDefinition
    { -- | Required. Possible values for the attribute. The number of allowed values must not exceed 500. An empty list is invalid. The list can only be expanded after creation.
      allowedValues :: (Core.Maybe [Core.Text]),
      -- | Required. The category of the attribute. The value of this field cannot be changed after creation.
      category :: (Core.Maybe AttributeDefinition_Category),
      -- | Optional. Default values of the attribute in Consents. If no default values are specified, it defaults to an empty value.
      consentDefaultValues :: (Core.Maybe [Core.Text]),
      -- | Optional. Default value of the attribute in User data mappings. If no default value is specified, it defaults to an empty value. This field is only applicable to attributes of the category @RESOURCE@.
      dataMappingDefaultValue :: (Core.Maybe Core.Text),
      -- | Optional. A description of the attribute.
      description :: (Core.Maybe Core.Text),
      -- | Identifier. Resource name of the Attribute definition, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/attributeDefinitions\/{attribute_definition_id}@. Cannot be changed after creation.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AttributeDefinition' with the minimum fields required to make a request.
  newAttributeDefinition ::
    AttributeDefinition
  newAttributeDefinition =
    AttributeDefinition
      { allowedValues = Core.Nothing,
        category = Core.Nothing,
        consentDefaultValues = Core.Nothing,
        dataMappingDefaultValue = Core.Nothing,
        description = Core.Nothing,
        name = Core.Nothing
      }
  
  instance Core.FromJSON AttributeDefinition where
    parseJSON =
      Core.withObject
        "AttributeDefinition"
        ( \o ->
            AttributeDefinition
              Core.<$> (o Core..:? "allowedValues")
              Core.<*> (o Core..:? "category")
              Core.<*> (o Core..:? "consentDefaultValues")
              Core.<*> (o Core..:? "dataMappingDefaultValue")
              Core.<*> (o Core..:? "description")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON AttributeDefinition where
    toJSON AttributeDefinition {..} =
      Core.object
        ( Core.catMaybes
            [ ("allowedValues" Core..=) Core.<$> allowedValues,
              ("category" Core..=) Core.<$> category,
              ("consentDefaultValues" Core..=) Core.<$> consentDefaultValues,
              ("dataMappingDefaultValue" Core..=)
                Core.<$> dataMappingDefaultValue,
              ("description" Core..=) Core.<$> description,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | 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
            ]
        )
  
  -- | 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'
            ]
        )
  
  -- | BlobStorageInfo contains details about the data stored in Blob Storage for the referenced resource. Note: Storage class is only valid for DICOM and hence will only be populated for DICOM resources.
  --
  -- /See:/ 'newBlobStorageInfo' smart constructor.
  data BlobStorageInfo = BlobStorageInfo
    { -- | Size in bytes of data stored in Blob Storage.
      sizeBytes :: (Core.Maybe Core.Int64),
      -- | The storage class in which the Blob data is stored.
      storageClass :: (Core.Maybe BlobStorageInfo_StorageClass),
      -- | The time at which the storage class was updated. This is used to compute early deletion fees of the resource.
      storageClassUpdateTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BlobStorageInfo' with the minimum fields required to make a request.
  newBlobStorageInfo ::
    BlobStorageInfo
  newBlobStorageInfo =
    BlobStorageInfo
      { sizeBytes = Core.Nothing,
        storageClass = Core.Nothing,
        storageClassUpdateTime = Core.Nothing
      }
  
  instance Core.FromJSON BlobStorageInfo where
    parseJSON =
      Core.withObject
        "BlobStorageInfo"
        ( \o ->
            BlobStorageInfo
              Core.<$> (o Core..:? "sizeBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "storageClass")
              Core.<*> (o Core..:? "storageClassUpdateTime")
        )
  
  instance Core.ToJSON BlobStorageInfo where
    toJSON BlobStorageInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("sizeBytes" Core..=) Core.. Core.AsText Core.<$> sizeBytes,
              ("storageClass" Core..=) Core.<$> storageClass,
              ("storageClassUpdateTime" Core..=)
                Core.<$> storageClassUpdateTime
            ]
        )
  
  -- | Settings for data stored in Blob storage.
  --
  -- /See:/ 'newBlobStorageSettings' smart constructor.
  newtype BlobStorageSettings = BlobStorageSettings
    { -- | The Storage class in which the Blob data is stored.
      blobStorageClass :: (Core.Maybe BlobStorageSettings_BlobStorageClass)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BlobStorageSettings' with the minimum fields required to make a request.
  newBlobStorageSettings ::
    BlobStorageSettings
  newBlobStorageSettings =
    BlobStorageSettings {blobStorageClass = Core.Nothing}
  
  instance Core.FromJSON BlobStorageSettings where
    parseJSON =
      Core.withObject
        "BlobStorageSettings"
        ( \o ->
            BlobStorageSettings Core.<$> (o Core..:? "blobStorageClass")
        )
  
  instance Core.ToJSON BlobStorageSettings where
    toJSON BlobStorageSettings {..} =
      Core.object
        ( Core.catMaybes
            [("blobStorageClass" Core..=) Core.<$> blobStorageClass]
        )
  
  -- | The configuration for exporting to Cloud Storage using the bulk export API.
  --
  -- /See:/ 'newBulkExportGcsDestination' smart constructor.
  newtype BulkExportGcsDestination = BulkExportGcsDestination
    { -- | Optional. URI for a Cloud Storage directory where the server writes result files, in the format @gs:\/\/{bucket-id}\/{path\/to\/destination\/dir}@. If there is no trailing slash, the service appends one when composing the object path. The user is responsible for creating the Cloud Storage bucket referenced in @uri_prefix@.
      uriPrefix :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BulkExportGcsDestination' with the minimum fields required to make a request.
  newBulkExportGcsDestination ::
    BulkExportGcsDestination
  newBulkExportGcsDestination =
    BulkExportGcsDestination {uriPrefix = Core.Nothing}
  
  instance Core.FromJSON BulkExportGcsDestination where
    parseJSON =
      Core.withObject
        "BulkExportGcsDestination"
        (\o -> BulkExportGcsDestination Core.<$> (o Core..:? "uriPrefix"))
  
  instance Core.ToJSON BulkExportGcsDestination where
    toJSON BulkExportGcsDestination {..} =
      Core.object
        (Core.catMaybes [("uriPrefix" Core..=) Core.<$> uriPrefix])
  
  -- | The request message for Operations.CancelOperation.
  --
  -- /See:/ 'newCancelOperationRequest' smart constructor.
  data CancelOperationRequest = CancelOperationRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CancelOperationRequest' with the minimum fields required to make a request.
  newCancelOperationRequest ::
    CancelOperationRequest
  newCancelOperationRequest = CancelOperationRequest
  
  instance Core.FromJSON CancelOperationRequest where
    parseJSON =
      Core.withObject
        "CancelOperationRequest"
        (\o -> Core.pure CancelOperationRequest)
  
  instance Core.ToJSON CancelOperationRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | Mask a string by replacing its characters with a fixed character.
  --
  -- /See:/ 'newCharacterMaskConfig' smart constructor.
  newtype CharacterMaskConfig = CharacterMaskConfig
    { -- | Optional. Character to mask the sensitive values. If not supplied, defaults to \"*\".
      maskingCharacter :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CharacterMaskConfig' with the minimum fields required to make a request.
  newCharacterMaskConfig ::
    CharacterMaskConfig
  newCharacterMaskConfig =
    CharacterMaskConfig {maskingCharacter = Core.Nothing}
  
  instance Core.FromJSON CharacterMaskConfig where
    parseJSON =
      Core.withObject
        "CharacterMaskConfig"
        ( \o ->
            CharacterMaskConfig Core.<$> (o Core..:? "maskingCharacter")
        )
  
  instance Core.ToJSON CharacterMaskConfig where
    toJSON CharacterMaskConfig {..} =
      Core.object
        ( Core.catMaybes
            [("maskingCharacter" Core..=) Core.<$> maskingCharacter]
        )
  
  -- | Checks if a particular data_id of a User data mapping in the given consent store is consented for a given use.
  --
  -- /See:/ 'newCheckDataAccessRequest' smart constructor.
  data CheckDataAccessRequest = CheckDataAccessRequest
    { -- | Optional. Specific Consents to evaluate the access request against. These Consents must have the same @user_id@ as the evaluated User data mapping, must exist in the current @consent_store@, and have a @state@ of either @ACTIVE@ or @DRAFT@. A maximum of 100 Consents can be provided here. If no selection is specified, the access request is evaluated against all @ACTIVE@ unexpired Consents with the same @user_id@ as the evaluated User data mapping.
      consentList :: (Core.Maybe ConsentList),
      -- | Required. The unique identifier of the resource to check access for. This identifier must correspond to a User data mapping in the given consent store.
      dataId :: (Core.Maybe Core.Text),
      -- | The values of request attributes associated with this access request.
      requestAttributes :: (Core.Maybe CheckDataAccessRequest_RequestAttributes),
      -- | Optional. The view for CheckDataAccessResponse. If unspecified, defaults to @BASIC@ and returns @consented@ as @TRUE@ or @FALSE@.
      responseView :: (Core.Maybe CheckDataAccessRequest_ResponseView)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckDataAccessRequest' with the minimum fields required to make a request.
  newCheckDataAccessRequest ::
    CheckDataAccessRequest
  newCheckDataAccessRequest =
    CheckDataAccessRequest
      { consentList = Core.Nothing,
        dataId = Core.Nothing,
        requestAttributes = Core.Nothing,
        responseView = Core.Nothing
      }
  
  instance Core.FromJSON CheckDataAccessRequest where
    parseJSON =
      Core.withObject
        "CheckDataAccessRequest"
        ( \o ->
            CheckDataAccessRequest
              Core.<$> (o Core..:? "consentList")
              Core.<*> (o Core..:? "dataId")
              Core.<*> (o Core..:? "requestAttributes")
              Core.<*> (o Core..:? "responseView")
        )
  
  instance Core.ToJSON CheckDataAccessRequest where
    toJSON CheckDataAccessRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentList" Core..=) Core.<$> consentList,
              ("dataId" Core..=) Core.<$> dataId,
              ("requestAttributes" Core..=) Core.<$> requestAttributes,
              ("responseView" Core..=) Core.<$> responseView
            ]
        )
  
  -- | The values of request attributes associated with this access request.
  --
  -- /See:/ 'newCheckDataAccessRequest_RequestAttributes' smart constructor.
  newtype CheckDataAccessRequest_RequestAttributes = CheckDataAccessRequest_RequestAttributes
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckDataAccessRequest_RequestAttributes' with the minimum fields required to make a request.
  newCheckDataAccessRequest_RequestAttributes ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    CheckDataAccessRequest_RequestAttributes
  newCheckDataAccessRequest_RequestAttributes additional =
    CheckDataAccessRequest_RequestAttributes {additional = additional}
  
  instance Core.FromJSON CheckDataAccessRequest_RequestAttributes where
    parseJSON =
      Core.withObject
        "CheckDataAccessRequest_RequestAttributes"
        ( \o ->
            CheckDataAccessRequest_RequestAttributes
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON CheckDataAccessRequest_RequestAttributes where
    toJSON CheckDataAccessRequest_RequestAttributes {..} =
      Core.toJSON additional
  
  -- | Checks if a particular data_id of a User data mapping in the given consent store is consented for a given use.
  --
  -- /See:/ 'newCheckDataAccessResponse' smart constructor.
  data CheckDataAccessResponse = CheckDataAccessResponse
    { -- | The resource names of all evaluated Consents mapped to their evaluation.
      consentDetails :: (Core.Maybe CheckDataAccessResponse_ConsentDetails),
      -- | Whether the requested resource is consented for the given use.
      consented :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckDataAccessResponse' with the minimum fields required to make a request.
  newCheckDataAccessResponse ::
    CheckDataAccessResponse
  newCheckDataAccessResponse =
    CheckDataAccessResponse
      { consentDetails = Core.Nothing,
        consented = Core.Nothing
      }
  
  instance Core.FromJSON CheckDataAccessResponse where
    parseJSON =
      Core.withObject
        "CheckDataAccessResponse"
        ( \o ->
            CheckDataAccessResponse
              Core.<$> (o Core..:? "consentDetails")
              Core.<*> (o Core..:? "consented")
        )
  
  instance Core.ToJSON CheckDataAccessResponse where
    toJSON CheckDataAccessResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentDetails" Core..=) Core.<$> consentDetails,
              ("consented" Core..=) Core.<$> consented
            ]
        )
  
  -- | The resource names of all evaluated Consents mapped to their evaluation.
  --
  -- /See:/ 'newCheckDataAccessResponse_ConsentDetails' smart constructor.
  newtype CheckDataAccessResponse_ConsentDetails = CheckDataAccessResponse_ConsentDetails
    { additional :: (Core.HashMap Core.Text ConsentEvaluation)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckDataAccessResponse_ConsentDetails' with the minimum fields required to make a request.
  newCheckDataAccessResponse_ConsentDetails ::
    -- |  See 'additional'.
    Core.HashMap Core.Text ConsentEvaluation ->
    CheckDataAccessResponse_ConsentDetails
  newCheckDataAccessResponse_ConsentDetails additional =
    CheckDataAccessResponse_ConsentDetails {additional = additional}
  
  instance Core.FromJSON CheckDataAccessResponse_ConsentDetails where
    parseJSON =
      Core.withObject
        "CheckDataAccessResponse_ConsentDetails"
        ( \o ->
            CheckDataAccessResponse_ConsentDetails
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON CheckDataAccessResponse_ConsentDetails where
    toJSON CheckDataAccessResponse_ConsentDetails {..} =
      Core.toJSON additional
  
  -- | Represents a user\'s consent.
  --
  -- /See:/ 'newConsent' smart constructor.
  data Consent = Consent
    { -- | Required. The resource name of the Consent artifact that contains proof of the end user\'s consent, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/consentArtifacts\/{consent_artifact_id}@.
      consentArtifact :: (Core.Maybe Core.Text),
      -- | Timestamp in UTC of when this Consent is considered expired.
      expireTime :: (Core.Maybe Core.DateTime),
      -- | Optional. User-supplied key-value pairs used to organize Consent resources. Metadata keys must: - be between 1 and 63 characters long - have a UTF-8 encoding of maximum 128 bytes - begin with a letter - consist of up to 63 characters including lowercase letters, numeric characters, underscores, and dashes Metadata values must be: - be between 1 and 63 characters long - have a UTF-8 encoding of maximum 128 bytes - consist of up to 63 characters including lowercase letters, numeric characters, underscores, and dashes No more than 64 metadata entries can be associated with a given consent.
      metadata :: (Core.Maybe Consent_Metadata),
      -- | Identifier. Resource name of the Consent, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/consents\/{consent_id}@. Cannot be changed after creation.
      name :: (Core.Maybe Core.Text),
      -- | Optional. Represents a user\'s consent in terms of the resources that can be accessed and under what conditions.
      policies :: (Core.Maybe [GoogleCloudHealthcareV1ConsentPolicy]),
      -- | Output only. The timestamp that the revision was created.
      revisionCreateTime :: (Core.Maybe Core.DateTime),
      -- | Output only. The revision ID of the Consent. The format is an 8-character hexadecimal string. Refer to a specific revision of a Consent by appending @\@{revision_id}@ to the Consent\'s resource name.
      revisionId :: (Core.Maybe Core.Text),
      -- | Required. Indicates the current state of this Consent.
      state :: (Core.Maybe Consent_State),
      -- | Input only. The time to live for this Consent from when it is created.
      ttl :: (Core.Maybe Core.Duration),
      -- | Required. User\'s UUID provided by the client.
      userId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Consent' with the minimum fields required to make a request.
  newConsent ::
    Consent
  newConsent =
    Consent
      { consentArtifact = Core.Nothing,
        expireTime = Core.Nothing,
        metadata = Core.Nothing,
        name = Core.Nothing,
        policies = Core.Nothing,
        revisionCreateTime = Core.Nothing,
        revisionId = Core.Nothing,
        state = Core.Nothing,
        ttl = Core.Nothing,
        userId = Core.Nothing
      }
  
  instance Core.FromJSON Consent where
    parseJSON =
      Core.withObject
        "Consent"
        ( \o ->
            Consent
              Core.<$> (o Core..:? "consentArtifact")
              Core.<*> (o Core..:? "expireTime")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "policies")
              Core.<*> (o Core..:? "revisionCreateTime")
              Core.<*> (o Core..:? "revisionId")
              Core.<*> (o Core..:? "state")
              Core.<*> (o Core..:? "ttl")
              Core.<*> (o Core..:? "userId")
        )
  
  instance Core.ToJSON Consent where
    toJSON Consent {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentArtifact" Core..=) Core.<$> consentArtifact,
              ("expireTime" Core..=) Core.<$> expireTime,
              ("metadata" Core..=) Core.<$> metadata,
              ("name" Core..=) Core.<$> name,
              ("policies" Core..=) Core.<$> policies,
              ("revisionCreateTime" Core..=) Core.<$> revisionCreateTime,
              ("revisionId" Core..=) Core.<$> revisionId,
              ("state" Core..=) Core.<$> state,
              ("ttl" Core..=) Core.<$> ttl,
              ("userId" Core..=) Core.<$> userId
            ]
        )
  
  -- | Optional. User-supplied key-value pairs used to organize Consent resources. Metadata keys must: - be between 1 and 63 characters long - have a UTF-8 encoding of maximum 128 bytes - begin with a letter - consist of up to 63 characters including lowercase letters, numeric characters, underscores, and dashes Metadata values must be: - be between 1 and 63 characters long - have a UTF-8 encoding of maximum 128 bytes - consist of up to 63 characters including lowercase letters, numeric characters, underscores, and dashes No more than 64 metadata entries can be associated with a given consent.
  --
  -- /See:/ 'newConsent_Metadata' smart constructor.
  newtype Consent_Metadata = Consent_Metadata
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Consent_Metadata' with the minimum fields required to make a request.
  newConsent_Metadata ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Consent_Metadata
  newConsent_Metadata additional =
    Consent_Metadata {additional = additional}
  
  instance Core.FromJSON Consent_Metadata where
    parseJSON =
      Core.withObject
        "Consent_Metadata"
        (\o -> Consent_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Consent_Metadata where
    toJSON Consent_Metadata {..} = Core.toJSON additional
  
  -- | The accessor scope that describes who can access, for what purpose, in which environment.
  --
  -- /See:/ 'newConsentAccessorScope' smart constructor.
  data ConsentAccessorScope = ConsentAccessorScope
    { -- | An individual, group, or access role that identifies the accessor or a characteristic of the accessor. This can be a resource ID (such as @{resourceType}\/{id}@) or an external URI. This value must be present.
      actor :: (Core.Maybe Core.Text),
      -- | An abstract identifier that describes the environment or conditions under which the accessor is acting. If it\'s not specified, it applies to all environments.
      environment :: (Core.Maybe Core.Text),
      -- | The intent of data use. If it\'s not specified, it applies to all purposes.
      purpose :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentAccessorScope' with the minimum fields required to make a request.
  newConsentAccessorScope ::
    ConsentAccessorScope
  newConsentAccessorScope =
    ConsentAccessorScope
      { actor = Core.Nothing,
        environment = Core.Nothing,
        purpose = Core.Nothing
      }
  
  instance Core.FromJSON ConsentAccessorScope where
    parseJSON =
      Core.withObject
        "ConsentAccessorScope"
        ( \o ->
            ConsentAccessorScope
              Core.<$> (o Core..:? "actor")
              Core.<*> (o Core..:? "environment")
              Core.<*> (o Core..:? "purpose")
        )
  
  instance Core.ToJSON ConsentAccessorScope where
    toJSON ConsentAccessorScope {..} =
      Core.object
        ( Core.catMaybes
            [ ("actor" Core..=) Core.<$> actor,
              ("environment" Core..=) Core.<$> environment,
              ("purpose" Core..=) Core.<$> purpose
            ]
        )
  
  -- | Documentation of a user\'s consent.
  --
  -- /See:/ 'newConsentArtifact' smart constructor.
  data ConsentArtifact = ConsentArtifact
    { -- | Optional. Screenshots, PDFs, or other binary information documenting the user\'s consent.
      consentContentScreenshots :: (Core.Maybe [Image]),
      -- | Optional. An string indicating the version of the consent information shown to the user.
      consentContentVersion :: (Core.Maybe Core.Text),
      -- | Optional. A signature from a guardian.
      guardianSignature :: (Core.Maybe Signature),
      -- | Optional. Metadata associated with the Consent artifact. For example, the consent locale or user agent version.
      metadata :: (Core.Maybe ConsentArtifact_Metadata),
      -- | Identifier. Resource name of the Consent artifact, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/consentArtifacts\/{consent_artifact_id}@. Cannot be changed after creation.
      name :: (Core.Maybe Core.Text),
      -- | Required. User\'s UUID provided by the client.
      userId :: (Core.Maybe Core.Text),
      -- | Optional. User\'s signature.
      userSignature :: (Core.Maybe Signature),
      -- | Optional. A signature from a witness.
      witnessSignature :: (Core.Maybe Signature)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentArtifact' with the minimum fields required to make a request.
  newConsentArtifact ::
    ConsentArtifact
  newConsentArtifact =
    ConsentArtifact
      { consentContentScreenshots = Core.Nothing,
        consentContentVersion = Core.Nothing,
        guardianSignature = Core.Nothing,
        metadata = Core.Nothing,
        name = Core.Nothing,
        userId = Core.Nothing,
        userSignature = Core.Nothing,
        witnessSignature = Core.Nothing
      }
  
  instance Core.FromJSON ConsentArtifact where
    parseJSON =
      Core.withObject
        "ConsentArtifact"
        ( \o ->
            ConsentArtifact
              Core.<$> (o Core..:? "consentContentScreenshots")
              Core.<*> (o Core..:? "consentContentVersion")
              Core.<*> (o Core..:? "guardianSignature")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "userId")
              Core.<*> (o Core..:? "userSignature")
              Core.<*> (o Core..:? "witnessSignature")
        )
  
  instance Core.ToJSON ConsentArtifact where
    toJSON ConsentArtifact {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentContentScreenshots" Core..=)
                Core.<$> consentContentScreenshots,
              ("consentContentVersion" Core..=) Core.<$> consentContentVersion,
              ("guardianSignature" Core..=) Core.<$> guardianSignature,
              ("metadata" Core..=) Core.<$> metadata,
              ("name" Core..=) Core.<$> name,
              ("userId" Core..=) Core.<$> userId,
              ("userSignature" Core..=) Core.<$> userSignature,
              ("witnessSignature" Core..=) Core.<$> witnessSignature
            ]
        )
  
  -- | Optional. Metadata associated with the Consent artifact. For example, the consent locale or user agent version.
  --
  -- /See:/ 'newConsentArtifact_Metadata' smart constructor.
  newtype ConsentArtifact_Metadata = ConsentArtifact_Metadata
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentArtifact_Metadata' with the minimum fields required to make a request.
  newConsentArtifact_Metadata ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    ConsentArtifact_Metadata
  newConsentArtifact_Metadata additional =
    ConsentArtifact_Metadata {additional = additional}
  
  instance Core.FromJSON ConsentArtifact_Metadata where
    parseJSON =
      Core.withObject
        "ConsentArtifact_Metadata"
        (\o -> ConsentArtifact_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON ConsentArtifact_Metadata where
    toJSON ConsentArtifact_Metadata {..} = Core.toJSON additional
  
  -- | Configures whether to enforce consent for the FHIR store and which consent enforcement version is being used.
  --
  -- /See:/ 'newConsentConfig' smart constructor.
  data ConsentConfig = ConsentConfig
    { -- | Optional. Specifies how the server logs the consent-aware requests. If not specified, the @AccessDeterminationLogConfig.LogLevel.MINIMUM@ option is used.
      accessDeterminationLogConfig :: (Core.Maybe AccessDeterminationLogConfig),
      -- | Optional. The default value is false. If set to true, when accessing FHIR resources, the consent headers will be verified against consents given by patients. See the ConsentEnforcementVersion for the supported consent headers.
      accessEnforced :: (Core.Maybe Core.Bool),
      -- | Optional. Different options to configure the behaviour of the server when handling the @X-Consent-Scope@ header.
      consentHeaderHandling :: (Core.Maybe ConsentHeaderHandling),
      -- | Output only. The versioned names of the enforced admin Consent resource(s), in the format @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Consent\/{resource_id}\/_history\/{version_id}@. For FHIR stores with @disable_resource_versioning=true@, the format is @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Consent\/{resource_id}@. This field can only be updated using ApplyAdminConsents.
      enforcedAdminConsents :: (Core.Maybe [Core.Text]),
      -- | Required. Specifies which consent enforcement version is being used for this FHIR store. This field can only be set once by either CreateFhirStore or UpdateFhirStore. After that, you must call ApplyConsents to change the version.
      version :: (Core.Maybe ConsentConfig_Version)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentConfig' with the minimum fields required to make a request.
  newConsentConfig ::
    ConsentConfig
  newConsentConfig =
    ConsentConfig
      { accessDeterminationLogConfig = Core.Nothing,
        accessEnforced = Core.Nothing,
        consentHeaderHandling = Core.Nothing,
        enforcedAdminConsents = Core.Nothing,
        version = Core.Nothing
      }
  
  instance Core.FromJSON ConsentConfig where
    parseJSON =
      Core.withObject
        "ConsentConfig"
        ( \o ->
            ConsentConfig
              Core.<$> (o Core..:? "accessDeterminationLogConfig")
              Core.<*> (o Core..:? "accessEnforced")
              Core.<*> (o Core..:? "consentHeaderHandling")
              Core.<*> (o Core..:? "enforcedAdminConsents")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON ConsentConfig where
    toJSON ConsentConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("accessDeterminationLogConfig" Core..=)
                Core.<$> accessDeterminationLogConfig,
              ("accessEnforced" Core..=) Core.<$> accessEnforced,
              ("consentHeaderHandling" Core..=) Core.<$> consentHeaderHandling,
              ("enforcedAdminConsents" Core..=) Core.<$> enforcedAdminConsents,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | The Consent resource name and error.
  --
  -- /See:/ 'newConsentErrors' smart constructor.
  data ConsentErrors = ConsentErrors
    { -- | The error code and message.
      error :: (Core.Maybe Status),
      -- | The versioned name of the admin Consent resource, in the format @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Consent\/{resource_id}\/_history\/{version_id}@. For FHIR stores with @disable_resource_versioning=true@, the format is @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Consent\/{resource_id}@.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentErrors' with the minimum fields required to make a request.
  newConsentErrors ::
    ConsentErrors
  newConsentErrors =
    ConsentErrors {error = Core.Nothing, name = Core.Nothing}
  
  instance Core.FromJSON ConsentErrors where
    parseJSON =
      Core.withObject
        "ConsentErrors"
        ( \o ->
            ConsentErrors
              Core.<$> (o Core..:? "error")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON ConsentErrors where
    toJSON ConsentErrors {..} =
      Core.object
        ( Core.catMaybes
            [("error" Core..=) Core.<$> error, ("name" Core..=) Core.<$> name]
        )
  
  -- | The detailed evaluation of a particular Consent.
  --
  -- /See:/ 'newConsentEvaluation' smart constructor.
  newtype ConsentEvaluation = ConsentEvaluation
    { -- | The evaluation result.
      evaluationResult :: (Core.Maybe ConsentEvaluation_EvaluationResult)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentEvaluation' with the minimum fields required to make a request.
  newConsentEvaluation ::
    ConsentEvaluation
  newConsentEvaluation =
    ConsentEvaluation {evaluationResult = Core.Nothing}
  
  instance Core.FromJSON ConsentEvaluation where
    parseJSON =
      Core.withObject
        "ConsentEvaluation"
        (\o -> ConsentEvaluation Core.<$> (o Core..:? "evaluationResult"))
  
  instance Core.ToJSON ConsentEvaluation where
    toJSON ConsentEvaluation {..} =
      Core.object
        ( Core.catMaybes
            [("evaluationResult" Core..=) Core.<$> evaluationResult]
        )
  
  -- | How the server handles the consent header.
  --
  -- /See:/ 'newConsentHeaderHandling' smart constructor.
  newtype ConsentHeaderHandling = ConsentHeaderHandling
    { -- | Optional. Specifies the default server behavior when the header is empty. If not specified, the @ScopeProfile.PERMIT_EMPTY_SCOPE@ option is used.
      profile :: (Core.Maybe ConsentHeaderHandling_Profile)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentHeaderHandling' with the minimum fields required to make a request.
  newConsentHeaderHandling ::
    ConsentHeaderHandling
  newConsentHeaderHandling =
    ConsentHeaderHandling {profile = Core.Nothing}
  
  instance Core.FromJSON ConsentHeaderHandling where
    parseJSON =
      Core.withObject
        "ConsentHeaderHandling"
        (\o -> ConsentHeaderHandling Core.<$> (o Core..:? "profile"))
  
  instance Core.ToJSON ConsentHeaderHandling where
    toJSON ConsentHeaderHandling {..} =
      Core.object
        (Core.catMaybes [("profile" Core..=) Core.<$> profile])
  
  -- | List of resource names of Consent resources.
  --
  -- /See:/ 'newConsentList' smart constructor.
  newtype ConsentList = ConsentList
    { -- | The resource names of the Consents to evaluate against, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/consents\/{consent_id}@.
      consents :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentList' with the minimum fields required to make a request.
  newConsentList ::
    ConsentList
  newConsentList = ConsentList {consents = Core.Nothing}
  
  instance Core.FromJSON ConsentList where
    parseJSON =
      Core.withObject
        "ConsentList"
        (\o -> ConsentList Core.<$> (o Core..:? "consents"))
  
  instance Core.ToJSON ConsentList where
    toJSON ConsentList {..} =
      Core.object
        (Core.catMaybes [("consents" Core..=) Core.<$> consents])
  
  -- | Represents a consent store.
  --
  -- /See:/ 'newConsentStore' smart constructor.
  data ConsentStore = ConsentStore
    { -- | Optional. Default time to live for Consents created in this store. Must be at least 24 hours. Updating this field will not affect the expiration time of existing consents.
      defaultConsentTtl :: (Core.Maybe Core.Duration),
      -- | Optional. If @true@, UpdateConsent creates the Consent if it does not already exist. If unspecified, defaults to @false@.
      enableConsentCreateOnUpdate :: (Core.Maybe Core.Bool),
      -- | Optional. User-supplied key-value pairs used to organize consent stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62}. Label values must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63}. No more than 64 labels can be associated with a given store. For more information: https:\/\/cloud.google.com\/healthcare\/docs\/how-tos\/labeling-resources
      labels :: (Core.Maybe ConsentStore_Labels),
      -- | Identifier. Resource name of the consent store, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}@. Cannot be changed after creation.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentStore' with the minimum fields required to make a request.
  newConsentStore ::
    ConsentStore
  newConsentStore =
    ConsentStore
      { defaultConsentTtl = Core.Nothing,
        enableConsentCreateOnUpdate = Core.Nothing,
        labels = Core.Nothing,
        name = Core.Nothing
      }
  
  instance Core.FromJSON ConsentStore where
    parseJSON =
      Core.withObject
        "ConsentStore"
        ( \o ->
            ConsentStore
              Core.<$> (o Core..:? "defaultConsentTtl")
              Core.<*> (o Core..:? "enableConsentCreateOnUpdate")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON ConsentStore where
    toJSON ConsentStore {..} =
      Core.object
        ( Core.catMaybes
            [ ("defaultConsentTtl" Core..=) Core.<$> defaultConsentTtl,
              ("enableConsentCreateOnUpdate" Core..=)
                Core.<$> enableConsentCreateOnUpdate,
              ("labels" Core..=) Core.<$> labels,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | Optional. User-supplied key-value pairs used to organize consent stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62}. Label values must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63}. No more than 64 labels can be associated with a given store. For more information: https:\/\/cloud.google.com\/healthcare\/docs\/how-tos\/labeling-resources
  --
  -- /See:/ 'newConsentStore_Labels' smart constructor.
  newtype ConsentStore_Labels = ConsentStore_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConsentStore_Labels' with the minimum fields required to make a request.
  newConsentStore_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    ConsentStore_Labels
  newConsentStore_Labels additional =
    ConsentStore_Labels {additional = additional}
  
  instance Core.FromJSON ConsentStore_Labels where
    parseJSON =
      Core.withObject
        "ConsentStore_Labels"
        (\o -> ConsentStore_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON ConsentStore_Labels where
    toJSON ConsentStore_Labels {..} = Core.toJSON additional
  
  -- | Creates a new message.
  --
  -- /See:/ 'newCreateMessageRequest' smart constructor.
  newtype CreateMessageRequest = CreateMessageRequest
    { -- | Required. HL7v2 message.
      message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateMessageRequest' with the minimum fields required to make a request.
  newCreateMessageRequest ::
    CreateMessageRequest
  newCreateMessageRequest =
    CreateMessageRequest {message = Core.Nothing}
  
  instance Core.FromJSON CreateMessageRequest where
    parseJSON =
      Core.withObject
        "CreateMessageRequest"
        (\o -> CreateMessageRequest Core.<$> (o Core..:? "message"))
  
  instance Core.ToJSON CreateMessageRequest where
    toJSON CreateMessageRequest {..} =
      Core.object
        (Core.catMaybes [("message" Core..=) Core.<$> message])
  
  -- | Pseudonymization method that generates surrogates via cryptographic hashing. Uses SHA-256. Outputs a base64-encoded representation of the hashed output (for example, @L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=@).
  --
  -- /See:/ 'newCryptoHashConfig' smart constructor.
  data CryptoHashConfig = CryptoHashConfig
    { -- | An AES 128\/192\/256 bit key. Causes the hash to be computed based on this key. A default key is generated for each Deidentify operation and is used when neither @crypto_key@ nor @kms_wrapped@ is specified. Must not be set if @kms_wrapped@ is set.
      cryptoKey :: (Core.Maybe Core.Base64),
      -- | KMS wrapped key. Must not be set if @crypto_key@ is set.
      kmsWrapped :: (Core.Maybe KmsWrappedCryptoKey)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CryptoHashConfig' with the minimum fields required to make a request.
  newCryptoHashConfig ::
    CryptoHashConfig
  newCryptoHashConfig =
    CryptoHashConfig
      { cryptoKey = Core.Nothing,
        kmsWrapped = Core.Nothing
      }
  
  instance Core.FromJSON CryptoHashConfig where
    parseJSON =
      Core.withObject
        "CryptoHashConfig"
        ( \o ->
            CryptoHashConfig
              Core.<$> (o Core..:? "cryptoKey")
              Core.<*> (o Core..:? "kmsWrapped")
        )
  
  instance Core.ToJSON CryptoHashConfig where
    toJSON CryptoHashConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("cryptoKey" Core..=) Core.<$> cryptoKey,
              ("kmsWrapped" Core..=) Core.<$> kmsWrapped
            ]
        )
  
  -- | A message representing a health dataset. A health dataset represents a collection of healthcare data pertaining to one or more patients. This may include multiple modalities of healthcare data, such as electronic medical records or medical imaging data.
  --
  -- /See:/ 'newDataset' smart constructor.
  data Dataset = Dataset
    { -- | Optional. Customer-managed encryption key spec for a Dataset. If set, this Dataset and all of its sub-resources will be secured by this key. If empty, the Dataset is secured by the default Google encryption key.
      encryptionSpec :: (Core.Maybe EncryptionSpec),
      -- | Identifier. Resource name of the dataset, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}@.
      name :: (Core.Maybe Core.Text),
      -- | Output only. For future use.
      satisfiesPzi :: (Core.Maybe Core.Bool),
      -- | Output only. For future use.
      satisfiesPzs :: (Core.Maybe Core.Bool),
      -- | Optional. The default timezone used by this dataset. Must be a either a valid IANA time zone name such as \"America\/New_York\" or empty, which defaults to UTC. This is used for parsing times in resources, such as HL7 messages, where no explicit timezone is specified.
      timeZone :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Dataset' with the minimum fields required to make a request.
  newDataset ::
    Dataset
  newDataset =
    Dataset
      { encryptionSpec = Core.Nothing,
        name = Core.Nothing,
        satisfiesPzi = Core.Nothing,
        satisfiesPzs = Core.Nothing,
        timeZone = Core.Nothing
      }
  
  instance Core.FromJSON Dataset where
    parseJSON =
      Core.withObject
        "Dataset"
        ( \o ->
            Dataset
              Core.<$> (o Core..:? "encryptionSpec")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "satisfiesPzi")
              Core.<*> (o Core..:? "satisfiesPzs")
              Core.<*> (o Core..:? "timeZone")
        )
  
  instance Core.ToJSON Dataset where
    toJSON Dataset {..} =
      Core.object
        ( Core.catMaybes
            [ ("encryptionSpec" Core..=) Core.<$> encryptionSpec,
              ("name" Core..=) Core.<$> name,
              ("satisfiesPzi" Core..=) Core.<$> satisfiesPzi,
              ("satisfiesPzs" Core..=) Core.<$> satisfiesPzs,
              ("timeZone" Core..=) Core.<$> timeZone
            ]
        )
  
  -- | Shift a date forward or backward in time by a random amount which is consistent for a given patient and crypto key combination.
  --
  -- /See:/ 'newDateShiftConfig' smart constructor.
  data DateShiftConfig = DateShiftConfig
    { -- | An AES 128\/192\/256 bit key. The date shift is computed based on this key and the patient ID. If the patient ID is empty for a DICOM resource, the date shift is computed based on this key and the study instance UID. If @crypto_key@ is not set, then @kms_wrapped@ is used to calculate the date shift. If neither is set, a default key is generated for each de-identify operation. Must not be set if @kms_wrapped@ is set.
      cryptoKey :: (Core.Maybe Core.Base64),
      -- | KMS wrapped key. If @kms_wrapped@ is not set, then @crypto_key@ is used to calculate the date shift. If neither is set, a default key is generated for each de-identify operation. Must not be set if @crypto_key@ is set.
      kmsWrapped :: (Core.Maybe KmsWrappedCryptoKey)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DateShiftConfig' with the minimum fields required to make a request.
  newDateShiftConfig ::
    DateShiftConfig
  newDateShiftConfig =
    DateShiftConfig
      { cryptoKey = Core.Nothing,
        kmsWrapped = Core.Nothing
      }
  
  instance Core.FromJSON DateShiftConfig where
    parseJSON =
      Core.withObject
        "DateShiftConfig"
        ( \o ->
            DateShiftConfig
              Core.<$> (o Core..:? "cryptoKey")
              Core.<*> (o Core..:? "kmsWrapped")
        )
  
  instance Core.ToJSON DateShiftConfig where
    toJSON DateShiftConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("cryptoKey" Core..=) Core.<$> cryptoKey,
              ("kmsWrapped" Core..=) Core.<$> kmsWrapped
            ]
        )
  
  -- | Contains configuration for streaming de-identified FHIR export.
  --
  -- /See:/ 'newDeidentifiedStoreDestination' smart constructor.
  data DeidentifiedStoreDestination = DeidentifiedStoreDestination
    { -- | Optional. The configuration to use when de-identifying resources that are added to this store.
      config :: (Core.Maybe DeidentifyConfig),
      -- | Optional. The full resource name of a Cloud Healthcare FHIR store, for example, @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}@.
      store :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DeidentifiedStoreDestination' with the minimum fields required to make a request.
  newDeidentifiedStoreDestination ::
    DeidentifiedStoreDestination
  newDeidentifiedStoreDestination =
    DeidentifiedStoreDestination
      { config = Core.Nothing,
        store = Core.Nothing
      }
  
  instance Core.FromJSON DeidentifiedStoreDestination where
    parseJSON =
      Core.withObject
        "DeidentifiedStoreDestination"
        ( \o ->
            DeidentifiedStoreDestination
              Core.<$> (o Core..:? "config")
              Core.<*> (o Core..:? "store")
        )
  
  instance Core.ToJSON DeidentifiedStoreDestination where
    toJSON DeidentifiedStoreDestination {..} =
      Core.object
        ( Core.catMaybes
            [ ("config" Core..=) Core.<$> config,
              ("store" Core..=) Core.<$> store
            ]
        )
  
  -- | Configures de-id options specific to different types of content. Each submessage customizes the handling of an https:\/\/tools.ietf.org\/html\/rfc6838 media type or subtype. Configs are applied in a nested manner at runtime.
  --
  -- /See:/ 'newDeidentifyConfig' smart constructor.
  data DeidentifyConfig = DeidentifyConfig
    { -- | Optional. Configures de-id of application\/DICOM content.
      dicom :: (Core.Maybe DicomConfig),
      -- | Optional. Configures de-id of application\/FHIR content.
      fhir :: (Core.Maybe FhirConfig),
      -- | Optional. Configures de-identification of image pixels wherever they are found in the source_dataset.
      image :: (Core.Maybe ImageConfig),
      -- | Optional. Configures de-identification of text wherever it is found in the source_dataset.
      text :: (Core.Maybe TextConfig),
      -- | Optional. Ensures in-flight data remains in the region of origin during de-identification. The default value is false. Using this option results in a significant reduction of throughput, and is not compatible with @LOCATION@ or @ORGANIZATION_NAME@ infoTypes. @LOCATION@ must be excluded within TextConfig, and must also be excluded within ImageConfig if image redaction is required.
      useRegionalDataProcessing :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DeidentifyConfig' with the minimum fields required to make a request.
  newDeidentifyConfig ::
    DeidentifyConfig
  newDeidentifyConfig =
    DeidentifyConfig
      { dicom = Core.Nothing,
        fhir = Core.Nothing,
        image = Core.Nothing,
        text = Core.Nothing,
        useRegionalDataProcessing = Core.Nothing
      }
  
  instance Core.FromJSON DeidentifyConfig where
    parseJSON =
      Core.withObject
        "DeidentifyConfig"
        ( \o ->
            DeidentifyConfig
              Core.<$> (o Core..:? "dicom")
              Core.<*> (o Core..:? "fhir")
              Core.<*> (o Core..:? "image")
              Core.<*> (o Core..:? "text")
              Core.<*> (o Core..:? "useRegionalDataProcessing")
        )
  
  instance Core.ToJSON DeidentifyConfig where
    toJSON DeidentifyConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("dicom" Core..=) Core.<$> dicom,
              ("fhir" Core..=) Core.<$> fhir,
              ("image" Core..=) Core.<$> image,
              ("text" Core..=) Core.<$> text,
              ("useRegionalDataProcessing" Core..=)
                Core.<$> useRegionalDataProcessing
            ]
        )
  
  -- | Redacts identifying information from the specified dataset.
  --
  -- /See:/ 'newDeidentifyDatasetRequest' smart constructor.
  data DeidentifyDatasetRequest = DeidentifyDatasetRequest
    { -- | Deidentify configuration. Only one of @config@ and @gcs_config_uri@ can be specified.
      config :: (Core.Maybe DeidentifyConfig),
      -- | Required. The name of the dataset resource to create and write the redacted data to. * The destination dataset must not exist. * The destination dataset must be in the same location as the source dataset. De-identifying data across multiple locations is not supported.
      destinationDataset :: (Core.Maybe Core.Text),
      -- | Cloud Storage location to read the JSON cloud.healthcare.deidentify.DeidentifyConfig from, overriding the default config. Must be of the form @gs:\/\/{bucket_id}\/path\/to\/object@. The Cloud Storage location must grant the Cloud IAM role @roles\/storage.objectViewer@ to the project\'s Cloud Healthcare Service Agent service account. Only one of @config@ and @gcs_config_uri@ can be specified.
      gcsConfigUri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DeidentifyDatasetRequest' with the minimum fields required to make a request.
  newDeidentifyDatasetRequest ::
    DeidentifyDatasetRequest
  newDeidentifyDatasetRequest =
    DeidentifyDatasetRequest
      { config = Core.Nothing,
        destinationDataset = Core.Nothing,
        gcsConfigUri = Core.Nothing
      }
  
  instance Core.FromJSON DeidentifyDatasetRequest where
    parseJSON =
      Core.withObject
        "DeidentifyDatasetRequest"
        ( \o ->
            DeidentifyDatasetRequest
              Core.<$> (o Core..:? "config")
              Core.<*> (o Core..:? "destinationDataset")
              Core.<*> (o Core..:? "gcsConfigUri")
        )
  
  instance Core.ToJSON DeidentifyDatasetRequest where
    toJSON DeidentifyDatasetRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("config" Core..=) Core.<$> config,
              ("destinationDataset" Core..=) Core.<$> destinationDataset,
              ("gcsConfigUri" Core..=) Core.<$> gcsConfigUri
            ]
        )
  
  -- | Creates a new DICOM store with sensitive information de-identified.
  --
  -- /See:/ 'newDeidentifyDicomStoreRequest' smart constructor.
  data DeidentifyDicomStoreRequest = DeidentifyDicomStoreRequest
    { -- | Deidentify configuration. Only one of @config@ and @gcs_config_uri@ can be specified.
      config :: (Core.Maybe DeidentifyConfig),
      -- | Required. The name of the DICOM store to create and write the redacted data to. For example, @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/dicomStores\/{dicom_store_id}@. * The destination dataset must exist. * The source dataset and destination dataset must both reside in the same location. De-identifying data across multiple locations is not supported. * The destination DICOM store must not exist. * The caller must have the necessary permissions to create the destination DICOM store.
      destinationStore :: (Core.Maybe Core.Text),
      -- | Filter configuration.
      filterConfig :: (Core.Maybe DicomFilterConfig),
      -- | Cloud Storage location to read the JSON cloud.healthcare.deidentify.DeidentifyConfig from, overriding the default config. Must be of the form @gs:\/\/{bucket_id}\/path\/to\/object@. The Cloud Storage location must grant the Cloud IAM role @roles\/storage.objectViewer@ to the project\'s Cloud Healthcare Service Agent service account. Only one of @config@ and @gcs_config_uri@ can be specified.
      gcsConfigUri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DeidentifyDicomStoreRequest' with the minimum fields required to make a request.
  newDeidentifyDicomStoreRequest ::
    DeidentifyDicomStoreRequest
  newDeidentifyDicomStoreRequest =
    DeidentifyDicomStoreRequest
      { config = Core.Nothing,
        destinationStore = Core.Nothing,
        filterConfig = Core.Nothing,
        gcsConfigUri = Core.Nothing
      }
  
  instance Core.FromJSON DeidentifyDicomStoreRequest where
    parseJSON =
      Core.withObject
        "DeidentifyDicomStoreRequest"
        ( \o ->
            DeidentifyDicomStoreRequest
              Core.<$> (o Core..:? "config")
              Core.<*> (o Core..:? "destinationStore")
              Core.<*> (o Core..:? "filterConfig")
              Core.<*> (o Core..:? "gcsConfigUri")
        )
  
  instance Core.ToJSON DeidentifyDicomStoreRequest where
    toJSON DeidentifyDicomStoreRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("config" Core..=) Core.<$> config,
              ("destinationStore" Core..=) Core.<$> destinationStore,
              ("filterConfig" Core..=) Core.<$> filterConfig,
              ("gcsConfigUri" Core..=) Core.<$> gcsConfigUri
            ]
        )
  
  -- | Creates a new FHIR store with sensitive information de-identified.
  --
  -- /See:/ 'newDeidentifyFhirStoreRequest' smart constructor.
  data DeidentifyFhirStoreRequest = DeidentifyFhirStoreRequest
    { -- | Deidentify configuration. Only one of @config@ and @gcs_config_uri@ can be specified.
      config :: (Core.Maybe DeidentifyConfig),
      -- | Required. The name of the FHIR store to create and write the redacted data to. For example, @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}@. * The destination dataset must exist. * The source dataset and destination dataset must both reside in the same location. De-identifying data across multiple locations is not supported. * The destination FHIR store must exist. * The caller must have the healthcare.fhirResources.update permission to write to the destination FHIR store.
      destinationStore :: (Core.Maybe Core.Text),
      -- | Cloud Storage location to read the JSON cloud.healthcare.deidentify.DeidentifyConfig from, overriding the default config. Must be of the form @gs:\/\/{bucket_id}\/path\/to\/object@. The Cloud Storage location must grant the Cloud IAM role @roles\/storage.objectViewer@ to the project\'s Cloud Healthcare Service Agent service account. Only one of @config@ and @gcs_config_uri@ can be specified.
      gcsConfigUri :: (Core.Maybe Core.Text),
      -- | A filter specifying the resources to include in the output. If not specified, all resources are included in the output.
      resourceFilter :: (Core.Maybe FhirFilter),
      -- | If true, skips resources that are created or modified after the de-identify operation is created.
      skipModifiedResources :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DeidentifyFhirStoreRequest' with the minimum fields required to make a request.
  newDeidentifyFhirStoreRequest ::
    DeidentifyFhirStoreRequest
  newDeidentifyFhirStoreRequest =
    DeidentifyFhirStoreRequest
      { config = Core.Nothing,
        destinationStore = Core.Nothing,
        gcsConfigUri = Core.Nothing,
        resourceFilter = Core.Nothing,
        skipModifiedResources = Core.Nothing
      }
  
  instance Core.FromJSON DeidentifyFhirStoreRequest where
    parseJSON =
      Core.withObject
        "DeidentifyFhirStoreRequest"
        ( \o ->
            DeidentifyFhirStoreRequest
              Core.<$> (o Core..:? "config")
              Core.<*> (o Core..:? "destinationStore")
              Core.<*> (o Core..:? "gcsConfigUri")
              Core.<*> (o Core..:? "resourceFilter")
              Core.<*> (o Core..:? "skipModifiedResources")
        )
  
  instance Core.ToJSON DeidentifyFhirStoreRequest where
    toJSON DeidentifyFhirStoreRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("config" Core..=) Core.<$> config,
              ("destinationStore" Core..=) Core.<$> destinationStore,
              ("gcsConfigUri" Core..=) Core.<$> gcsConfigUri,
              ("resourceFilter" Core..=) Core.<$> resourceFilter,
              ("skipModifiedResources" Core..=) Core.<$> skipModifiedResources
            ]
        )
  
  -- | Contains a summary of the Deidentify operation.
  --
  -- /See:/ 'newDeidentifySummary' smart constructor.
  data DeidentifySummary = DeidentifySummary
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DeidentifySummary' with the minimum fields required to make a request.
  newDeidentifySummary ::
    DeidentifySummary
  newDeidentifySummary = DeidentifySummary
  
  instance Core.FromJSON DeidentifySummary where
    parseJSON =
      Core.withObject
        "DeidentifySummary"
        (\o -> Core.pure DeidentifySummary)
  
  instance Core.ToJSON DeidentifySummary where
    toJSON = Core.const Core.emptyObject
  
  -- | Specifies the parameters needed for de-identification of DICOM stores.
  --
  -- /See:/ 'newDicomConfig' smart constructor.
  data DicomConfig = DicomConfig
    { -- | Tag filtering profile that determines which tags to keep\/remove.
      filterProfile :: (Core.Maybe DicomConfig_FilterProfile),
      -- | List of tags to keep. Remove all other tags.
      keepList :: (Core.Maybe TagFilterList),
      -- | List of tags to remove. Keep all other tags.
      removeList :: (Core.Maybe TagFilterList),
      -- | Optional. If true, skip replacing StudyInstanceUID, SeriesInstanceUID, SOPInstanceUID, and MediaStorageSOPInstanceUID and leave them untouched. The Cloud Healthcare API regenerates these UIDs by default based on the DICOM Standard\'s reasoning: \"Whilst these UIDs cannot be mapped directly to an individual out of context, given access to the original images, or to a database of the original images containing the UIDs, it would be possible to recover the individual\'s identity.\" http:\/\/dicom.nema.org\/medical\/dicom\/current\/output\/chtml\/part15\/sect_E.3.9.html
      skipIdRedaction :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DicomConfig' with the minimum fields required to make a request.
  newDicomConfig ::
    DicomConfig
  newDicomConfig =
    DicomConfig
      { filterProfile = Core.Nothing,
        keepList = Core.Nothing,
        removeList = Core.Nothing,
        skipIdRedaction = Core.Nothing
      }
  
  instance Core.FromJSON DicomConfig where
    parseJSON =
      Core.withObject
        "DicomConfig"
        ( \o ->
            DicomConfig
              Core.<$> (o Core..:? "filterProfile")
              Core.<*> (o Core..:? "keepList")
              Core.<*> (o Core..:? "removeList")
              Core.<*> (o Core..:? "skipIdRedaction")
        )
  
  instance Core.ToJSON DicomConfig where
    toJSON DicomConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("filterProfile" Core..=) Core.<$> filterProfile,
              ("keepList" Core..=) Core.<$> keepList,
              ("removeList" Core..=) Core.<$> removeList,
              ("skipIdRedaction" Core..=) Core.<$> skipIdRedaction
            ]
        )
  
  -- | Specifies the filter configuration for DICOM resources.
  --
  -- /See:/ 'newDicomFilterConfig' smart constructor.
  newtype DicomFilterConfig = DicomFilterConfig
    { -- | The Cloud Storage location of the filter configuration file. The @gcs_uri@ must be in the format @gs:\/\/bucket\/path\/to\/object@. The filter configuration file must contain a list of resource paths separated by newline characters (\\n or \\r\\n). Each resource path must be in the format \"\/studies\/{studyUID}[\/series\/{seriesUID}[\/instances\/{instanceUID}]]\" The Cloud Healthcare API service account must have the @roles\/storage.objectViewer@ Cloud IAM role for this Cloud Storage location.
      resourcePathsGcsUri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DicomFilterConfig' with the minimum fields required to make a request.
  newDicomFilterConfig ::
    DicomFilterConfig
  newDicomFilterConfig =
    DicomFilterConfig {resourcePathsGcsUri = Core.Nothing}
  
  instance Core.FromJSON DicomFilterConfig where
    parseJSON =
      Core.withObject
        "DicomFilterConfig"
        ( \o ->
            DicomFilterConfig Core.<$> (o Core..:? "resourcePathsGcsUri")
        )
  
  instance Core.ToJSON DicomFilterConfig where
    toJSON DicomFilterConfig {..} =
      Core.object
        ( Core.catMaybes
            [("resourcePathsGcsUri" Core..=) Core.<$> resourcePathsGcsUri]
        )
  
  -- | Represents a DICOM store.
  --
  -- /See:/ 'newDicomStore' smart constructor.
  data DicomStore = DicomStore
    { -- | User-supplied key-value pairs used to organize DICOM stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
      labels :: (Core.Maybe DicomStore_Labels),
      -- | Identifier. Resource name of the DICOM store, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/dicomStores\/{dicom_store_id}@.
      name :: (Core.Maybe Core.Text),
      -- | Optional. Notification destination for new DICOM instances. Supplied by the client.
      notificationConfig :: (Core.Maybe NotificationConfig),
      -- | Optional. A list of streaming configs used to configure the destination of streaming exports for every DICOM instance insertion in this DICOM store. After a new config is added to @stream_configs@, DICOM instance insertions are streamed to the new destination. When a config is removed from @stream_configs@, the server stops streaming to that destination. Each config must contain a unique destination.
      streamConfigs :: (Core.Maybe [GoogleCloudHealthcareV1DicomStreamConfig])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DicomStore' with the minimum fields required to make a request.
  newDicomStore ::
    DicomStore
  newDicomStore =
    DicomStore
      { labels = Core.Nothing,
        name = Core.Nothing,
        notificationConfig = Core.Nothing,
        streamConfigs = Core.Nothing
      }
  
  instance Core.FromJSON DicomStore where
    parseJSON =
      Core.withObject
        "DicomStore"
        ( \o ->
            DicomStore
              Core.<$> (o Core..:? "labels")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "notificationConfig")
              Core.<*> (o Core..:? "streamConfigs")
        )
  
  instance Core.ToJSON DicomStore where
    toJSON DicomStore {..} =
      Core.object
        ( Core.catMaybes
            [ ("labels" Core..=) Core.<$> labels,
              ("name" Core..=) Core.<$> name,
              ("notificationConfig" Core..=) Core.<$> notificationConfig,
              ("streamConfigs" Core..=) Core.<$> streamConfigs
            ]
        )
  
  -- | User-supplied key-value pairs used to organize DICOM stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
  --
  -- /See:/ 'newDicomStore_Labels' smart constructor.
  newtype DicomStore_Labels = DicomStore_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DicomStore_Labels' with the minimum fields required to make a request.
  newDicomStore_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    DicomStore_Labels
  newDicomStore_Labels additional =
    DicomStore_Labels {additional = additional}
  
  instance Core.FromJSON DicomStore_Labels where
    parseJSON =
      Core.withObject
        "DicomStore_Labels"
        (\o -> DicomStore_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON DicomStore_Labels where
    toJSON DicomStore_Labels {..} = Core.toJSON additional
  
  -- | DicomStoreMetrics contains metrics describing a DICOM store.
  --
  -- /See:/ 'newDicomStoreMetrics' smart constructor.
  data DicomStoreMetrics = DicomStoreMetrics
    { -- | Total blob storage bytes for all instances in the store.
      blobStorageSizeBytes :: (Core.Maybe Core.Int64),
      -- | Number of instances in the store.
      instanceCount :: (Core.Maybe Core.Int64),
      -- | Resource name of the DICOM store, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/dicomStores\/{dicom_store_id}@.
      name :: (Core.Maybe Core.Text),
      -- | Number of series in the store.
      seriesCount :: (Core.Maybe Core.Int64),
      -- | Total structured storage bytes for all instances in the store.
      structuredStorageSizeBytes :: (Core.Maybe Core.Int64),
      -- | Number of studies in the store.
      studyCount :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DicomStoreMetrics' with the minimum fields required to make a request.
  newDicomStoreMetrics ::
    DicomStoreMetrics
  newDicomStoreMetrics =
    DicomStoreMetrics
      { blobStorageSizeBytes = Core.Nothing,
        instanceCount = Core.Nothing,
        name = Core.Nothing,
        seriesCount = Core.Nothing,
        structuredStorageSizeBytes = Core.Nothing,
        studyCount = Core.Nothing
      }
  
  instance Core.FromJSON DicomStoreMetrics where
    parseJSON =
      Core.withObject
        "DicomStoreMetrics"
        ( \o ->
            DicomStoreMetrics
              Core.<$> ( o
                           Core..:? "blobStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "instanceCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "seriesCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> ( o
                           Core..:? "structuredStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "studyCount" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON DicomStoreMetrics where
    toJSON DicomStoreMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("blobStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> blobStorageSizeBytes,
              ("instanceCount" Core..=)
                Core.. Core.AsText
                Core.<$> instanceCount,
              ("name" Core..=) Core.<$> name,
              ("seriesCount" Core..=) Core.. Core.AsText Core.<$> seriesCount,
              ("structuredStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> structuredStorageSizeBytes,
              ("studyCount" Core..=) Core.. Core.AsText Core.<$> studyCount
            ]
        )
  
  -- | 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
  
  -- | Represents a customer-managed encryption key spec that can be applied to a resource.
  --
  -- /See:/ 'newEncryptionSpec' smart constructor.
  newtype EncryptionSpec = EncryptionSpec
    { -- | Required. The resource name of customer-managed encryption key that is used to secure a resource and its sub-resources. Only the key in the same location as this Dataset is allowed to be used for encryption. Format is: @projects\/{project}\/locations\/{location}\/keyRings\/{keyRing}\/cryptoKeys\/{key}@
      kmsKeyName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EncryptionSpec' with the minimum fields required to make a request.
  newEncryptionSpec ::
    EncryptionSpec
  newEncryptionSpec = EncryptionSpec {kmsKeyName = Core.Nothing}
  
  instance Core.FromJSON EncryptionSpec where
    parseJSON =
      Core.withObject
        "EncryptionSpec"
        (\o -> EncryptionSpec Core.<$> (o Core..:? "kmsKeyName"))
  
  instance Core.ToJSON EncryptionSpec where
    toJSON EncryptionSpec {..} =
      Core.object
        (Core.catMaybes [("kmsKeyName" Core..=) Core.<$> kmsKeyName])
  
  -- | The candidate entities that an entity mention could link to.
  --
  -- /See:/ 'newEntity' smart constructor.
  data Entity = Entity
    { -- | entity/id is a first class field entity/id uniquely identifies this concept and its meta-vocabulary. For example, \"UMLS\/C0000970\".
      entityId :: (Core.Maybe Core.Text),
      -- | preferred_term is the preferred term for this concept. For example, \"Acetaminophen\". For ad hoc entities formed by normalization, this is the most popular unnormalized string.
      preferredTerm :: (Core.Maybe Core.Text),
      -- | Vocabulary codes are first-class fields and differentiated from the concept unique identifier (entity/id). vocabulary/codes contains the representation of this concept in particular vocabularies, such as ICD-10, SNOMED-CT and RxNORM. These are prefixed by the name of the vocabulary, followed by the unique code within that vocabulary. For example, \"RXNORM\/A10334543\".
      vocabularyCodes :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Entity' with the minimum fields required to make a request.
  newEntity ::
    Entity
  newEntity =
    Entity
      { entityId = Core.Nothing,
        preferredTerm = Core.Nothing,
        vocabularyCodes = Core.Nothing
      }
  
  instance Core.FromJSON Entity where
    parseJSON =
      Core.withObject
        "Entity"
        ( \o ->
            Entity
              Core.<$> (o Core..:? "entityId")
              Core.<*> (o Core..:? "preferredTerm")
              Core.<*> (o Core..:? "vocabularyCodes")
        )
  
  instance Core.ToJSON Entity where
    toJSON Entity {..} =
      Core.object
        ( Core.catMaybes
            [ ("entityId" Core..=) Core.<$> entityId,
              ("preferredTerm" Core..=) Core.<$> preferredTerm,
              ("vocabularyCodes" Core..=) Core.<$> vocabularyCodes
            ]
        )
  
  -- | An entity mention in the document.
  --
  -- /See:/ 'newEntityMention' smart constructor.
  data EntityMention = EntityMention
    { -- | The certainty assessment of the entity mention. Its value is one of: LIKELY, SOMEWHAT/LIKELY, UNCERTAIN, SOMEWHAT/UNLIKELY, UNLIKELY, CONDITIONAL
      certaintyAssessment :: (Core.Maybe Feature),
      -- | The model\'s confidence in this entity mention annotation. A number between 0 and 1.
      confidence :: (Core.Maybe Core.Double),
      -- | linked_entities are candidate ontological concepts that this entity mention may refer to. They are sorted by decreasing confidence.
      linkedEntities :: (Core.Maybe [LinkedEntity]),
      -- | mention_id uniquely identifies each entity mention in a single response.
      mentionId :: (Core.Maybe Core.Text),
      -- | The subject this entity mention relates to. Its value is one of: PATIENT, FAMILY_MEMBER, OTHER
      subject :: (Core.Maybe Feature),
      -- | How this entity mention relates to the subject temporally. Its value is one of: CURRENT, CLINICAL/HISTORY, FAMILY/HISTORY, UPCOMING, ALLERGY
      temporalAssessment :: (Core.Maybe Feature),
      -- | text is the location of the entity mention in the document.
      text :: (Core.Maybe TextSpan),
      -- | The semantic type of the entity: UNKNOWN/ENTITY/TYPE, ALONE, ANATOMICAL/STRUCTURE, ASSISTED/LIVING, BF/RESULT, BM/RESULT, BM/UNIT, BM/VALUE, BODY/FUNCTION, BODY/MEASUREMENT, COMPLIANT, DOESNOT/FOLLOWUP, FAMILY, FOLLOWSUP, LABORATORY/DATA, LAB/RESULT, LAB/UNIT, LAB/VALUE, MEDICAL/DEVICE, MEDICINE, MED/DOSE, MED/DURATION, MED/FORM, MED/FREQUENCY, MED/ROUTE, MED/STATUS, MED/STRENGTH, MED/TOTALDOSE, MED/UNIT, NON/COMPLIANT, OTHER/LIVINGSTATUS, PROBLEM, PROCEDURE, PROCEDURE/RESULT, PROC/METHOD, REASON/FOR/NONCOMPLIANCE, SEVERITY, SUBSTANCE/ABUSE, UNCLEAR_FOLLOWUP.
      type' :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EntityMention' with the minimum fields required to make a request.
  newEntityMention ::
    EntityMention
  newEntityMention =
    EntityMention
      { certaintyAssessment = Core.Nothing,
        confidence = Core.Nothing,
        linkedEntities = Core.Nothing,
        mentionId = Core.Nothing,
        subject = Core.Nothing,
        temporalAssessment = Core.Nothing,
        text = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON EntityMention where
    parseJSON =
      Core.withObject
        "EntityMention"
        ( \o ->
            EntityMention
              Core.<$> (o Core..:? "certaintyAssessment")
              Core.<*> (o Core..:? "confidence")
              Core.<*> (o Core..:? "linkedEntities")
              Core.<*> (o Core..:? "mentionId")
              Core.<*> (o Core..:? "subject")
              Core.<*> (o Core..:? "temporalAssessment")
              Core.<*> (o Core..:? "text")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON EntityMention where
    toJSON EntityMention {..} =
      Core.object
        ( Core.catMaybes
            [ ("certaintyAssessment" Core..=) Core.<$> certaintyAssessment,
              ("confidence" Core..=) Core.<$> confidence,
              ("linkedEntities" Core..=) Core.<$> linkedEntities,
              ("mentionId" Core..=) Core.<$> mentionId,
              ("subject" Core..=) Core.<$> subject,
              ("temporalAssessment" Core..=) Core.<$> temporalAssessment,
              ("text" Core..=) Core.<$> text,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Defines directed relationship from one entity mention to another.
  --
  -- /See:/ 'newEntityMentionRelationship' smart constructor.
  data EntityMentionRelationship = EntityMentionRelationship
    { -- | The model\'s confidence in this annotation. A number between 0 and 1.
      confidence :: (Core.Maybe Core.Double),
      -- | object_id is the id of the object entity mention.
      objectId :: (Core.Maybe Core.Text),
      -- | subject_id is the id of the subject entity mention.
      subjectId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EntityMentionRelationship' with the minimum fields required to make a request.
  newEntityMentionRelationship ::
    EntityMentionRelationship
  newEntityMentionRelationship =
    EntityMentionRelationship
      { confidence = Core.Nothing,
        objectId = Core.Nothing,
        subjectId = Core.Nothing
      }
  
  instance Core.FromJSON EntityMentionRelationship where
    parseJSON =
      Core.withObject
        "EntityMentionRelationship"
        ( \o ->
            EntityMentionRelationship
              Core.<$> (o Core..:? "confidence")
              Core.<*> (o Core..:? "objectId")
              Core.<*> (o Core..:? "subjectId")
        )
  
  instance Core.ToJSON EntityMentionRelationship where
    toJSON EntityMentionRelationship {..} =
      Core.object
        ( Core.catMaybes
            [ ("confidence" Core..=) Core.<$> confidence,
              ("objectId" Core..=) Core.<$> objectId,
              ("subjectId" Core..=) Core.<$> subjectId
            ]
        )
  
  -- | Evaluate a user\'s Consents for all matching User data mappings. Note: User data mappings are indexed asynchronously, causing slight delays between the time mappings are created or updated and when they are included in EvaluateUserConsents results.
  --
  -- /See:/ 'newEvaluateUserConsentsRequest' smart constructor.
  data EvaluateUserConsentsRequest = EvaluateUserConsentsRequest
    { -- | Optional. Specific Consents to evaluate the access request against. These Consents must have the same @user_id@ as the User data mappings being evalauted, must exist in the current @consent_store@, and must have a @state@ of either @ACTIVE@ or @DRAFT@. A maximum of 100 Consents can be provided here. If unspecified, all @ACTIVE@ unexpired Consents in the current @consent_store@ will be evaluated.
      consentList :: (Core.Maybe ConsentList),
      -- | Optional. Limit on the number of User data mappings to return in a single response. If not specified, 100 is used. May not be larger than 1000.
      pageSize :: (Core.Maybe Core.Int32),
      -- | Optional. Token to retrieve the next page of results, or empty to get the first page.
      pageToken :: (Core.Maybe Core.Text),
      -- | Required. The values of request attributes associated with this access request.
      requestAttributes :: (Core.Maybe EvaluateUserConsentsRequest_RequestAttributes),
      -- | Optional. The values of resource attributes associated with the resources being requested. If no values are specified, then all resources are queried.
      resourceAttributes :: (Core.Maybe EvaluateUserConsentsRequest_ResourceAttributes),
      -- | Optional. The view for EvaluateUserConsentsResponse. If unspecified, defaults to @BASIC@ and returns @consented@ as @TRUE@ or @FALSE@.
      responseView :: (Core.Maybe EvaluateUserConsentsRequest_ResponseView),
      -- | Required. User ID to evaluate consents for.
      userId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EvaluateUserConsentsRequest' with the minimum fields required to make a request.
  newEvaluateUserConsentsRequest ::
    EvaluateUserConsentsRequest
  newEvaluateUserConsentsRequest =
    EvaluateUserConsentsRequest
      { consentList = Core.Nothing,
        pageSize = Core.Nothing,
        pageToken = Core.Nothing,
        requestAttributes = Core.Nothing,
        resourceAttributes = Core.Nothing,
        responseView = Core.Nothing,
        userId = Core.Nothing
      }
  
  instance Core.FromJSON EvaluateUserConsentsRequest where
    parseJSON =
      Core.withObject
        "EvaluateUserConsentsRequest"
        ( \o ->
            EvaluateUserConsentsRequest
              Core.<$> (o Core..:? "consentList")
              Core.<*> (o Core..:? "pageSize")
              Core.<*> (o Core..:? "pageToken")
              Core.<*> (o Core..:? "requestAttributes")
              Core.<*> (o Core..:? "resourceAttributes")
              Core.<*> (o Core..:? "responseView")
              Core.<*> (o Core..:? "userId")
        )
  
  instance Core.ToJSON EvaluateUserConsentsRequest where
    toJSON EvaluateUserConsentsRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentList" Core..=) Core.<$> consentList,
              ("pageSize" Core..=) Core.<$> pageSize,
              ("pageToken" Core..=) Core.<$> pageToken,
              ("requestAttributes" Core..=) Core.<$> requestAttributes,
              ("resourceAttributes" Core..=) Core.<$> resourceAttributes,
              ("responseView" Core..=) Core.<$> responseView,
              ("userId" Core..=) Core.<$> userId
            ]
        )
  
  -- | Required. The values of request attributes associated with this access request.
  --
  -- /See:/ 'newEvaluateUserConsentsRequest_RequestAttributes' smart constructor.
  newtype EvaluateUserConsentsRequest_RequestAttributes = EvaluateUserConsentsRequest_RequestAttributes
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EvaluateUserConsentsRequest_RequestAttributes' with the minimum fields required to make a request.
  newEvaluateUserConsentsRequest_RequestAttributes ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    EvaluateUserConsentsRequest_RequestAttributes
  newEvaluateUserConsentsRequest_RequestAttributes additional =
    EvaluateUserConsentsRequest_RequestAttributes
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      EvaluateUserConsentsRequest_RequestAttributes
    where
    parseJSON =
      Core.withObject
        "EvaluateUserConsentsRequest_RequestAttributes"
        ( \o ->
            EvaluateUserConsentsRequest_RequestAttributes
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON EvaluateUserConsentsRequest_RequestAttributes where
    toJSON EvaluateUserConsentsRequest_RequestAttributes {..} =
      Core.toJSON additional
  
  -- | Optional. The values of resource attributes associated with the resources being requested. If no values are specified, then all resources are queried.
  --
  -- /See:/ 'newEvaluateUserConsentsRequest_ResourceAttributes' smart constructor.
  newtype EvaluateUserConsentsRequest_ResourceAttributes = EvaluateUserConsentsRequest_ResourceAttributes
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EvaluateUserConsentsRequest_ResourceAttributes' with the minimum fields required to make a request.
  newEvaluateUserConsentsRequest_ResourceAttributes ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    EvaluateUserConsentsRequest_ResourceAttributes
  newEvaluateUserConsentsRequest_ResourceAttributes additional =
    EvaluateUserConsentsRequest_ResourceAttributes
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      EvaluateUserConsentsRequest_ResourceAttributes
    where
    parseJSON =
      Core.withObject
        "EvaluateUserConsentsRequest_ResourceAttributes"
        ( \o ->
            EvaluateUserConsentsRequest_ResourceAttributes
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON EvaluateUserConsentsRequest_ResourceAttributes where
    toJSON EvaluateUserConsentsRequest_ResourceAttributes {..} =
      Core.toJSON additional
  
  --
  -- /See:/ 'newEvaluateUserConsentsResponse' smart constructor.
  data EvaluateUserConsentsResponse = EvaluateUserConsentsResponse
    { -- | Token to retrieve the next page of results, or empty if there are no more results in the list. This token is valid for 72 hours after it is created.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The consent evaluation result for each @data_id@.
      results :: (Core.Maybe [Result])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EvaluateUserConsentsResponse' with the minimum fields required to make a request.
  newEvaluateUserConsentsResponse ::
    EvaluateUserConsentsResponse
  newEvaluateUserConsentsResponse =
    EvaluateUserConsentsResponse
      { nextPageToken = Core.Nothing,
        results = Core.Nothing
      }
  
  instance Core.FromJSON EvaluateUserConsentsResponse where
    parseJSON =
      Core.withObject
        "EvaluateUserConsentsResponse"
        ( \o ->
            EvaluateUserConsentsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "results")
        )
  
  instance Core.ToJSON EvaluateUserConsentsResponse where
    toJSON EvaluateUserConsentsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("results" Core..=) Core.<$> results
            ]
        )
  
  -- | The enforcing consent\'s metadata.
  --
  -- /See:/ 'newExplainDataAccessConsentInfo' smart constructor.
  data ExplainDataAccessConsentInfo = ExplainDataAccessConsentInfo
    { -- | The compartment base resources that matched a cascading policy. Each resource has the following format: @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/{resource_type}\/{resource_id}@
      cascadeOrigins :: (Core.Maybe [Core.Text]),
      -- | The resource name of this consent resource, in the format: @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Consent\/{resource_id}@.
      consentResource :: (Core.Maybe Core.Text),
      -- | Last enforcement timestamp of this consent resource.
      enforcementTime :: (Core.Maybe Core.DateTime),
      -- | A list of all the matching accessor scopes of this consent policy that enforced ExplainDataAccessConsentScope.accessor_scope.
      matchingAccessorScopes :: (Core.Maybe [ConsentAccessorScope]),
      -- | The patient owning the consent (only applicable for patient consents), in the format: @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}\/fhir\/Patient\/{patient_id}@
      patientConsentOwner :: (Core.Maybe Core.Text),
      -- | The policy type of consent resource (e.g. PATIENT, ADMIN).
      type' :: (Core.Maybe ExplainDataAccessConsentInfo_Type),
      -- | The consent\'s variant combinations. A single consent may have multiple variants.
      variants :: (Core.Maybe [ExplainDataAccessConsentInfo_VariantsItem])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExplainDataAccessConsentInfo' with the minimum fields required to make a request.
  newExplainDataAccessConsentInfo ::
    ExplainDataAccessConsentInfo
  newExplainDataAccessConsentInfo =
    ExplainDataAccessConsentInfo
      { cascadeOrigins = Core.Nothing,
        consentResource = Core.Nothing,
        enforcementTime = Core.Nothing,
        matchingAccessorScopes = Core.Nothing,
        patientConsentOwner = Core.Nothing,
        type' = Core.Nothing,
        variants = Core.Nothing
      }
  
  instance Core.FromJSON ExplainDataAccessConsentInfo where
    parseJSON =
      Core.withObject
        "ExplainDataAccessConsentInfo"
        ( \o ->
            ExplainDataAccessConsentInfo
              Core.<$> (o Core..:? "cascadeOrigins")
              Core.<*> (o Core..:? "consentResource")
              Core.<*> (o Core..:? "enforcementTime")
              Core.<*> (o Core..:? "matchingAccessorScopes")
              Core.<*> (o Core..:? "patientConsentOwner")
              Core.<*> (o Core..:? "type")
              Core.<*> (o Core..:? "variants")
        )
  
  instance Core.ToJSON ExplainDataAccessConsentInfo where
    toJSON ExplainDataAccessConsentInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("cascadeOrigins" Core..=) Core.<$> cascadeOrigins,
              ("consentResource" Core..=) Core.<$> consentResource,
              ("enforcementTime" Core..=) Core.<$> enforcementTime,
              ("matchingAccessorScopes" Core..=) Core.<$> matchingAccessorScopes,
              ("patientConsentOwner" Core..=) Core.<$> patientConsentOwner,
              ("type" Core..=) Core.<$> type',
              ("variants" Core..=) Core.<$> variants
            ]
        )
  
  -- | A single consent scope that provides info on who has access to the requested resource scope for a particular purpose and environment, enforced by which consent.
  --
  -- /See:/ 'newExplainDataAccessConsentScope' smart constructor.
  data ExplainDataAccessConsentScope = ExplainDataAccessConsentScope
    { -- | The accessor scope that describes who can access, for what purpose, and in which environment.
      accessorScope :: (Core.Maybe ConsentAccessorScope),
      -- | Whether the current consent scope is permitted or denied access on the requested resource.
      decision :: (Core.Maybe ExplainDataAccessConsentScope_Decision),
      -- | Metadata of the consent resources that enforce the consent scope\'s access.
      enforcingConsents :: (Core.Maybe [ExplainDataAccessConsentInfo]),
      -- | Other consent scopes that created exceptions within this scope.
      exceptions :: (Core.Maybe [ExplainDataAccessConsentScope])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExplainDataAccessConsentScope' with the minimum fields required to make a request.
  newExplainDataAccessConsentScope ::
    ExplainDataAccessConsentScope
  newExplainDataAccessConsentScope =
    ExplainDataAccessConsentScope
      { accessorScope = Core.Nothing,
        decision = Core.Nothing,
        enforcingConsents = Core.Nothing,
        exceptions = Core.Nothing
      }
  
  instance Core.FromJSON ExplainDataAccessConsentScope where
    parseJSON =
      Core.withObject
        "ExplainDataAccessConsentScope"
        ( \o ->
            ExplainDataAccessConsentScope
              Core.<$> (o Core..:? "accessorScope")
              Core.<*> (o Core..:? "decision")
              Core.<*> (o Core..:? "enforcingConsents")
              Core.<*> (o Core..:? "exceptions")
        )
  
  instance Core.ToJSON ExplainDataAccessConsentScope where
    toJSON ExplainDataAccessConsentScope {..} =
      Core.object
        ( Core.catMaybes
            [ ("accessorScope" Core..=) Core.<$> accessorScope,
              ("decision" Core..=) Core.<$> decision,
              ("enforcingConsents" Core..=) Core.<$> enforcingConsents,
              ("exceptions" Core..=) Core.<$> exceptions
            ]
        )
  
  -- | List of consent scopes that are applicable to the explained access on a given resource.
  --
  -- /See:/ 'newExplainDataAccessResponse' smart constructor.
  data ExplainDataAccessResponse = ExplainDataAccessResponse
    { -- | List of applicable consent scopes. Sorted in order of actor such that scopes belonging to the same actor will be adjacent to each other in the list.
      consentScopes :: (Core.Maybe [ExplainDataAccessConsentScope]),
      -- | Warnings associated with this response. It inform user with exceeded scope limit errors.
      warning :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExplainDataAccessResponse' with the minimum fields required to make a request.
  newExplainDataAccessResponse ::
    ExplainDataAccessResponse
  newExplainDataAccessResponse =
    ExplainDataAccessResponse
      { consentScopes = Core.Nothing,
        warning = Core.Nothing
      }
  
  instance Core.FromJSON ExplainDataAccessResponse where
    parseJSON =
      Core.withObject
        "ExplainDataAccessResponse"
        ( \o ->
            ExplainDataAccessResponse
              Core.<$> (o Core..:? "consentScopes")
              Core.<*> (o Core..:? "warning")
        )
  
  instance Core.ToJSON ExplainDataAccessResponse where
    toJSON ExplainDataAccessResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentScopes" Core..=) Core.<$> consentScopes,
              ("warning" Core..=) Core.<$> warning
            ]
        )
  
  -- | Exports data from the specified DICOM store. If a given resource, such as a DICOM object with the same SOPInstance UID, already exists in the output, it is overwritten with the version in the source dataset. Exported DICOM data persists when the DICOM store from which it was exported is deleted.
  --
  -- /See:/ 'newExportDicomDataRequest' smart constructor.
  data ExportDicomDataRequest = ExportDicomDataRequest
    { -- | The BigQuery output destination. You can only export to a BigQuery dataset that\'s in the same project as the DICOM store you\'re exporting from. The Cloud Healthcare Service Agent requires two IAM roles on the BigQuery location: @roles\/bigquery.dataEditor@ and @roles\/bigquery.jobUser@.
      bigqueryDestination :: (Core.Maybe GoogleCloudHealthcareV1DicomBigQueryDestination),
      -- | The Cloud Storage output destination. The Cloud Healthcare Service Agent requires the @roles\/storage.objectAdmin@ Cloud IAM roles on the Cloud Storage location.
      gcsDestination :: (Core.Maybe GoogleCloudHealthcareV1DicomGcsDestination)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExportDicomDataRequest' with the minimum fields required to make a request.
  newExportDicomDataRequest ::
    ExportDicomDataRequest
  newExportDicomDataRequest =
    ExportDicomDataRequest
      { bigqueryDestination = Core.Nothing,
        gcsDestination = Core.Nothing
      }
  
  instance Core.FromJSON ExportDicomDataRequest where
    parseJSON =
      Core.withObject
        "ExportDicomDataRequest"
        ( \o ->
            ExportDicomDataRequest
              Core.<$> (o Core..:? "bigqueryDestination")
              Core.<*> (o Core..:? "gcsDestination")
        )
  
  instance Core.ToJSON ExportDicomDataRequest where
    toJSON ExportDicomDataRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("bigqueryDestination" Core..=) Core.<$> bigqueryDestination,
              ("gcsDestination" Core..=) Core.<$> gcsDestination
            ]
        )
  
  -- | Returns additional information in regards to a completed DICOM store export.
  --
  -- /See:/ 'newExportDicomDataResponse' smart constructor.
  data ExportDicomDataResponse = ExportDicomDataResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExportDicomDataResponse' with the minimum fields required to make a request.
  newExportDicomDataResponse ::
    ExportDicomDataResponse
  newExportDicomDataResponse = ExportDicomDataResponse
  
  instance Core.FromJSON ExportDicomDataResponse where
    parseJSON =
      Core.withObject
        "ExportDicomDataResponse"
        (\o -> Core.pure ExportDicomDataResponse)
  
  instance Core.ToJSON ExportDicomDataResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | Request to schedule an export.
  --
  -- /See:/ 'newExportMessagesRequest' smart constructor.
  data ExportMessagesRequest = ExportMessagesRequest
    { -- | The end of the range in @send_time@ (MSH.7, https:\/\/www.hl7.org\/documentcenter\/public/temp/2E58C1F9-1C23-BA17-0C6126475344DA9D\/wg\/conf\/HL7MSH.htm) to process. If not specified, the time when the export is scheduled is used. This value has to come after the @start_time@ defined below. Only messages whose @send_time@ lies in the range @start_time@ (inclusive) to @end_time@ (exclusive) are exported.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Restricts messages exported to those matching a filter, only applicable to PubsubDestination and GcsDestination. The following syntax is available: * A string field value can be written as text inside quotation marks, for example @\"query text\"@. The only valid relational operation for text fields is equality (@=@), where text is searched within the field, rather than having the field be equal to the text. For example, @\"Comment = great\"@ returns messages with @great@ in the comment field. * A number field value can be written as an integer, a decimal, or an exponential. The valid relational operators for number fields are the equality operator (@=@), along with the less than\/greater than operators (@\<@, @\<=@, @>@, @>=@). Note that there is no inequality (@!=@) operator. You can prepend the @NOT@ operator to an expression to negate it. * A date field value must be written in the @yyyy-mm-dd@ format. Fields with date and time use the RFC3339 time format. Leading zeros are required for one-digit months
      -- and days. The valid relational operators for date fields are the equality operator (@=@) , along with the less than\/greater than operators (@\<@, @\<=@, @>@, @>=@). Note that there is no inequality (@!=@) operator. You can prepend the @NOT@ operator to an expression to negate it. * Multiple field query expressions can be combined in one query by adding @AND@ or @OR@ operators between the expressions. If a boolean operator appears within a quoted string, it is not treated as special, and is just another part of the character string to be matched. You can prepend the @NOT@ operator to an expression to negate it. The following fields and functions are available for filtering: * @message_type@, from the MSH-9.1 field. For example, @NOT message_type = \"ADT\"@. * @send_date@ or @sendDate@, the @yyyy-mm-dd@ date the message was sent in the dataset\'s time_zone, from the MSH-7 segment. For example, @send_date \< \"2017-01-02\"@. * @send_time@, the timestamp when the message was sent, using the RFC3339 time format
      -- for comparisons, from the MSH-7 segment. For example, @send_time \< \"2017-01-02T00:00:00-05:00\"@. * @create_time@, the timestamp when the message was created in the HL7v2 store. Use the RFC3339 time format for comparisons. For example, @create_time \< \"2017-01-02T00:00:00-05:00\"@. * @send_facility@, the care center that the message came from, from the MSH-4 segment. For example, @send_facility = \"ABC\"@. Note: The filter will be applied to every message in the HL7v2 store whose @send_time@ lies in the range defined by the @start_time@ and the @end_time@. Even if the filter only matches a small set of messages, the export operation can still take a long time to finish when a lot of messages are between the specified @start_time@ and @end_time@ range.
      filter :: (Core.Maybe Core.Text),
      -- | Export to a Cloud Storage destination.
      gcsDestination :: (Core.Maybe GcsDestination),
      -- | Export messages to a Pub\/Sub topic.
      pubsubDestination :: (Core.Maybe PubsubDestination),
      -- | The start of the range in @send_time@ (MSH.7, https:\/\/www.hl7.org\/documentcenter\/public/temp/2E58C1F9-1C23-BA17-0C6126475344DA9D\/wg\/conf\/HL7MSH.htm) to process. If not specified, the UNIX epoch (1970-01-01T00:00:00Z) is used. This value has to come before the @end_time@ defined below. Only messages whose @send_time@ lies in the range @start_time@ (inclusive) to @end_time@ (exclusive) are exported.
      startTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExportMessagesRequest' with the minimum fields required to make a request.
  newExportMessagesRequest ::
    ExportMessagesRequest
  newExportMessagesRequest =
    ExportMessagesRequest
      { endTime = Core.Nothing,
        filter = Core.Nothing,
        gcsDestination = Core.Nothing,
        pubsubDestination = Core.Nothing,
        startTime = Core.Nothing
      }
  
  instance Core.FromJSON ExportMessagesRequest where
    parseJSON =
      Core.withObject
        "ExportMessagesRequest"
        ( \o ->
            ExportMessagesRequest
              Core.<$> (o Core..:? "endTime")
              Core.<*> (o Core..:? "filter")
              Core.<*> (o Core..:? "gcsDestination")
              Core.<*> (o Core..:? "pubsubDestination")
              Core.<*> (o Core..:? "startTime")
        )
  
  instance Core.ToJSON ExportMessagesRequest where
    toJSON ExportMessagesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("endTime" Core..=) Core.<$> endTime,
              ("filter" Core..=) Core.<$> filter,
              ("gcsDestination" Core..=) Core.<$> gcsDestination,
              ("pubsubDestination" Core..=) Core.<$> pubsubDestination,
              ("startTime" Core..=) Core.<$> startTime
            ]
        )
  
  -- | Final response for the export operation. This structure is included in the response to describe the detailed outcome.
  --
  -- /See:/ 'newExportMessagesResponse' smart constructor.
  data ExportMessagesResponse = ExportMessagesResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExportMessagesResponse' with the minimum fields required to make a request.
  newExportMessagesResponse ::
    ExportMessagesResponse
  newExportMessagesResponse = ExportMessagesResponse
  
  instance Core.FromJSON ExportMessagesResponse where
    parseJSON =
      Core.withObject
        "ExportMessagesResponse"
        (\o -> Core.pure ExportMessagesResponse)
  
  instance Core.ToJSON ExportMessagesResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | Request to export resources.
  --
  -- /See:/ 'newExportResourcesRequest' smart constructor.
  data ExportResourcesRequest = ExportResourcesRequest
    { -- | If provided, only resources updated after this time are exported. The time uses the format YYYY-MM-DDThh:mm:ss.sss+zz:zz. For example, @2015-02-07T13:28:17.239+02:00@ or @2017-01-01T00:00:00Z@. The time must be specified to the second and include a time zone.
      since :: (Core.Maybe Core.Text),
      -- | String of comma-delimited FHIR resource types. If provided, only resources of the specified resource type(s) are exported.
      type' :: (Core.Maybe Core.Text),
      -- | The BigQuery output destination. The Cloud Healthcare Service Agent requires two IAM roles on the BigQuery location: @roles\/bigquery.dataEditor@ and @roles\/bigquery.jobUser@. The output is one BigQuery table per resource type. Unlike when setting @BigQueryDestination@ for @StreamConfig@, @ExportResources@ does not create BigQuery views.
      bigqueryDestination :: (Core.Maybe GoogleCloudHealthcareV1FhirBigQueryDestination),
      -- | The Cloud Storage output destination. The Healthcare Service Agent account requires the @roles\/storage.objectAdmin@ role on the Cloud Storage location. The exported outputs are organized by FHIR resource types. The server creates one object per resource type. Each object contains newline delimited JSON, and each line is a FHIR resource.
      gcsDestination :: (Core.Maybe GoogleCloudHealthcareV1FhirGcsDestination)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExportResourcesRequest' with the minimum fields required to make a request.
  newExportResourcesRequest ::
    ExportResourcesRequest
  newExportResourcesRequest =
    ExportResourcesRequest
      { since = Core.Nothing,
        type' = Core.Nothing,
        bigqueryDestination = Core.Nothing,
        gcsDestination = Core.Nothing
      }
  
  instance Core.FromJSON ExportResourcesRequest where
    parseJSON =
      Core.withObject
        "ExportResourcesRequest"
        ( \o ->
            ExportResourcesRequest
              Core.<$> (o Core..:? "_since")
              Core.<*> (o Core..:? "_type")
              Core.<*> (o Core..:? "bigqueryDestination")
              Core.<*> (o Core..:? "gcsDestination")
        )
  
  instance Core.ToJSON ExportResourcesRequest where
    toJSON ExportResourcesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("_since" Core..=) Core.<$> since,
              ("_type" Core..=) Core.<$> type',
              ("bigqueryDestination" Core..=) Core.<$> bigqueryDestination,
              ("gcsDestination" Core..=) Core.<$> gcsDestination
            ]
        )
  
  -- | Response when all resources export successfully. This structure is included in the response to describe the detailed outcome after the operation finishes successfully.
  --
  -- /See:/ 'newExportResourcesResponse' smart constructor.
  data ExportResourcesResponse = ExportResourcesResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExportResourcesResponse' with the minimum fields required to make a request.
  newExportResourcesResponse ::
    ExportResourcesResponse
  newExportResourcesResponse = ExportResourcesResponse
  
  instance Core.FromJSON ExportResourcesResponse where
    parseJSON =
      Core.withObject
        "ExportResourcesResponse"
        (\o -> Core.pure ExportResourcesResponse)
  
  instance Core.ToJSON ExportResourcesResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | 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
            ]
        )
  
  -- | A feature of an entity mention.
  --
  -- /See:/ 'newFeature' smart constructor.
  data Feature = Feature
    { -- | The model\'s confidence in this feature annotation. A number between 0 and 1.
      confidence :: (Core.Maybe Core.Double),
      -- | The value of this feature annotation. Its range depends on the type of the feature.
      value :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Feature' with the minimum fields required to make a request.
  newFeature ::
    Feature
  newFeature =
    Feature {confidence = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON Feature where
    parseJSON =
      Core.withObject
        "Feature"
        ( \o ->
            Feature
              Core.<$> (o Core..:? "confidence")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON Feature where
    toJSON Feature {..} =
      Core.object
        ( Core.catMaybes
            [ ("confidence" Core..=) Core.<$> confidence,
              ("value" Core..=) Core.<$> value
            ]
        )
  
  -- | Specifies how to handle de-identification of a FHIR store.
  --
  -- /See:/ 'newFhirConfig' smart constructor.
  data FhirConfig = FhirConfig
    { -- | Optional. The behaviour for handling FHIR extensions that aren\'t otherwise specified for de-identification. If true, all extensions are preserved during de-identification by default. If false or unspecified, all extensions are removed during de-identification by default.
      defaultKeepExtensions :: (Core.Maybe Core.Bool),
      -- | Optional. Specifies FHIR paths to match and how to transform them. Any field that is not matched by a FieldMetadata is passed through to the output dataset unmodified. All extensions will be processed according to @default_keep_extensions@.
      fieldMetadataList :: (Core.Maybe [FieldMetadata])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FhirConfig' with the minimum fields required to make a request.
  newFhirConfig ::
    FhirConfig
  newFhirConfig =
    FhirConfig
      { defaultKeepExtensions = Core.Nothing,
        fieldMetadataList = Core.Nothing
      }
  
  instance Core.FromJSON FhirConfig where
    parseJSON =
      Core.withObject
        "FhirConfig"
        ( \o ->
            FhirConfig
              Core.<$> (o Core..:? "defaultKeepExtensions")
              Core.<*> (o Core..:? "fieldMetadataList")
        )
  
  instance Core.ToJSON FhirConfig where
    toJSON FhirConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("defaultKeepExtensions" Core..=) Core.<$> defaultKeepExtensions,
              ("fieldMetadataList" Core..=) Core.<$> fieldMetadataList
            ]
        )
  
  -- | Filter configuration.
  --
  -- /See:/ 'newFhirFilter' smart constructor.
  newtype FhirFilter = FhirFilter
    { -- | List of resources to include in the output. If this list is empty or not specified, all resources are included in the output.
      resources :: (Core.Maybe Resources)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FhirFilter' with the minimum fields required to make a request.
  newFhirFilter ::
    FhirFilter
  newFhirFilter = FhirFilter {resources = Core.Nothing}
  
  instance Core.FromJSON FhirFilter where
    parseJSON =
      Core.withObject
        "FhirFilter"
        (\o -> FhirFilter Core.<$> (o Core..:? "resources"))
  
  instance Core.ToJSON FhirFilter where
    toJSON FhirFilter {..} =
      Core.object
        (Core.catMaybes [("resources" Core..=) Core.<$> resources])
  
  -- | Contains the configuration for FHIR notifications.
  --
  -- /See:/ 'newFhirNotificationConfig' smart constructor.
  data FhirNotificationConfig = FhirNotificationConfig
    { -- | Optional. The <https://cloud.google.com/pubsub/docs/ Pub\/Sub> topic that notifications of changes are published on. Supplied by the client. The notification is a @PubsubMessage@ with the following fields: * @PubsubMessage.Data@ contains the resource name. * @PubsubMessage.MessageId@ is the ID of this notification. It is guaranteed to be unique within the topic. * @PubsubMessage.PublishTime@ is the time when the message was published. Note that notifications are only sent if the topic is non-empty. <https://cloud.google.com/pubsub/docs/overview#names Topic names> must be scoped to a project. The Cloud Healthcare API service account, service-\@gcp-sa-healthcare.iam.gserviceaccount.com, must have publisher permissions on the given Pub\/Sub topic. Not having adequate permissions causes the calls that send notifications to fail (https:\/\/cloud.google.com\/healthcare-api\/docs\/permissions-healthcare-api-gcp-products#dicom/fhir/and/hl7v2/store/cloud/pubsub_permissions). If a notification can\'t be published to
      -- Pub\/Sub, errors are logged to Cloud Logging. For more information, see <https://cloud.google.com/healthcare-api/docs/how-tos/logging Viewing error logs in Cloud Logging>.
      pubsubTopic :: (Core.Maybe Core.Text),
      -- | Optional. Whether to send full FHIR resource to this Pub\/Sub topic. The default value is false.
      sendFullResource :: (Core.Maybe Core.Bool),
      -- | Optional. Whether to send full FHIR resource to this Pub\/Sub topic for deleting FHIR resource. The default value is false. Note that setting this to true does not guarantee that all previous resources will be sent in the format of full FHIR resource. When a resource change is too large or during heavy traffic, only the resource name will be sent. Clients should always check the \"payloadType\" label from a Pub\/Sub message to determine whether it needs to fetch the full previous resource as a separate operation.
      sendPreviousResourceOnDelete :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FhirNotificationConfig' with the minimum fields required to make a request.
  newFhirNotificationConfig ::
    FhirNotificationConfig
  newFhirNotificationConfig =
    FhirNotificationConfig
      { pubsubTopic = Core.Nothing,
        sendFullResource = Core.Nothing,
        sendPreviousResourceOnDelete = Core.Nothing
      }
  
  instance Core.FromJSON FhirNotificationConfig where
    parseJSON =
      Core.withObject
        "FhirNotificationConfig"
        ( \o ->
            FhirNotificationConfig
              Core.<$> (o Core..:? "pubsubTopic")
              Core.<*> (o Core..:? "sendFullResource")
              Core.<*> (o Core..:? "sendPreviousResourceOnDelete")
        )
  
  instance Core.ToJSON FhirNotificationConfig where
    toJSON FhirNotificationConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("pubsubTopic" Core..=) Core.<$> pubsubTopic,
              ("sendFullResource" Core..=) Core.<$> sendFullResource,
              ("sendPreviousResourceOnDelete" Core..=)
                Core.<$> sendPreviousResourceOnDelete
            ]
        )
  
  -- | Represents a FHIR store.
  --
  -- /See:/ 'newFhirStore' smart constructor.
  data FhirStore = FhirStore
    { -- | Optional. FHIR bulk export exports resources to the specified Cloud Storage destination. A Cloud Storage destination is a URI for a Cloud Storage directory where result files will be written. Only used in the spec-defined bulk $export methods. The Cloud Healthcare Service Agent requires the @roles\/storage.objectAdmin@ Cloud IAM role on the destination.
      bulkExportGcsDestination :: (Core.Maybe BulkExportGcsDestination),
      -- | Optional. Enable parsing of references within complex FHIR data types such as Extensions. If this value is set to ENABLED, then features like referential integrity and Bundle reference rewriting apply to all references. If this flag has not been specified the behavior of the FHIR store will not change, references in complex data types will not be parsed. New stores will have this value set to ENABLED after a notification period. Warning: turning on this flag causes processing existing resources to fail if they contain references to non-existent resources.
      complexDataTypeReferenceParsing :: (Core.Maybe FhirStore_ComplexDataTypeReferenceParsing),
      -- | Optional. Specifies whether this store has consent enforcement. Not available for DSTU2 FHIR version due to absence of Consent resources.
      consentConfig :: (Core.Maybe ConsentConfig),
      -- | Optional. If true, overrides the default search behavior for this FHIR store to @handling=strict@ which returns an error for unrecognized search parameters. If false, uses the FHIR specification default @handling=lenient@ which ignores unrecognized search parameters. The handling can always be changed from the default on an individual API call by setting the HTTP header @Prefer: handling=strict@ or @Prefer: handling=lenient@. Defaults to false.
      defaultSearchHandlingStrict :: (Core.Maybe Core.Bool),
      -- | Immutable. Whether to disable referential integrity in this FHIR store. This field is immutable after FHIR store creation. The default value is false, meaning that the API enforces referential integrity and fails the requests that result in inconsistent state in the FHIR store. When this field is set to true, the API skips referential integrity checks. Consequently, operations that rely on references, such as GetPatientEverything, do not return all the results if broken references exist.
      disableReferentialIntegrity :: (Core.Maybe Core.Bool),
      -- | Immutable. Whether to disable resource versioning for this FHIR store. This field can not be changed after the creation of FHIR store. If set to false, all write operations cause historical versions to be recorded automatically. The historical versions can be fetched through the history APIs, but cannot be updated. If set to true, no historical versions are kept. The server sends errors for attempts to read the historical versions. Defaults to false.
      disableResourceVersioning :: (Core.Maybe Core.Bool),
      -- | Optional. Whether this FHIR store has the <https://www.hl7.org/fhir/capabilitystatement-definitions.html#CapabilityStatement.rest.resource.updateCreate updateCreate capability>. This determines if the client can use an Update operation to create a new resource with a client-specified ID. If false, all IDs are server-assigned through the Create operation and attempts to update a non-existent resource return errors. It is strongly advised not to include or encode any sensitive data such as patient identifiers in client-specified resource IDs. Those IDs are part of the FHIR resource path recorded in Cloud audit logs and Pub\/Sub notifications. Those IDs can also be contained in reference fields within other resources. Defaults to false.
      enableUpdateCreate :: (Core.Maybe Core.Bool),
      -- | User-supplied key-value pairs used to organize FHIR stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
      labels :: (Core.Maybe FhirStore_Labels),
      -- | Output only. Identifier. Resource name of the FHIR store, of the form @projects\/{project_id}\/locations\/{location}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}@.
      name :: (Core.Maybe Core.Text),
      -- | Deprecated. Use @notification_configs@ instead. If non-empty, publish all resource modifications of this FHIR store to this destination. The Pub\/Sub message attributes contain a map with a string describing the action that has triggered the notification. For example, \"action\":\"CreateResource\".
      notificationConfig :: (Core.Maybe NotificationConfig),
      -- | Optional. Specifies where and whether to send notifications upon changes to a FHIR store.
      notificationConfigs :: (Core.Maybe [FhirNotificationConfig]),
      -- | Optional. A list of streaming configs that configure the destinations of streaming export for every resource mutation in this FHIR store. Each store is allowed to have up to 10 streaming configs. After a new config is added, the next resource mutation is streamed to the new location in addition to the existing ones. When a location is removed from the list, the server stops streaming to that location. Before adding a new config, you must add the required <https://cloud.google.com/bigquery/docs/access-control#bigquery.dataEditor bigquery.dataEditor> role to your project\'s __Cloud Healthcare Service Agent__ <https://cloud.google.com/iam/docs/service-accounts service account>. Some lag (typically on the order of dozens of seconds) is expected before the results show up in the streaming destination.
      streamConfigs :: (Core.Maybe [StreamConfig]),
      -- | Optional. Configuration for how to validate incoming FHIR resources against configured profiles.
      validationConfig :: (Core.Maybe ValidationConfig),
      -- | Required. Immutable. The FHIR specification version that this FHIR store supports natively. This field is immutable after store creation. Requests are rejected if they contain FHIR resources of a different version. Version is required for every FHIR store.
      version :: (Core.Maybe FhirStore_Version)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FhirStore' with the minimum fields required to make a request.
  newFhirStore ::
    FhirStore
  newFhirStore =
    FhirStore
      { bulkExportGcsDestination = Core.Nothing,
        complexDataTypeReferenceParsing = Core.Nothing,
        consentConfig = Core.Nothing,
        defaultSearchHandlingStrict = Core.Nothing,
        disableReferentialIntegrity = Core.Nothing,
        disableResourceVersioning = Core.Nothing,
        enableUpdateCreate = Core.Nothing,
        labels = Core.Nothing,
        name = Core.Nothing,
        notificationConfig = Core.Nothing,
        notificationConfigs = Core.Nothing,
        streamConfigs = Core.Nothing,
        validationConfig = Core.Nothing,
        version = Core.Nothing
      }
  
  instance Core.FromJSON FhirStore where
    parseJSON =
      Core.withObject
        "FhirStore"
        ( \o ->
            FhirStore
              Core.<$> (o Core..:? "bulkExportGcsDestination")
              Core.<*> (o Core..:? "complexDataTypeReferenceParsing")
              Core.<*> (o Core..:? "consentConfig")
              Core.<*> (o Core..:? "defaultSearchHandlingStrict")
              Core.<*> (o Core..:? "disableReferentialIntegrity")
              Core.<*> (o Core..:? "disableResourceVersioning")
              Core.<*> (o Core..:? "enableUpdateCreate")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "notificationConfig")
              Core.<*> (o Core..:? "notificationConfigs")
              Core.<*> (o Core..:? "streamConfigs")
              Core.<*> (o Core..:? "validationConfig")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON FhirStore where
    toJSON FhirStore {..} =
      Core.object
        ( Core.catMaybes
            [ ("bulkExportGcsDestination" Core..=)
                Core.<$> bulkExportGcsDestination,
              ("complexDataTypeReferenceParsing" Core..=)
                Core.<$> complexDataTypeReferenceParsing,
              ("consentConfig" Core..=) Core.<$> consentConfig,
              ("defaultSearchHandlingStrict" Core..=)
                Core.<$> defaultSearchHandlingStrict,
              ("disableReferentialIntegrity" Core..=)
                Core.<$> disableReferentialIntegrity,
              ("disableResourceVersioning" Core..=)
                Core.<$> disableResourceVersioning,
              ("enableUpdateCreate" Core..=) Core.<$> enableUpdateCreate,
              ("labels" Core..=) Core.<$> labels,
              ("name" Core..=) Core.<$> name,
              ("notificationConfig" Core..=) Core.<$> notificationConfig,
              ("notificationConfigs" Core..=) Core.<$> notificationConfigs,
              ("streamConfigs" Core..=) Core.<$> streamConfigs,
              ("validationConfig" Core..=) Core.<$> validationConfig,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | User-supplied key-value pairs used to organize FHIR stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
  --
  -- /See:/ 'newFhirStore_Labels' smart constructor.
  newtype FhirStore_Labels = FhirStore_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FhirStore_Labels' with the minimum fields required to make a request.
  newFhirStore_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    FhirStore_Labels
  newFhirStore_Labels additional =
    FhirStore_Labels {additional = additional}
  
  instance Core.FromJSON FhirStore_Labels where
    parseJSON =
      Core.withObject
        "FhirStore_Labels"
        (\o -> FhirStore_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON FhirStore_Labels where
    toJSON FhirStore_Labels {..} = Core.toJSON additional
  
  -- | Count of resources and total storage size by type for a given FHIR store.
  --
  -- /See:/ 'newFhirStoreMetric' smart constructor.
  data FhirStoreMetric = FhirStoreMetric
    { -- | The total count of FHIR resources in the store of this resource type.
      count :: (Core.Maybe Core.Int64),
      -- | The FHIR resource type this metric applies to.
      resourceType :: (Core.Maybe Core.Text),
      -- | The total amount of structured storage used by FHIR resources of this resource type in the store.
      structuredStorageSizeBytes :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FhirStoreMetric' with the minimum fields required to make a request.
  newFhirStoreMetric ::
    FhirStoreMetric
  newFhirStoreMetric =
    FhirStoreMetric
      { count = Core.Nothing,
        resourceType = Core.Nothing,
        structuredStorageSizeBytes = Core.Nothing
      }
  
  instance Core.FromJSON FhirStoreMetric where
    parseJSON =
      Core.withObject
        "FhirStoreMetric"
        ( \o ->
            FhirStoreMetric
              Core.<$> (o Core..:? "count" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "resourceType")
              Core.<*> ( o
                           Core..:? "structuredStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON FhirStoreMetric where
    toJSON FhirStoreMetric {..} =
      Core.object
        ( Core.catMaybes
            [ ("count" Core..=) Core.. Core.AsText Core.<$> count,
              ("resourceType" Core..=) Core.<$> resourceType,
              ("structuredStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> structuredStorageSizeBytes
            ]
        )
  
  -- | List of metrics for a given FHIR store.
  --
  -- /See:/ 'newFhirStoreMetrics' smart constructor.
  data FhirStoreMetrics = FhirStoreMetrics
    { -- | List of FhirStoreMetric by resource type.
      metrics :: (Core.Maybe [FhirStoreMetric]),
      -- | The resource name of the FHIR store to get metrics for, in the format @projects\/{project_id}\/datasets\/{dataset_id}\/fhirStores\/{fhir_store_id}@.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FhirStoreMetrics' with the minimum fields required to make a request.
  newFhirStoreMetrics ::
    FhirStoreMetrics
  newFhirStoreMetrics =
    FhirStoreMetrics {metrics = Core.Nothing, name = Core.Nothing}
  
  instance Core.FromJSON FhirStoreMetrics where
    parseJSON =
      Core.withObject
        "FhirStoreMetrics"
        ( \o ->
            FhirStoreMetrics
              Core.<$> (o Core..:? "metrics")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON FhirStoreMetrics where
    toJSON FhirStoreMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("metrics" Core..=) Core.<$> metrics,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | A (sub) field of a type.
  --
  -- /See:/ 'newField' smart constructor.
  data Field = Field
    { -- | The maximum number of times this field can be repeated. 0 or -1 means unbounded.
      maxOccurs :: (Core.Maybe Core.Int32),
      -- | The minimum number of times this field must be present\/repeated.
      minOccurs :: (Core.Maybe Core.Int32),
      -- | The name of the field. For example, \"PID-1\" or just \"1\".
      name :: (Core.Maybe Core.Text),
      -- | The HL7v2 table this field refers to. For example, PID-15 (Patient\'s Primary Language) usually refers to table \"0296\".
      table :: (Core.Maybe Core.Text),
      -- | The type of this field. A Type with this name must be defined in an Hl7TypesConfig.
      type' :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Field' with the minimum fields required to make a request.
  newField ::
    Field
  newField =
    Field
      { maxOccurs = Core.Nothing,
        minOccurs = Core.Nothing,
        name = Core.Nothing,
        table = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON Field where
    parseJSON =
      Core.withObject
        "Field"
        ( \o ->
            Field
              Core.<$> (o Core..:? "maxOccurs")
              Core.<*> (o Core..:? "minOccurs")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "table")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON Field where
    toJSON Field {..} =
      Core.object
        ( Core.catMaybes
            [ ("maxOccurs" Core..=) Core.<$> maxOccurs,
              ("minOccurs" Core..=) Core.<$> minOccurs,
              ("name" Core..=) Core.<$> name,
              ("table" Core..=) Core.<$> table,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Specifies FHIR paths to match, and how to handle de-identification of matching fields.
  --
  -- /See:/ 'newFieldMetadata' smart constructor.
  data FieldMetadata = FieldMetadata
    { -- | Optional. Deidentify action for one field.
      action :: (Core.Maybe FieldMetadata_Action),
      -- | Optional. List of paths to FHIR fields to be redacted. Each path is a period-separated list where each component is either a field name or FHIR type name, for example: Patient, HumanName. For \"choice\" types (those defined in the FHIR spec with the form: field[x]) we use two separate components. For example, \"deceasedAge.unit\" is matched by \"Deceased.Age.unit\". Supported types are: AdministrativeGenderCode, Base64Binary, Boolean, Code, Date, DateTime, Decimal, HumanName, Id, Instant, Integer, LanguageCode, Markdown, Oid, PositiveInt, String, UnsignedInt, Uri, Uuid, Xhtml.
      paths :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FieldMetadata' with the minimum fields required to make a request.
  newFieldMetadata ::
    FieldMetadata
  newFieldMetadata =
    FieldMetadata {action = Core.Nothing, paths = Core.Nothing}
  
  instance Core.FromJSON FieldMetadata where
    parseJSON =
      Core.withObject
        "FieldMetadata"
        ( \o ->
            FieldMetadata
              Core.<$> (o Core..:? "action")
              Core.<*> (o Core..:? "paths")
        )
  
  instance Core.ToJSON FieldMetadata where
    toJSON FieldMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("action" Core..=) Core.<$> action,
              ("paths" Core..=) Core.<$> paths
            ]
        )
  
  -- | The Cloud Storage output destination. The Cloud Healthcare Service Agent requires the @roles\/storage.objectAdmin@ Cloud IAM roles on the Cloud Storage location.
  --
  -- /See:/ 'newGcsDestination' smart constructor.
  data GcsDestination = GcsDestination
    { -- | The format of the exported HL7v2 message files.
      contentStructure :: (Core.Maybe GcsDestination_ContentStructure),
      -- | Specifies the parts of the Message resource to include in the export. If not specified, FULL is used.
      messageView :: (Core.Maybe GcsDestination_MessageView),
      -- | URI of an existing Cloud Storage directory where the server writes result files, in the format @gs:\/\/{bucket-id}\/{path\/to\/destination\/dir}@. If there is no trailing slash, the service appends one when composing the object path.
      uriPrefix :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GcsDestination' with the minimum fields required to make a request.
  newGcsDestination ::
    GcsDestination
  newGcsDestination =
    GcsDestination
      { contentStructure = Core.Nothing,
        messageView = Core.Nothing,
        uriPrefix = Core.Nothing
      }
  
  instance Core.FromJSON GcsDestination where
    parseJSON =
      Core.withObject
        "GcsDestination"
        ( \o ->
            GcsDestination
              Core.<$> (o Core..:? "contentStructure")
              Core.<*> (o Core..:? "messageView")
              Core.<*> (o Core..:? "uriPrefix")
        )
  
  instance Core.ToJSON GcsDestination where
    toJSON GcsDestination {..} =
      Core.object
        ( Core.catMaybes
            [ ("contentStructure" Core..=) Core.<$> contentStructure,
              ("messageView" Core..=) Core.<$> messageView,
              ("uriPrefix" Core..=) Core.<$> uriPrefix
            ]
        )
  
  -- | Specifies the configuration for importing data from Cloud Storage.
  --
  -- /See:/ 'newGcsSource' smart constructor.
  newtype GcsSource = GcsSource
    { -- | Points to a Cloud Storage URI containing file(s) to import. The URI must be in the following format: @gs:\/\/{bucket_id}\/{object_id}@. The URI can include wildcards in @object_id@ and thus identify multiple files. Supported wildcards: * @*@ to match 0 or more non-separator characters * @**@ to match 0 or more characters (including separators). Must be used at the end of a path and with no other wildcards in the path. Can also be used with a file extension (such as .ndjson), which imports all files with the extension in the specified directory and its sub-directories. For example, @gs:\/\/my-bucket\/my-directory\/**.ndjson@ imports all files with @.ndjson@ extensions in @my-directory\/@ and its sub-directories. * @?@ to match 1 character Files matching the wildcard are expected to contain content only, no metadata.
      uri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GcsSource' with the minimum fields required to make a request.
  newGcsSource ::
    GcsSource
  newGcsSource = GcsSource {uri = Core.Nothing}
  
  instance Core.FromJSON GcsSource where
    parseJSON =
      Core.withObject
        "GcsSource"
        (\o -> GcsSource Core.<$> (o Core..:? "uri"))
  
  instance Core.ToJSON GcsSource where
    toJSON GcsSource {..} =
      Core.object (Core.catMaybes [("uri" Core..=) Core.<$> uri])
  
  -- | The Cloud Storage location for export.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1ConsentGcsDestination' smart constructor.
  newtype GoogleCloudHealthcareV1ConsentGcsDestination = GoogleCloudHealthcareV1ConsentGcsDestination
    { -- | URI for a Cloud Storage directory where the server writes result files, in the format @gs:\/\/{bucket-id}\/{path\/to\/destination\/dir}@. If there is no trailing slash, the service appends one when composing the object path. The user is responsible for creating the Cloud Storage bucket and directory referenced in @uri_prefix@.
      uriPrefix :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1ConsentGcsDestination' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1ConsentGcsDestination ::
    GoogleCloudHealthcareV1ConsentGcsDestination
  newGoogleCloudHealthcareV1ConsentGcsDestination =
    GoogleCloudHealthcareV1ConsentGcsDestination
      { uriPrefix =
          Core.Nothing
      }
  
  instance Core.FromJSON GoogleCloudHealthcareV1ConsentGcsDestination where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1ConsentGcsDestination"
        ( \o ->
            GoogleCloudHealthcareV1ConsentGcsDestination
              Core.<$> (o Core..:? "uriPrefix")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1ConsentGcsDestination where
    toJSON GoogleCloudHealthcareV1ConsentGcsDestination {..} =
      Core.object
        (Core.catMaybes [("uriPrefix" Core..=) Core.<$> uriPrefix])
  
  -- | Represents a user\'s consent in terms of the resources that can be accessed and under what conditions.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1ConsentPolicy' smart constructor.
  data GoogleCloudHealthcareV1ConsentPolicy = GoogleCloudHealthcareV1ConsentPolicy
    { -- | Required. The request conditions to meet to grant access. In addition to any supported comparison operators, authorization rules may have @IN@ operator as well as at most 10 logical operators that are limited to @AND@ (@&&@), @OR@ (@||@).
      authorizationRule :: (Core.Maybe Expr),
      -- | The resources that this policy applies to. A resource is a match if it matches all the attributes listed here. If empty, this policy applies to all User data mappings for the given user.
      resourceAttributes :: (Core.Maybe [Attribute])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1ConsentPolicy' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1ConsentPolicy ::
    GoogleCloudHealthcareV1ConsentPolicy
  newGoogleCloudHealthcareV1ConsentPolicy =
    GoogleCloudHealthcareV1ConsentPolicy
      { authorizationRule =
          Core.Nothing,
        resourceAttributes = Core.Nothing
      }
  
  instance Core.FromJSON GoogleCloudHealthcareV1ConsentPolicy where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1ConsentPolicy"
        ( \o ->
            GoogleCloudHealthcareV1ConsentPolicy
              Core.<$> (o Core..:? "authorizationRule")
              Core.<*> (o Core..:? "resourceAttributes")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1ConsentPolicy where
    toJSON GoogleCloudHealthcareV1ConsentPolicy {..} =
      Core.object
        ( Core.catMaybes
            [ ("authorizationRule" Core..=) Core.<$> authorizationRule,
              ("resourceAttributes" Core..=) Core.<$> resourceAttributes
            ]
        )
  
  -- | Contains a summary of the DeidentifyDicomStore operation.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary' smart constructor.
  data GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary = GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary ::
    GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary
  newGoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary =
    GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary
  
  instance
    Core.FromJSON
      GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary
    where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary"
        ( \o ->
            Core.pure
              GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary
        )
  
  instance
    Core.ToJSON
      GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary
    where
    toJSON = Core.const Core.emptyObject
  
  -- | Contains a summary of the DeidentifyFhirStore operation.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary' smart constructor.
  data GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary = GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary ::
    GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary
  newGoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary =
    GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary
  
  instance
    Core.FromJSON
      GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary
    where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary"
        ( \o ->
            Core.pure
              GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary
        )
  
  instance
    Core.ToJSON
      GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary
    where
    toJSON = Core.const Core.emptyObject
  
  -- | The BigQuery table where the server writes the output.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1DicomBigQueryDestination' smart constructor.
  data GoogleCloudHealthcareV1DicomBigQueryDestination = GoogleCloudHealthcareV1DicomBigQueryDestination
    { -- | Optional. Use @write_disposition@ instead. If @write_disposition@ is specified, this parameter is ignored. force=false is equivalent to write/disposition=WRITE/EMPTY and force=true is equivalent to write/disposition=WRITE/TRUNCATE.
      force :: (Core.Maybe Core.Bool),
      -- | Optional. BigQuery URI to a table, up to 2000 characters long, in the format @bq:\/\/projectId.bqDatasetId.tableId@
      tableUri :: (Core.Maybe Core.Text),
      -- | Optional. Determines whether the existing table in the destination is to be overwritten or appended to. If a write_disposition is specified, the @force@ parameter is ignored.
      writeDisposition ::
        ( Core.Maybe
            GoogleCloudHealthcareV1DicomBigQueryDestination_WriteDisposition
        )
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1DicomBigQueryDestination' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1DicomBigQueryDestination ::
    GoogleCloudHealthcareV1DicomBigQueryDestination
  newGoogleCloudHealthcareV1DicomBigQueryDestination =
    GoogleCloudHealthcareV1DicomBigQueryDestination
      { force =
          Core.Nothing,
        tableUri = Core.Nothing,
        writeDisposition = Core.Nothing
      }
  
  instance
    Core.FromJSON
      GoogleCloudHealthcareV1DicomBigQueryDestination
    where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1DicomBigQueryDestination"
        ( \o ->
            GoogleCloudHealthcareV1DicomBigQueryDestination
              Core.<$> (o Core..:? "force")
              Core.<*> (o Core..:? "tableUri")
              Core.<*> (o Core..:? "writeDisposition")
        )
  
  instance
    Core.ToJSON
      GoogleCloudHealthcareV1DicomBigQueryDestination
    where
    toJSON GoogleCloudHealthcareV1DicomBigQueryDestination {..} =
      Core.object
        ( Core.catMaybes
            [ ("force" Core..=) Core.<$> force,
              ("tableUri" Core..=) Core.<$> tableUri,
              ("writeDisposition" Core..=) Core.<$> writeDisposition
            ]
        )
  
  -- | The Cloud Storage location where the server writes the output and the export configuration.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1DicomGcsDestination' smart constructor.
  data GoogleCloudHealthcareV1DicomGcsDestination = GoogleCloudHealthcareV1DicomGcsDestination
    { -- | MIME types supported by DICOM spec. Each file is written in the following format: @...\/{study_id}\/{series_id}\/{instance_id}[\/{frame_number}].{extension}@ The frame/number component exists only for multi-frame instances. Supported MIME types are consistent with supported formats in DICOMweb: https:\/\/cloud.google.com\/healthcare\/docs\/dicom#retrieve/transaction. Specifically, the following are supported: - application\/dicom; transfer-syntax=1.2.840.10008.1.2.1 (uncompressed DICOM) - application\/dicom; transfer-syntax=1.2.840.10008.1.2.4.50 (DICOM with embedded JPEG Baseline) - application\/dicom; transfer-syntax=1.2.840.10008.1.2.4.90 (DICOM with embedded JPEG 2000 Lossless Only) - application\/dicom; transfer-syntax=1.2.840.10008.1.2.4.91 (DICOM with embedded JPEG 2000) - application\/dicom; transfer-syntax=* (DICOM with no transcoding) - application\/octet-stream; transfer-syntax=1.2.840.10008.1.2.1 (raw uncompressed PixelData) - application\/octet-stream; transfer-syntax=* (raw PixelData in whatever
      -- format it was uploaded in) - image\/jpeg; transfer-syntax=1.2.840.10008.1.2.4.50 (Consumer JPEG) - image\/png The following extensions are used for output files: - application\/dicom -> .dcm - image\/jpeg -> .jpg - image\/png -> .png - application\/octet-stream -> no extension If unspecified, the instances are exported in the original DICOM format they were uploaded in.
      mimeType :: (Core.Maybe Core.Text),
      -- | The Cloud Storage destination to export to. URI for a Cloud Storage directory where the server writes the result files, in the format @gs:\/\/{bucket-id}\/{path\/to\/destination\/dir}@). If there is no trailing slash, the service appends one when composing the object path. The user is responsible for creating the Cloud Storage bucket referenced in @uri_prefix@.
      uriPrefix :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1DicomGcsDestination' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1DicomGcsDestination ::
    GoogleCloudHealthcareV1DicomGcsDestination
  newGoogleCloudHealthcareV1DicomGcsDestination =
    GoogleCloudHealthcareV1DicomGcsDestination
      { mimeType =
          Core.Nothing,
        uriPrefix = Core.Nothing
      }
  
  instance Core.FromJSON GoogleCloudHealthcareV1DicomGcsDestination where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1DicomGcsDestination"
        ( \o ->
            GoogleCloudHealthcareV1DicomGcsDestination
              Core.<$> (o Core..:? "mimeType")
              Core.<*> (o Core..:? "uriPrefix")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1DicomGcsDestination where
    toJSON GoogleCloudHealthcareV1DicomGcsDestination {..} =
      Core.object
        ( Core.catMaybes
            [ ("mimeType" Core..=) Core.<$> mimeType,
              ("uriPrefix" Core..=) Core.<$> uriPrefix
            ]
        )
  
  -- | Specifies the configuration for importing data from Cloud Storage.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1DicomGcsSource' smart constructor.
  newtype GoogleCloudHealthcareV1DicomGcsSource = GoogleCloudHealthcareV1DicomGcsSource
    { -- | Points to a Cloud Storage URI containing file(s) with content only. The URI must be in the following format: @gs:\/\/{bucket_id}\/{object_id}@. The URI can include wildcards in @object_id@ and thus identify multiple files. Supported wildcards: * \'/\' to match 0 or more non-separator characters / \'**\' to match 0 or more characters (including separators). Must be used at the end of a path and with no other wildcards in the path. Can also be used with a file extension (such as .dcm), which imports all files with the extension in the specified directory and its sub-directories. For example, @gs:\/\/my-bucket\/my-directory\/**.dcm@ imports all files with .dcm extensions in @my-directory\/@ and its sub-directories. * \'?\' to match 1 character. All other URI formats are invalid. Files matching the wildcard are expected to contain content only, no metadata.
      uri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1DicomGcsSource' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1DicomGcsSource ::
    GoogleCloudHealthcareV1DicomGcsSource
  newGoogleCloudHealthcareV1DicomGcsSource =
    GoogleCloudHealthcareV1DicomGcsSource {uri = Core.Nothing}
  
  instance Core.FromJSON GoogleCloudHealthcareV1DicomGcsSource where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1DicomGcsSource"
        ( \o ->
            GoogleCloudHealthcareV1DicomGcsSource Core.<$> (o Core..:? "uri")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1DicomGcsSource where
    toJSON GoogleCloudHealthcareV1DicomGcsSource {..} =
      Core.object (Core.catMaybes [("uri" Core..=) Core.<$> uri])
  
  -- | StreamConfig specifies configuration for a streaming DICOM export.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1DicomStreamConfig' smart constructor.
  newtype GoogleCloudHealthcareV1DicomStreamConfig = GoogleCloudHealthcareV1DicomStreamConfig
    { -- | Results are appended to this table. The server creates a new table in the given BigQuery dataset if the specified table does not exist. To enable the Cloud Healthcare API to write to your BigQuery table, you must give the Cloud Healthcare API service account the bigquery.dataEditor role. The service account is: @service-{PROJECT_NUMBER}\@gcp-sa-healthcare.iam.gserviceaccount.com@. The PROJECT_NUMBER identifies the project that the DICOM store resides in. To get the project number, go to the Cloud Console Dashboard. It is recommended to not have a custom schema in the destination table which could conflict with the schema created by the Cloud Healthcare API. Instance deletions are not applied to the destination table. The destination\'s table schema will be automatically updated in case a new instance\'s data is incompatible with the current schema. The schema should not be updated manually as this can cause incompatibilies that cannot be resolved automatically. One resolution in this case is to delete the
      -- incompatible table and let the server recreate one, though the newly created table only contains data after the table recreation. BigQuery imposes a 1 MB limit on streaming insert row size, therefore any instance that generates more than 1 MB of BigQuery data will not be streamed. If an instance cannot be streamed to BigQuery, errors will be logged to Cloud Logging (see <https://cloud.google.com/healthcare/docs/how-tos/logging Viewing error logs in Cloud Logging>).
      bigqueryDestination :: (Core.Maybe GoogleCloudHealthcareV1DicomBigQueryDestination)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1DicomStreamConfig' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1DicomStreamConfig ::
    GoogleCloudHealthcareV1DicomStreamConfig
  newGoogleCloudHealthcareV1DicomStreamConfig =
    GoogleCloudHealthcareV1DicomStreamConfig
      { bigqueryDestination =
          Core.Nothing
      }
  
  instance Core.FromJSON GoogleCloudHealthcareV1DicomStreamConfig where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1DicomStreamConfig"
        ( \o ->
            GoogleCloudHealthcareV1DicomStreamConfig
              Core.<$> (o Core..:? "bigqueryDestination")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1DicomStreamConfig where
    toJSON GoogleCloudHealthcareV1DicomStreamConfig {..} =
      Core.object
        ( Core.catMaybes
            [("bigqueryDestination" Core..=) Core.<$> bigqueryDestination]
        )
  
  -- | The configuration for exporting to BigQuery.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1FhirBigQueryDestination' smart constructor.
  data GoogleCloudHealthcareV1FhirBigQueryDestination = GoogleCloudHealthcareV1FhirBigQueryDestination
    { -- | Optional. BigQuery URI to an existing dataset, up to 2000 characters long, in the format @bq:\/\/projectId.bqDatasetId@.
      datasetUri :: (Core.Maybe Core.Text),
      -- | Optional. The default value is false. If this flag is @TRUE@, all tables are deleted from the dataset before the new exported tables are written. If the flag is not set and the destination dataset contains tables, the export call returns an error. If @write_disposition@ is specified, this parameter is ignored. force=false is equivalent to write/disposition=WRITE/EMPTY and force=true is equivalent to write/disposition=WRITE/TRUNCATE.
      force :: (Core.Maybe Core.Bool),
      -- | Optional. The configuration for the exported BigQuery schema.
      schemaConfig :: (Core.Maybe SchemaConfig),
      -- | Optional. Determines if existing data in the destination dataset is overwritten, appended to, or not written if the tables contain data. If a write_disposition is specified, the @force@ parameter is ignored.
      writeDisposition ::
        ( Core.Maybe
            GoogleCloudHealthcareV1FhirBigQueryDestination_WriteDisposition
        )
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1FhirBigQueryDestination' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1FhirBigQueryDestination ::
    GoogleCloudHealthcareV1FhirBigQueryDestination
  newGoogleCloudHealthcareV1FhirBigQueryDestination =
    GoogleCloudHealthcareV1FhirBigQueryDestination
      { datasetUri =
          Core.Nothing,
        force = Core.Nothing,
        schemaConfig = Core.Nothing,
        writeDisposition = Core.Nothing
      }
  
  instance
    Core.FromJSON
      GoogleCloudHealthcareV1FhirBigQueryDestination
    where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1FhirBigQueryDestination"
        ( \o ->
            GoogleCloudHealthcareV1FhirBigQueryDestination
              Core.<$> (o Core..:? "datasetUri")
              Core.<*> (o Core..:? "force")
              Core.<*> (o Core..:? "schemaConfig")
              Core.<*> (o Core..:? "writeDisposition")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1FhirBigQueryDestination where
    toJSON GoogleCloudHealthcareV1FhirBigQueryDestination {..} =
      Core.object
        ( Core.catMaybes
            [ ("datasetUri" Core..=) Core.<$> datasetUri,
              ("force" Core..=) Core.<$> force,
              ("schemaConfig" Core..=) Core.<$> schemaConfig,
              ("writeDisposition" Core..=) Core.<$> writeDisposition
            ]
        )
  
  -- | The configuration for exporting to Cloud Storage.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1FhirGcsDestination' smart constructor.
  newtype GoogleCloudHealthcareV1FhirGcsDestination = GoogleCloudHealthcareV1FhirGcsDestination
    { -- | URI for a Cloud Storage directory where result files should be written, in the format of @gs:\/\/{bucket-id}\/{path\/to\/destination\/dir}@. If there is no trailing slash, the service appends one when composing the object path. The user is responsible for creating the Cloud Storage bucket referenced in @uri_prefix@.
      uriPrefix :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1FhirGcsDestination' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1FhirGcsDestination ::
    GoogleCloudHealthcareV1FhirGcsDestination
  newGoogleCloudHealthcareV1FhirGcsDestination =
    GoogleCloudHealthcareV1FhirGcsDestination
      { uriPrefix =
          Core.Nothing
      }
  
  instance Core.FromJSON GoogleCloudHealthcareV1FhirGcsDestination where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1FhirGcsDestination"
        ( \o ->
            GoogleCloudHealthcareV1FhirGcsDestination
              Core.<$> (o Core..:? "uriPrefix")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1FhirGcsDestination where
    toJSON GoogleCloudHealthcareV1FhirGcsDestination {..} =
      Core.object
        (Core.catMaybes [("uriPrefix" Core..=) Core.<$> uriPrefix])
  
  -- | Specifies the configuration for importing data from Cloud Storage.
  --
  -- /See:/ 'newGoogleCloudHealthcareV1FhirGcsSource' smart constructor.
  newtype GoogleCloudHealthcareV1FhirGcsSource = GoogleCloudHealthcareV1FhirGcsSource
    { -- | Points to a Cloud Storage URI containing file(s) to import. The URI must be in the following format: @gs:\/\/{bucket_id}\/{object_id}@. The URI can include wildcards in @object_id@ and thus identify multiple files. Supported wildcards: * @*@ to match 0 or more non-separator characters * @**@ to match 0 or more characters (including separators). Must be used at the end of a path and with no other wildcards in the path. Can also be used with a file extension (such as .ndjson), which imports all files with the extension in the specified directory and its sub-directories. For example, @gs:\/\/my-bucket\/my-directory\/**.ndjson@ imports all files with @.ndjson@ extensions in @my-directory\/@ and its sub-directories. * @?@ to match 1 character Files matching the wildcard are expected to contain content only, no metadata.
      uri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleCloudHealthcareV1FhirGcsSource' with the minimum fields required to make a request.
  newGoogleCloudHealthcareV1FhirGcsSource ::
    GoogleCloudHealthcareV1FhirGcsSource
  newGoogleCloudHealthcareV1FhirGcsSource =
    GoogleCloudHealthcareV1FhirGcsSource {uri = Core.Nothing}
  
  instance Core.FromJSON GoogleCloudHealthcareV1FhirGcsSource where
    parseJSON =
      Core.withObject
        "GoogleCloudHealthcareV1FhirGcsSource"
        ( \o ->
            GoogleCloudHealthcareV1FhirGcsSource Core.<$> (o Core..:? "uri")
        )
  
  instance Core.ToJSON GoogleCloudHealthcareV1FhirGcsSource where
    toJSON GoogleCloudHealthcareV1FhirGcsSource {..} =
      Core.object (Core.catMaybes [("uri" Core..=) Core.<$> uri])
  
  -- | Construct representing a logical group or a segment.
  --
  -- /See:/ 'newGroupOrSegment' smart constructor.
  data GroupOrSegment = GroupOrSegment
    { group' :: (Core.Maybe SchemaGroup),
      segment :: (Core.Maybe SchemaSegment)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GroupOrSegment' with the minimum fields required to make a request.
  newGroupOrSegment ::
    GroupOrSegment
  newGroupOrSegment =
    GroupOrSegment {group' = Core.Nothing, segment = Core.Nothing}
  
  instance Core.FromJSON GroupOrSegment where
    parseJSON =
      Core.withObject
        "GroupOrSegment"
        ( \o ->
            GroupOrSegment
              Core.<$> (o Core..:? "group")
              Core.<*> (o Core..:? "segment")
        )
  
  instance Core.ToJSON GroupOrSegment where
    toJSON GroupOrSegment {..} =
      Core.object
        ( Core.catMaybes
            [ ("group" Core..=) Core.<$> group',
              ("segment" Core..=) Core.<$> segment
            ]
        )
  
  -- | Root config message for HL7v2 schema. This contains a schema structure of groups and segments, and filters that determine which messages to apply the schema structure to.
  --
  -- /See:/ 'newHl7SchemaConfig' smart constructor.
  data Hl7SchemaConfig = Hl7SchemaConfig
    { -- | Map from each HL7v2 message type and trigger event pair, such as ADT_A04, to its schema configuration root group.
      messageSchemaConfigs :: (Core.Maybe Hl7SchemaConfig_MessageSchemaConfigs),
      -- | Each VersionSource is tested and only if they all match is the schema used for the message.
      version :: (Core.Maybe [VersionSource])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7SchemaConfig' with the minimum fields required to make a request.
  newHl7SchemaConfig ::
    Hl7SchemaConfig
  newHl7SchemaConfig =
    Hl7SchemaConfig
      { messageSchemaConfigs = Core.Nothing,
        version = Core.Nothing
      }
  
  instance Core.FromJSON Hl7SchemaConfig where
    parseJSON =
      Core.withObject
        "Hl7SchemaConfig"
        ( \o ->
            Hl7SchemaConfig
              Core.<$> (o Core..:? "messageSchemaConfigs")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON Hl7SchemaConfig where
    toJSON Hl7SchemaConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("messageSchemaConfigs" Core..=) Core.<$> messageSchemaConfigs,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | Map from each HL7v2 message type and trigger event pair, such as ADT_A04, to its schema configuration root group.
  --
  -- /See:/ 'newHl7SchemaConfig_MessageSchemaConfigs' smart constructor.
  newtype Hl7SchemaConfig_MessageSchemaConfigs = Hl7SchemaConfig_MessageSchemaConfigs
    { additional :: (Core.HashMap Core.Text SchemaGroup)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7SchemaConfig_MessageSchemaConfigs' with the minimum fields required to make a request.
  newHl7SchemaConfig_MessageSchemaConfigs ::
    -- |  See 'additional'.
    Core.HashMap Core.Text SchemaGroup ->
    Hl7SchemaConfig_MessageSchemaConfigs
  newHl7SchemaConfig_MessageSchemaConfigs additional =
    Hl7SchemaConfig_MessageSchemaConfigs {additional = additional}
  
  instance Core.FromJSON Hl7SchemaConfig_MessageSchemaConfigs where
    parseJSON =
      Core.withObject
        "Hl7SchemaConfig_MessageSchemaConfigs"
        ( \o ->
            Hl7SchemaConfig_MessageSchemaConfigs
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON Hl7SchemaConfig_MessageSchemaConfigs where
    toJSON Hl7SchemaConfig_MessageSchemaConfigs {..} =
      Core.toJSON additional
  
  -- | Root config for HL7v2 datatype definitions for a specific HL7v2 version.
  --
  -- /See:/ 'newHl7TypesConfig' smart constructor.
  data Hl7TypesConfig = Hl7TypesConfig
    { -- | The HL7v2 type definitions.
      type' :: (Core.Maybe [Type]),
      -- | The version selectors that this config applies to. A message must match ALL version sources to apply.
      version :: (Core.Maybe [VersionSource])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7TypesConfig' with the minimum fields required to make a request.
  newHl7TypesConfig ::
    Hl7TypesConfig
  newHl7TypesConfig =
    Hl7TypesConfig {type' = Core.Nothing, version = Core.Nothing}
  
  instance Core.FromJSON Hl7TypesConfig where
    parseJSON =
      Core.withObject
        "Hl7TypesConfig"
        ( \o ->
            Hl7TypesConfig
              Core.<$> (o Core..:? "type")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON Hl7TypesConfig where
    toJSON Hl7TypesConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("type" Core..=) Core.<$> type',
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | Specifies where and whether to send notifications upon changes to a data store.
  --
  -- /See:/ 'newHl7V2NotificationConfig' smart constructor.
  data Hl7V2NotificationConfig = Hl7V2NotificationConfig
    { -- | Optional. Restricts notifications sent for messages matching a filter. If this is empty, all messages are matched. The following syntax is available: * A string field value can be written as text inside quotation marks, for example @\"query text\"@. The only valid relational operation for text fields is equality (@=@), where text is searched within the field, rather than having the field be equal to the text. For example, @\"Comment = great\"@ returns messages with @great@ in the comment field. * A number field value can be written as an integer, a decimal, or an exponential. The valid relational operators for number fields are the equality operator (@=@), along with the less than\/greater than operators (@\<@, @\<=@, @>@, @>=@). Note that there is no inequality (@!=@) operator. You can prepend the @NOT@ operator to an expression to negate it. * A date field value must be written in @yyyy-mm-dd@ form. Fields with date and time use the RFC3339 time format. Leading zeros are required for one-digit months and
      -- days. The valid relational operators for date fields are the equality operator (@=@) , along with the less than\/greater than operators (@\<@, @\<=@, @>@, @>=@). Note that there is no inequality (@!=@) operator. You can prepend the @NOT@ operator to an expression to negate it. * Multiple field query expressions can be combined in one query by adding @AND@ or @OR@ operators between the expressions. If a boolean operator appears within a quoted string, it is not treated as special, it\'s just another part of the character string to be matched. You can prepend the @NOT@ operator to an expression to negate it. The following fields and functions are available for filtering: * @message_type@, from the MSH-9.1 field. For example, @NOT message_type = \"ADT\"@. * @send_date@ or @sendDate@, the YYYY-MM-DD date the message was sent in the dataset\'s time_zone, from the MSH-7 segment. For example, @send_date \< \"2017-01-02\"@. * @send_time@, the timestamp when the message was sent, using the RFC3339 time format for
      -- comparisons, from the MSH-7 segment. For example, @send_time \< \"2017-01-02T00:00:00-05:00\"@. * @create_time@, the timestamp when the message was created in the HL7v2 store. Use the RFC3339 time format for comparisons. For example, @create_time \< \"2017-01-02T00:00:00-05:00\"@. * @send_facility@, the care center that the message came from, from the MSH-4 segment. For example, @send_facility = \"ABC\"@. * @PatientId(value, type)@, which matches if the message lists a patient having an ID of the given value and type in the PID-2, PID-3, or PID-4 segments. For example, @PatientId(\"123456\", \"MRN\")@. * @labels.x@, a string value of the label with key @x@ as set using the Message.labels map. For example, @labels.\"priority\"=\"high\"@. The operator @:*@ can be used to assert the existence of a label. For example, @labels.\"priority\":*@.
      filter :: (Core.Maybe Core.Text),
      -- | The <https://cloud.google.com/pubsub/docs/ Pub\/Sub> topic that notifications of changes are published on. Supplied by the client. The notification is a @PubsubMessage@ with the following fields: * @PubsubMessage.Data@ contains the resource name. * @PubsubMessage.MessageId@ is the ID of this notification. It\'s guaranteed to be unique within the topic. * @PubsubMessage.PublishTime@ is the time when the message was published. Note that notifications are only sent if the topic is non-empty. <https://cloud.google.com/pubsub/docs/overview#names Topic names> must be scoped to a project. The Cloud Healthcare API service account, service-PROJECT_NUMBER\@gcp-sa-healthcare.iam.gserviceaccount.com, must have publisher permissions on the given Pub\/Sub topic. Not having adequate permissions causes the calls that send notifications to fail. If a notification cannot be published to Pub\/Sub, errors are logged to Cloud Logging. For more information, see
      -- <https://cloud.google.com/healthcare/docs/how-tos/logging Viewing error logs in Cloud Logging>).
      pubsubTopic :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7V2NotificationConfig' with the minimum fields required to make a request.
  newHl7V2NotificationConfig ::
    Hl7V2NotificationConfig
  newHl7V2NotificationConfig =
    Hl7V2NotificationConfig
      { filter = Core.Nothing,
        pubsubTopic = Core.Nothing
      }
  
  instance Core.FromJSON Hl7V2NotificationConfig where
    parseJSON =
      Core.withObject
        "Hl7V2NotificationConfig"
        ( \o ->
            Hl7V2NotificationConfig
              Core.<$> (o Core..:? "filter")
              Core.<*> (o Core..:? "pubsubTopic")
        )
  
  instance Core.ToJSON Hl7V2NotificationConfig where
    toJSON Hl7V2NotificationConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("filter" Core..=) Core.<$> filter,
              ("pubsubTopic" Core..=) Core.<$> pubsubTopic
            ]
        )
  
  -- | Represents an HL7v2 store.
  --
  -- /See:/ 'newHl7V2Store' smart constructor.
  data Hl7V2Store = Hl7V2Store
    { -- | User-supplied key-value pairs used to organize HL7v2 stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
      labels :: (Core.Maybe Hl7V2Store_Labels),
      -- | Identifier. Resource name of the HL7v2 store, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/hl7V2Stores\/{hl7v2_store_id}@.
      name :: (Core.Maybe Core.Text),
      -- | Optional. A list of notification configs. Each configuration uses a filter to determine whether to publish a message (both Ingest & Create) on the corresponding notification destination. Only the message name is sent as part of the notification. Supplied by the client.
      notificationConfigs :: (Core.Maybe [Hl7V2NotificationConfig]),
      -- | Optional. The configuration for the parser. It determines how the server parses the messages.
      parserConfig :: (Core.Maybe ParserConfig),
      -- | Optional. Determines whether to reject duplicate messages. A duplicate message is a message with the same raw bytes as a message that has already been ingested\/created in this HL7v2 store. The default value is false, meaning that the store accepts the duplicate messages and it also returns the same ACK message in the IngestMessageResponse as has been returned previously. Note that only one resource is created in the store. When this field is set to true, CreateMessage\/IngestMessage requests with a duplicate message will be rejected by the store, and IngestMessageErrorDetail returns a NACK message upon rejection.
      rejectDuplicateMessage :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7V2Store' with the minimum fields required to make a request.
  newHl7V2Store ::
    Hl7V2Store
  newHl7V2Store =
    Hl7V2Store
      { labels = Core.Nothing,
        name = Core.Nothing,
        notificationConfigs = Core.Nothing,
        parserConfig = Core.Nothing,
        rejectDuplicateMessage = Core.Nothing
      }
  
  instance Core.FromJSON Hl7V2Store where
    parseJSON =
      Core.withObject
        "Hl7V2Store"
        ( \o ->
            Hl7V2Store
              Core.<$> (o Core..:? "labels")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "notificationConfigs")
              Core.<*> (o Core..:? "parserConfig")
              Core.<*> (o Core..:? "rejectDuplicateMessage")
        )
  
  instance Core.ToJSON Hl7V2Store where
    toJSON Hl7V2Store {..} =
      Core.object
        ( Core.catMaybes
            [ ("labels" Core..=) Core.<$> labels,
              ("name" Core..=) Core.<$> name,
              ("notificationConfigs" Core..=) Core.<$> notificationConfigs,
              ("parserConfig" Core..=) Core.<$> parserConfig,
              ("rejectDuplicateMessage" Core..=)
                Core.<$> rejectDuplicateMessage
            ]
        )
  
  -- | User-supplied key-value pairs used to organize HL7v2 stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
  --
  -- /See:/ 'newHl7V2Store_Labels' smart constructor.
  newtype Hl7V2Store_Labels = Hl7V2Store_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7V2Store_Labels' with the minimum fields required to make a request.
  newHl7V2Store_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Hl7V2Store_Labels
  newHl7V2Store_Labels additional =
    Hl7V2Store_Labels {additional = additional}
  
  instance Core.FromJSON Hl7V2Store_Labels where
    parseJSON =
      Core.withObject
        "Hl7V2Store_Labels"
        (\o -> Hl7V2Store_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Hl7V2Store_Labels where
    toJSON Hl7V2Store_Labels {..} = Core.toJSON additional
  
  -- | Count of messages and total storage size by type for a given HL7 store.
  --
  -- /See:/ 'newHl7V2StoreMetric' smart constructor.
  data Hl7V2StoreMetric = Hl7V2StoreMetric
    { -- | The total count of HL7v2 messages in the store for the given message type.
      count :: (Core.Maybe Core.Int64),
      -- | The Hl7v2 message type this metric applies to, such as @ADT@ or @ORU@.
      messageType :: (Core.Maybe Core.Text),
      -- | The total amount of structured storage used by HL7v2 messages of this message type in the store.
      structuredStorageSizeBytes :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7V2StoreMetric' with the minimum fields required to make a request.
  newHl7V2StoreMetric ::
    Hl7V2StoreMetric
  newHl7V2StoreMetric =
    Hl7V2StoreMetric
      { count = Core.Nothing,
        messageType = Core.Nothing,
        structuredStorageSizeBytes = Core.Nothing
      }
  
  instance Core.FromJSON Hl7V2StoreMetric where
    parseJSON =
      Core.withObject
        "Hl7V2StoreMetric"
        ( \o ->
            Hl7V2StoreMetric
              Core.<$> (o Core..:? "count" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "messageType")
              Core.<*> ( o
                           Core..:? "structuredStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON Hl7V2StoreMetric where
    toJSON Hl7V2StoreMetric {..} =
      Core.object
        ( Core.catMaybes
            [ ("count" Core..=) Core.. Core.AsText Core.<$> count,
              ("messageType" Core..=) Core.<$> messageType,
              ("structuredStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> structuredStorageSizeBytes
            ]
        )
  
  -- | List of metrics for a given HL7v2 store.
  --
  -- /See:/ 'newHl7V2StoreMetrics' smart constructor.
  data Hl7V2StoreMetrics = Hl7V2StoreMetrics
    { -- | List of HL7v2 store metrics by message type.
      metrics :: (Core.Maybe [Hl7V2StoreMetric]),
      -- | The resource name of the HL7v2 store to get metrics for, in the format @projects\/{project_id}\/datasets\/{dataset_id}\/hl7V2Stores\/{hl7v2_store_id}@.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Hl7V2StoreMetrics' with the minimum fields required to make a request.
  newHl7V2StoreMetrics ::
    Hl7V2StoreMetrics
  newHl7V2StoreMetrics =
    Hl7V2StoreMetrics {metrics = Core.Nothing, name = Core.Nothing}
  
  instance Core.FromJSON Hl7V2StoreMetrics where
    parseJSON =
      Core.withObject
        "Hl7V2StoreMetrics"
        ( \o ->
            Hl7V2StoreMetrics
              Core.<$> (o Core..:? "metrics")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON Hl7V2StoreMetrics where
    toJSON Hl7V2StoreMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("metrics" Core..=) Core.<$> metrics,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can\'t be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { \/\/ A unique request id. string request/id = 1; \/\/ The raw HTTP body is bound to this field. google.api.HttpBody http/body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream
  -- google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged.
  --
  -- /See:/ 'newHttpBody' smart constructor.
  data HttpBody = HttpBody
    { -- | The HTTP Content-Type header value specifying the content type of the body.
      contentType :: (Core.Maybe Core.Text),
      -- | The HTTP request\/response body as raw binary.
      data' :: (Core.Maybe Core.Base64),
      -- | Application specific response metadata. Must be set in the first response for streaming APIs.
      extensions :: (Core.Maybe [HttpBody_ExtensionsItem])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HttpBody' with the minimum fields required to make a request.
  newHttpBody ::
    HttpBody
  newHttpBody =
    HttpBody
      { contentType = Core.Nothing,
        data' = Core.Nothing,
        extensions = Core.Nothing
      }
  
  instance Core.FromJSON HttpBody where
    parseJSON =
      Core.withObject
        "HttpBody"
        ( \o ->
            HttpBody
              Core.<$> (o Core..:? "contentType")
              Core.<*> (o Core..:? "data")
              Core.<*> (o Core..:? "extensions")
        )
  
  instance Core.ToJSON HttpBody where
    toJSON HttpBody {..} =
      Core.object
        ( Core.catMaybes
            [ ("contentType" Core..=) Core.<$> contentType,
              ("data" Core..=) Core.<$> data',
              ("extensions" Core..=) Core.<$> extensions
            ]
        )
  
  --
  -- /See:/ 'newHttpBody_ExtensionsItem' smart constructor.
  newtype HttpBody_ExtensionsItem = HttpBody_ExtensionsItem
    { -- | 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 'HttpBody_ExtensionsItem' with the minimum fields required to make a request.
  newHttpBody_ExtensionsItem ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    HttpBody_ExtensionsItem
  newHttpBody_ExtensionsItem additional =
    HttpBody_ExtensionsItem {additional = additional}
  
  instance Core.FromJSON HttpBody_ExtensionsItem where
    parseJSON =
      Core.withObject
        "HttpBody_ExtensionsItem"
        (\o -> HttpBody_ExtensionsItem Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON HttpBody_ExtensionsItem where
    toJSON HttpBody_ExtensionsItem {..} = Core.toJSON additional
  
  -- | Raw bytes representing consent artifact content.
  --
  -- /See:/ 'newImage' smart constructor.
  data Image = Image
    { -- | Input only. Points to a Cloud Storage URI containing the consent artifact content. The URI must be in the following format: @gs:\/\/{bucket_id}\/{object_id}@. The Cloud Healthcare API service account must have the @roles\/storage.objectViewer@ Cloud IAM role for this Cloud Storage location. The consent artifact content at this URI is copied to a Cloud Storage location managed by the Cloud Healthcare API. Responses to fetching requests return the consent artifact content in raw_bytes.
      gcsUri :: (Core.Maybe Core.Text),
      -- | Consent artifact content represented as a stream of bytes. This field is populated when returned in GetConsentArtifact response, but not included in CreateConsentArtifact and ListConsentArtifact response.
      rawBytes :: (Core.Maybe Core.Base64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Image' with the minimum fields required to make a request.
  newImage ::
    Image
  newImage = Image {gcsUri = Core.Nothing, rawBytes = Core.Nothing}
  
  instance Core.FromJSON Image where
    parseJSON =
      Core.withObject
        "Image"
        ( \o ->
            Image
              Core.<$> (o Core..:? "gcsUri")
              Core.<*> (o Core..:? "rawBytes")
        )
  
  instance Core.ToJSON Image where
    toJSON Image {..} =
      Core.object
        ( Core.catMaybes
            [ ("gcsUri" Core..=) Core.<$> gcsUri,
              ("rawBytes" Core..=) Core.<$> rawBytes
            ]
        )
  
  -- | Specifies how to handle de-identification of image pixels.
  --
  -- /See:/ 'newImageConfig' smart constructor.
  newtype ImageConfig = ImageConfig
    { -- | Optional. Determines how to redact text from image.
      textRedactionMode :: (Core.Maybe ImageConfig_TextRedactionMode)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImageConfig' with the minimum fields required to make a request.
  newImageConfig ::
    ImageConfig
  newImageConfig = ImageConfig {textRedactionMode = Core.Nothing}
  
  instance Core.FromJSON ImageConfig where
    parseJSON =
      Core.withObject
        "ImageConfig"
        (\o -> ImageConfig Core.<$> (o Core..:? "textRedactionMode"))
  
  instance Core.ToJSON ImageConfig where
    toJSON ImageConfig {..} =
      Core.object
        ( Core.catMaybes
            [("textRedactionMode" Core..=) Core.<$> textRedactionMode]
        )
  
  -- | Imports data into the specified DICOM store. Returns an error if any of the files to import are not DICOM files. This API accepts duplicate DICOM instances by ignoring the newly-pushed instance. It does not overwrite.
  --
  -- /See:/ 'newImportDicomDataRequest' smart constructor.
  data ImportDicomDataRequest = ImportDicomDataRequest
    { -- | Optional. The blob storage settings for the data imported by this operation.
      blobStorageSettings :: (Core.Maybe BlobStorageSettings),
      -- | Cloud Storage source data location and import configuration. The Cloud Healthcare Service Agent requires the @roles\/storage.objectViewer@ Cloud IAM roles on the Cloud Storage location.
      gcsSource :: (Core.Maybe GoogleCloudHealthcareV1DicomGcsSource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImportDicomDataRequest' with the minimum fields required to make a request.
  newImportDicomDataRequest ::
    ImportDicomDataRequest
  newImportDicomDataRequest =
    ImportDicomDataRequest
      { blobStorageSettings = Core.Nothing,
        gcsSource = Core.Nothing
      }
  
  instance Core.FromJSON ImportDicomDataRequest where
    parseJSON =
      Core.withObject
        "ImportDicomDataRequest"
        ( \o ->
            ImportDicomDataRequest
              Core.<$> (o Core..:? "blobStorageSettings")
              Core.<*> (o Core..:? "gcsSource")
        )
  
  instance Core.ToJSON ImportDicomDataRequest where
    toJSON ImportDicomDataRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("blobStorageSettings" Core..=) Core.<$> blobStorageSettings,
              ("gcsSource" Core..=) Core.<$> gcsSource
            ]
        )
  
  -- | Returns additional information in regards to a completed DICOM store import.
  --
  -- /See:/ 'newImportDicomDataResponse' smart constructor.
  data ImportDicomDataResponse = ImportDicomDataResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImportDicomDataResponse' with the minimum fields required to make a request.
  newImportDicomDataResponse ::
    ImportDicomDataResponse
  newImportDicomDataResponse = ImportDicomDataResponse
  
  instance Core.FromJSON ImportDicomDataResponse where
    parseJSON =
      Core.withObject
        "ImportDicomDataResponse"
        (\o -> Core.pure ImportDicomDataResponse)
  
  instance Core.ToJSON ImportDicomDataResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | Request to import messages.
  --
  -- /See:/ 'newImportMessagesRequest' smart constructor.
  newtype ImportMessagesRequest = ImportMessagesRequest
    { -- | Cloud Storage source data location and import configuration. The Cloud Healthcare Service Agent requires the @roles\/storage.objectViewer@ Cloud IAM roles on the Cloud Storage location.
      gcsSource :: (Core.Maybe GcsSource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImportMessagesRequest' with the minimum fields required to make a request.
  newImportMessagesRequest ::
    ImportMessagesRequest
  newImportMessagesRequest =
    ImportMessagesRequest {gcsSource = Core.Nothing}
  
  instance Core.FromJSON ImportMessagesRequest where
    parseJSON =
      Core.withObject
        "ImportMessagesRequest"
        (\o -> ImportMessagesRequest Core.<$> (o Core..:? "gcsSource"))
  
  instance Core.ToJSON ImportMessagesRequest where
    toJSON ImportMessagesRequest {..} =
      Core.object
        (Core.catMaybes [("gcsSource" Core..=) Core.<$> gcsSource])
  
  -- | Final response of importing messages. This structure is included in the response to describe the detailed outcome. It is only included when the operation finishes successfully.
  --
  -- /See:/ 'newImportMessagesResponse' smart constructor.
  data ImportMessagesResponse = ImportMessagesResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImportMessagesResponse' with the minimum fields required to make a request.
  newImportMessagesResponse ::
    ImportMessagesResponse
  newImportMessagesResponse = ImportMessagesResponse
  
  instance Core.FromJSON ImportMessagesResponse where
    parseJSON =
      Core.withObject
        "ImportMessagesResponse"
        (\o -> Core.pure ImportMessagesResponse)
  
  instance Core.ToJSON ImportMessagesResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | Request to import resources.
  --
  -- /See:/ 'newImportResourcesRequest' smart constructor.
  data ImportResourcesRequest = ImportResourcesRequest
    { -- | The content structure in the source location. If not specified, the server treats the input source files as BUNDLE.
      contentStructure :: (Core.Maybe ImportResourcesRequest_ContentStructure),
      -- | Cloud Storage source data location and import configuration. The Healthcare Service Agent account requires the @roles\/storage.objectAdmin@ role on the Cloud Storage location. Each Cloud Storage object should be a text file that contains the format specified in ContentStructure.
      gcsSource :: (Core.Maybe GoogleCloudHealthcareV1FhirGcsSource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImportResourcesRequest' with the minimum fields required to make a request.
  newImportResourcesRequest ::
    ImportResourcesRequest
  newImportResourcesRequest =
    ImportResourcesRequest
      { contentStructure = Core.Nothing,
        gcsSource = Core.Nothing
      }
  
  instance Core.FromJSON ImportResourcesRequest where
    parseJSON =
      Core.withObject
        "ImportResourcesRequest"
        ( \o ->
            ImportResourcesRequest
              Core.<$> (o Core..:? "contentStructure")
              Core.<*> (o Core..:? "gcsSource")
        )
  
  instance Core.ToJSON ImportResourcesRequest where
    toJSON ImportResourcesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("contentStructure" Core..=) Core.<$> contentStructure,
              ("gcsSource" Core..=) Core.<$> gcsSource
            ]
        )
  
  -- | Final response of importing resources. This structure is included in the response to describe the detailed outcome after the operation finishes successfully.
  --
  -- /See:/ 'newImportResourcesResponse' smart constructor.
  data ImportResourcesResponse = ImportResourcesResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImportResourcesResponse' with the minimum fields required to make a request.
  newImportResourcesResponse ::
    ImportResourcesResponse
  newImportResourcesResponse = ImportResourcesResponse
  
  instance Core.FromJSON ImportResourcesResponse where
    parseJSON =
      Core.withObject
        "ImportResourcesResponse"
        (\o -> Core.pure ImportResourcesResponse)
  
  instance Core.ToJSON ImportResourcesResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | A transformation to apply to text that is identified as a specific info_type.
  --
  -- /See:/ 'newInfoTypeTransformation' smart constructor.
  data InfoTypeTransformation = InfoTypeTransformation
    { -- | Config for character mask.
      characterMaskConfig :: (Core.Maybe CharacterMaskConfig),
      -- | Config for crypto hash.
      cryptoHashConfig :: (Core.Maybe CryptoHashConfig),
      -- | Config for date shift.
      dateShiftConfig :: (Core.Maybe DateShiftConfig),
      -- | Optional. InfoTypes to apply this transformation to. If this is not specified, the transformation applies to any info_type.
      infoTypes :: (Core.Maybe [Core.Text]),
      -- | Config for text redaction.
      redactConfig :: (Core.Maybe RedactConfig),
      -- | Config for replace with InfoType.
      replaceWithInfoTypeConfig :: (Core.Maybe ReplaceWithInfoTypeConfig)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'InfoTypeTransformation' with the minimum fields required to make a request.
  newInfoTypeTransformation ::
    InfoTypeTransformation
  newInfoTypeTransformation =
    InfoTypeTransformation
      { characterMaskConfig = Core.Nothing,
        cryptoHashConfig = Core.Nothing,
        dateShiftConfig = Core.Nothing,
        infoTypes = Core.Nothing,
        redactConfig = Core.Nothing,
        replaceWithInfoTypeConfig = Core.Nothing
      }
  
  instance Core.FromJSON InfoTypeTransformation where
    parseJSON =
      Core.withObject
        "InfoTypeTransformation"
        ( \o ->
            InfoTypeTransformation
              Core.<$> (o Core..:? "characterMaskConfig")
              Core.<*> (o Core..:? "cryptoHashConfig")
              Core.<*> (o Core..:? "dateShiftConfig")
              Core.<*> (o Core..:? "infoTypes")
              Core.<*> (o Core..:? "redactConfig")
              Core.<*> (o Core..:? "replaceWithInfoTypeConfig")
        )
  
  instance Core.ToJSON InfoTypeTransformation where
    toJSON InfoTypeTransformation {..} =
      Core.object
        ( Core.catMaybes
            [ ("characterMaskConfig" Core..=) Core.<$> characterMaskConfig,
              ("cryptoHashConfig" Core..=) Core.<$> cryptoHashConfig,
              ("dateShiftConfig" Core..=) Core.<$> dateShiftConfig,
              ("infoTypes" Core..=) Core.<$> infoTypes,
              ("redactConfig" Core..=) Core.<$> redactConfig,
              ("replaceWithInfoTypeConfig" Core..=)
                Core.<$> replaceWithInfoTypeConfig
            ]
        )
  
  -- | Ingests a message into the specified HL7v2 store.
  --
  -- /See:/ 'newIngestMessageRequest' smart constructor.
  newtype IngestMessageRequest = IngestMessageRequest
    { -- | Required. HL7v2 message to ingest.
      message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IngestMessageRequest' with the minimum fields required to make a request.
  newIngestMessageRequest ::
    IngestMessageRequest
  newIngestMessageRequest =
    IngestMessageRequest {message = Core.Nothing}
  
  instance Core.FromJSON IngestMessageRequest where
    parseJSON =
      Core.withObject
        "IngestMessageRequest"
        (\o -> IngestMessageRequest Core.<$> (o Core..:? "message"))
  
  instance Core.ToJSON IngestMessageRequest where
    toJSON IngestMessageRequest {..} =
      Core.object
        (Core.catMaybes [("message" Core..=) Core.<$> message])
  
  -- | Acknowledges that a message has been ingested into the specified HL7v2 store.
  --
  -- /See:/ 'newIngestMessageResponse' smart constructor.
  data IngestMessageResponse = IngestMessageResponse
    { -- | HL7v2 ACK message.
      hl7Ack :: (Core.Maybe Core.Base64),
      -- | Created message resource.
      message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IngestMessageResponse' with the minimum fields required to make a request.
  newIngestMessageResponse ::
    IngestMessageResponse
  newIngestMessageResponse =
    IngestMessageResponse
      { hl7Ack = Core.Nothing,
        message = Core.Nothing
      }
  
  instance Core.FromJSON IngestMessageResponse where
    parseJSON =
      Core.withObject
        "IngestMessageResponse"
        ( \o ->
            IngestMessageResponse
              Core.<$> (o Core..:? "hl7Ack")
              Core.<*> (o Core..:? "message")
        )
  
  instance Core.ToJSON IngestMessageResponse where
    toJSON IngestMessageResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("hl7Ack" Core..=) Core.<$> hl7Ack,
              ("message" Core..=) Core.<$> message
            ]
        )
  
  -- | Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. The key must grant the Cloud IAM permission @cloudkms.cryptoKeyVersions.useToDecrypt@ to the project\'s Cloud Healthcare Service Agent service account. For more information, see [Creating a wrapped key] (https:\/\/cloud.google.com\/dlp\/docs\/create-wrapped-key).
  --
  -- /See:/ 'newKmsWrappedCryptoKey' smart constructor.
  data KmsWrappedCryptoKey = KmsWrappedCryptoKey
    { -- | Required. The resource name of the KMS CryptoKey to use for unwrapping. For example, @projects\/{project_id}\/locations\/{location_id}\/keyRings\/{keyring}\/cryptoKeys\/{key}@.
      cryptoKey :: (Core.Maybe Core.Text),
      -- | Required. The wrapped data crypto key.
      wrappedKey :: (Core.Maybe Core.Base64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'KmsWrappedCryptoKey' with the minimum fields required to make a request.
  newKmsWrappedCryptoKey ::
    KmsWrappedCryptoKey
  newKmsWrappedCryptoKey =
    KmsWrappedCryptoKey
      { cryptoKey = Core.Nothing,
        wrappedKey = Core.Nothing
      }
  
  instance Core.FromJSON KmsWrappedCryptoKey where
    parseJSON =
      Core.withObject
        "KmsWrappedCryptoKey"
        ( \o ->
            KmsWrappedCryptoKey
              Core.<$> (o Core..:? "cryptoKey")
              Core.<*> (o Core..:? "wrappedKey")
        )
  
  instance Core.ToJSON KmsWrappedCryptoKey where
    toJSON KmsWrappedCryptoKey {..} =
      Core.object
        ( Core.catMaybes
            [ ("cryptoKey" Core..=) Core.<$> cryptoKey,
              ("wrappedKey" Core..=) Core.<$> wrappedKey
            ]
        )
  
  -- | EntityMentions can be linked to multiple entities using a LinkedEntity message lets us add other fields, e.g. confidence.
  --
  -- /See:/ 'newLinkedEntity' smart constructor.
  newtype LinkedEntity = LinkedEntity
    { -- | entity_id is a concept unique identifier. These are prefixed by a string that identifies the entity coding system, followed by the unique identifier within that system. For example, \"UMLS\/C0000970\". This also supports ad hoc entities, which are formed by normalizing entity mention content.
      entityId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LinkedEntity' with the minimum fields required to make a request.
  newLinkedEntity ::
    LinkedEntity
  newLinkedEntity = LinkedEntity {entityId = Core.Nothing}
  
  instance Core.FromJSON LinkedEntity where
    parseJSON =
      Core.withObject
        "LinkedEntity"
        (\o -> LinkedEntity Core.<$> (o Core..:? "entityId"))
  
  instance Core.ToJSON LinkedEntity where
    toJSON LinkedEntity {..} =
      Core.object
        (Core.catMaybes [("entityId" Core..=) Core.<$> entityId])
  
  --
  -- /See:/ 'newListAttributeDefinitionsResponse' smart constructor.
  data ListAttributeDefinitionsResponse = ListAttributeDefinitionsResponse
    { -- | The returned Attribute definitions. The maximum number of attributes returned is determined by the value of page_size in the ListAttributeDefinitionsRequest.
      attributeDefinitions :: (Core.Maybe [AttributeDefinition]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListAttributeDefinitionsResponse' with the minimum fields required to make a request.
  newListAttributeDefinitionsResponse ::
    ListAttributeDefinitionsResponse
  newListAttributeDefinitionsResponse =
    ListAttributeDefinitionsResponse
      { attributeDefinitions =
          Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListAttributeDefinitionsResponse where
    parseJSON =
      Core.withObject
        "ListAttributeDefinitionsResponse"
        ( \o ->
            ListAttributeDefinitionsResponse
              Core.<$> (o Core..:? "attributeDefinitions")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListAttributeDefinitionsResponse where
    toJSON ListAttributeDefinitionsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("attributeDefinitions" Core..=) Core.<$> attributeDefinitions,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  --
  -- /See:/ 'newListConsentArtifactsResponse' smart constructor.
  data ListConsentArtifactsResponse = ListConsentArtifactsResponse
    { -- | The returned Consent artifacts. The maximum number of artifacts returned is determined by the value of page_size in the ListConsentArtifactsRequest.
      consentArtifacts :: (Core.Maybe [ConsentArtifact]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListConsentArtifactsResponse' with the minimum fields required to make a request.
  newListConsentArtifactsResponse ::
    ListConsentArtifactsResponse
  newListConsentArtifactsResponse =
    ListConsentArtifactsResponse
      { consentArtifacts = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListConsentArtifactsResponse where
    parseJSON =
      Core.withObject
        "ListConsentArtifactsResponse"
        ( \o ->
            ListConsentArtifactsResponse
              Core.<$> (o Core..:? "consentArtifacts")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListConsentArtifactsResponse where
    toJSON ListConsentArtifactsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentArtifacts" Core..=) Core.<$> consentArtifacts,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  --
  -- /See:/ 'newListConsentRevisionsResponse' smart constructor.
  data ListConsentRevisionsResponse = ListConsentRevisionsResponse
    { -- | The returned Consent revisions. The maximum number of revisions returned is determined by the value of @page_size@ in the ListConsentRevisionsRequest.
      consents :: (Core.Maybe [Consent]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListConsentRevisionsResponse' with the minimum fields required to make a request.
  newListConsentRevisionsResponse ::
    ListConsentRevisionsResponse
  newListConsentRevisionsResponse =
    ListConsentRevisionsResponse
      { consents = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListConsentRevisionsResponse where
    parseJSON =
      Core.withObject
        "ListConsentRevisionsResponse"
        ( \o ->
            ListConsentRevisionsResponse
              Core.<$> (o Core..:? "consents")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListConsentRevisionsResponse where
    toJSON ListConsentRevisionsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("consents" Core..=) Core.<$> consents,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  --
  -- /See:/ 'newListConsentStoresResponse' smart constructor.
  data ListConsentStoresResponse = ListConsentStoresResponse
    { -- | The returned consent stores. The maximum number of stores returned is determined by the value of page_size in the ListConsentStoresRequest.
      consentStores :: (Core.Maybe [ConsentStore]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListConsentStoresResponse' with the minimum fields required to make a request.
  newListConsentStoresResponse ::
    ListConsentStoresResponse
  newListConsentStoresResponse =
    ListConsentStoresResponse
      { consentStores = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListConsentStoresResponse where
    parseJSON =
      Core.withObject
        "ListConsentStoresResponse"
        ( \o ->
            ListConsentStoresResponse
              Core.<$> (o Core..:? "consentStores")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListConsentStoresResponse where
    toJSON ListConsentStoresResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentStores" Core..=) Core.<$> consentStores,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  --
  -- /See:/ 'newListConsentsResponse' smart constructor.
  data ListConsentsResponse = ListConsentsResponse
    { -- | The returned Consents. The maximum number of Consents returned is determined by the value of page_size in the ListConsentsRequest.
      consents :: (Core.Maybe [Consent]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListConsentsResponse' with the minimum fields required to make a request.
  newListConsentsResponse ::
    ListConsentsResponse
  newListConsentsResponse =
    ListConsentsResponse
      { consents = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListConsentsResponse where
    parseJSON =
      Core.withObject
        "ListConsentsResponse"
        ( \o ->
            ListConsentsResponse
              Core.<$> (o Core..:? "consents")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListConsentsResponse where
    toJSON ListConsentsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("consents" Core..=) Core.<$> consents,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Lists the available datasets.
  --
  -- /See:/ 'newListDatasetsResponse' smart constructor.
  data ListDatasetsResponse = ListDatasetsResponse
    { -- | The first page of datasets.
      datasets :: (Core.Maybe [Dataset]),
      -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListDatasetsResponse' with the minimum fields required to make a request.
  newListDatasetsResponse ::
    ListDatasetsResponse
  newListDatasetsResponse =
    ListDatasetsResponse
      { datasets = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListDatasetsResponse where
    parseJSON =
      Core.withObject
        "ListDatasetsResponse"
        ( \o ->
            ListDatasetsResponse
              Core.<$> (o Core..:? "datasets")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListDatasetsResponse where
    toJSON ListDatasetsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("datasets" Core..=) Core.<$> datasets,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Lists the DICOM stores in the given dataset.
  --
  -- /See:/ 'newListDicomStoresResponse' smart constructor.
  data ListDicomStoresResponse = ListDicomStoresResponse
    { -- | The returned DICOM stores. Won\'t be more DICOM stores than the value of page_size in the request.
      dicomStores :: (Core.Maybe [DicomStore]),
      -- | Token to retrieve the next page of results or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListDicomStoresResponse' with the minimum fields required to make a request.
  newListDicomStoresResponse ::
    ListDicomStoresResponse
  newListDicomStoresResponse =
    ListDicomStoresResponse
      { dicomStores = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListDicomStoresResponse where
    parseJSON =
      Core.withObject
        "ListDicomStoresResponse"
        ( \o ->
            ListDicomStoresResponse
              Core.<$> (o Core..:? "dicomStores")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListDicomStoresResponse where
    toJSON ListDicomStoresResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("dicomStores" Core..=) Core.<$> dicomStores,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Lists the FHIR stores in the given dataset.
  --
  -- /See:/ 'newListFhirStoresResponse' smart constructor.
  data ListFhirStoresResponse = ListFhirStoresResponse
    { -- | The returned FHIR stores. Won\'t be more FHIR stores than the value of page_size in the request.
      fhirStores :: (Core.Maybe [FhirStore]),
      -- | Token to retrieve the next page of results or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListFhirStoresResponse' with the minimum fields required to make a request.
  newListFhirStoresResponse ::
    ListFhirStoresResponse
  newListFhirStoresResponse =
    ListFhirStoresResponse
      { fhirStores = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListFhirStoresResponse where
    parseJSON =
      Core.withObject
        "ListFhirStoresResponse"
        ( \o ->
            ListFhirStoresResponse
              Core.<$> (o Core..:? "fhirStores")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListFhirStoresResponse where
    toJSON ListFhirStoresResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("fhirStores" Core..=) Core.<$> fhirStores,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Lists the HL7v2 stores in the given dataset.
  --
  -- /See:/ 'newListHl7V2StoresResponse' smart constructor.
  data ListHl7V2StoresResponse = ListHl7V2StoresResponse
    { -- | The returned HL7v2 stores. Won\'t be more HL7v2 stores than the value of page_size in the request.
      hl7V2Stores :: (Core.Maybe [Hl7V2Store]),
      -- | Token to retrieve the next page of results or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListHl7V2StoresResponse' with the minimum fields required to make a request.
  newListHl7V2StoresResponse ::
    ListHl7V2StoresResponse
  newListHl7V2StoresResponse =
    ListHl7V2StoresResponse
      { hl7V2Stores = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListHl7V2StoresResponse where
    parseJSON =
      Core.withObject
        "ListHl7V2StoresResponse"
        ( \o ->
            ListHl7V2StoresResponse
              Core.<$> (o Core..:? "hl7V2Stores")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListHl7V2StoresResponse where
    toJSON ListHl7V2StoresResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("hl7V2Stores" Core..=) Core.<$> hl7V2Stores,
              ("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
            ]
        )
  
  -- | Lists the messages in the specified HL7v2 store.
  --
  -- /See:/ 'newListMessagesResponse' smart constructor.
  data ListMessagesResponse = ListMessagesResponse
    { -- | The returned Messages. Won\'t be more Messages than the value of page_size in the request. See view for populated fields.
      hl7V2Messages :: (Core.Maybe [Message]),
      -- | Token to retrieve the next page of results or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListMessagesResponse' with the minimum fields required to make a request.
  newListMessagesResponse ::
    ListMessagesResponse
  newListMessagesResponse =
    ListMessagesResponse
      { hl7V2Messages = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListMessagesResponse where
    parseJSON =
      Core.withObject
        "ListMessagesResponse"
        ( \o ->
            ListMessagesResponse
              Core.<$> (o Core..:? "hl7V2Messages")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListMessagesResponse where
    toJSON ListMessagesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("hl7V2Messages" Core..=) Core.<$> hl7V2Messages,
              ("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
            ]
        )
  
  --
  -- /See:/ 'newListUserDataMappingsResponse' smart constructor.
  data ListUserDataMappingsResponse = ListUserDataMappingsResponse
    { -- | Token to retrieve the next page of results, or empty if there are no more results in the list.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The returned User data mappings. The maximum number of User data mappings returned is determined by the value of page_size in the ListUserDataMappingsRequest.
      userDataMappings :: (Core.Maybe [UserDataMapping])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListUserDataMappingsResponse' with the minimum fields required to make a request.
  newListUserDataMappingsResponse ::
    ListUserDataMappingsResponse
  newListUserDataMappingsResponse =
    ListUserDataMappingsResponse
      { nextPageToken = Core.Nothing,
        userDataMappings = Core.Nothing
      }
  
  instance Core.FromJSON ListUserDataMappingsResponse where
    parseJSON =
      Core.withObject
        "ListUserDataMappingsResponse"
        ( \o ->
            ListUserDataMappingsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "userDataMappings")
        )
  
  instance Core.ToJSON ListUserDataMappingsResponse where
    toJSON ListUserDataMappingsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("userDataMappings" Core..=) Core.<$> userDataMappings
            ]
        )
  
  -- | 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 complete HL7v2 message. See [Introduction to HL7 Standards] (https:\/\/www.hl7.org\/implement\/standards\/index.cfm?ref=common) for details on the standard.
  --
  -- /See:/ 'newMessage' smart constructor.
  data Message = Message
    { -- | Output only. The datetime when the message was created. Set by the server.
      createTime :: (Core.Maybe Core.DateTime),
      -- | Required. Raw message bytes.
      data' :: (Core.Maybe Core.Base64),
      -- | User-supplied key-value pairs used to organize HL7v2 stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
      labels :: (Core.Maybe Message_Labels),
      -- | Output only. The message type for this message. MSH-9.1.
      messageType :: (Core.Maybe Core.Text),
      -- | Output only. Resource name of the Message, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/hl7V2Stores\/{hl7_v2_store_id}\/messages\/{message_id}@.
      name :: (Core.Maybe Core.Text),
      -- | Output only. The parsed version of the raw message data.
      parsedData :: (Core.Maybe ParsedData),
      -- | Output only. All patient IDs listed in the PID-2, PID-3, and PID-4 segments of this message.
      patientIds :: (Core.Maybe [PatientId]),
      -- | Output only. The parsed version of the raw message data schematized according to this store\'s schemas and type definitions.
      schematizedData :: (Core.Maybe SchematizedData),
      -- | Output only. The hospital that this message came from. MSH-4.
      sendFacility :: (Core.Maybe Core.Text),
      -- | Output only. The datetime the sending application sent this message. MSH-7.
      sendTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Message' with the minimum fields required to make a request.
  newMessage ::
    Message
  newMessage =
    Message
      { createTime = Core.Nothing,
        data' = Core.Nothing,
        labels = Core.Nothing,
        messageType = Core.Nothing,
        name = Core.Nothing,
        parsedData = Core.Nothing,
        patientIds = Core.Nothing,
        schematizedData = Core.Nothing,
        sendFacility = Core.Nothing,
        sendTime = Core.Nothing
      }
  
  instance Core.FromJSON Message where
    parseJSON =
      Core.withObject
        "Message"
        ( \o ->
            Message
              Core.<$> (o Core..:? "createTime")
              Core.<*> (o Core..:? "data")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "messageType")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "parsedData")
              Core.<*> (o Core..:? "patientIds")
              Core.<*> (o Core..:? "schematizedData")
              Core.<*> (o Core..:? "sendFacility")
              Core.<*> (o Core..:? "sendTime")
        )
  
  instance Core.ToJSON Message where
    toJSON Message {..} =
      Core.object
        ( Core.catMaybes
            [ ("createTime" Core..=) Core.<$> createTime,
              ("data" Core..=) Core.<$> data',
              ("labels" Core..=) Core.<$> labels,
              ("messageType" Core..=) Core.<$> messageType,
              ("name" Core..=) Core.<$> name,
              ("parsedData" Core..=) Core.<$> parsedData,
              ("patientIds" Core..=) Core.<$> patientIds,
              ("schematizedData" Core..=) Core.<$> schematizedData,
              ("sendFacility" Core..=) Core.<$> sendFacility,
              ("sendTime" Core..=) Core.<$> sendTime
            ]
        )
  
  -- | User-supplied key-value pairs used to organize HL7v2 stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \\p{Ll}\\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} No more than 64 labels can be associated with a given store.
  --
  -- /See:/ 'newMessage_Labels' smart constructor.
  newtype Message_Labels = Message_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Message_Labels' with the minimum fields required to make a request.
  newMessage_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Message_Labels
  newMessage_Labels additional =
    Message_Labels {additional = additional}
  
  instance Core.FromJSON Message_Labels where
    parseJSON =
      Core.withObject
        "Message_Labels"
        (\o -> Message_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Message_Labels where
    toJSON Message_Labels {..} = Core.toJSON additional
  
  -- | Specifies where to send notifications upon changes to a data store.
  --
  -- /See:/ 'newNotificationConfig' smart constructor.
  data NotificationConfig = NotificationConfig
    { -- | The <https://cloud.google.com/pubsub/docs/ Pub\/Sub> topic that notifications of changes are published on. Supplied by the client. PubsubMessage.Data contains the resource name. PubsubMessage.MessageId is the ID of this message. It is guaranteed to be unique within the topic. PubsubMessage.PublishTime is the time at which the message was published. Notifications are only sent if the topic is non-empty. <https://cloud.google.com/pubsub/docs/overview#names Topic names> must be scoped to a project. Cloud Healthcare API service account must have publisher permissions on the given Pub\/Sub topic. Not having adequate permissions causes the calls that send notifications to fail. If a notification can\'t be published to Pub\/Sub, errors are logged to Cloud Logging (see <https://cloud.google.com/healthcare/docs/how-tos/logging Viewing error logs in Cloud Logging>). If the number of errors exceeds a certain rate, some aren\'t submitted. Note that not all operations trigger notifications, see
      -- <https://cloud.google.com/healthcare/docs/how-tos/pubsub Configuring Pub\/Sub notifications> for specific details.
      pubsubTopic :: (Core.Maybe Core.Text),
      -- | Indicates whether or not to send Pub\/Sub notifications on bulk import. Only supported for DICOM imports.
      sendForBulkImport :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'NotificationConfig' with the minimum fields required to make a request.
  newNotificationConfig ::
    NotificationConfig
  newNotificationConfig =
    NotificationConfig
      { pubsubTopic = Core.Nothing,
        sendForBulkImport = Core.Nothing
      }
  
  instance Core.FromJSON NotificationConfig where
    parseJSON =
      Core.withObject
        "NotificationConfig"
        ( \o ->
            NotificationConfig
              Core.<$> (o Core..:? "pubsubTopic")
              Core.<*> (o Core..:? "sendForBulkImport")
        )
  
  instance Core.ToJSON NotificationConfig where
    toJSON NotificationConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("pubsubTopic" Core..=) Core.<$> pubsubTopic,
              ("sendForBulkImport" Core..=) Core.<$> sendForBulkImport
            ]
        )
  
  -- | 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
  
  -- | OperationMetadata provides information about the operation execution. Returned in the long-running operation\'s metadata field.
  --
  -- /See:/ 'newOperationMetadata' smart constructor.
  data OperationMetadata = OperationMetadata
    { -- | The name of the API method that initiated the operation.
      apiMethodName :: (Core.Maybe Core.Text),
      -- | Specifies if cancellation was requested for the operation.
      cancelRequested :: (Core.Maybe Core.Bool),
      counter :: (Core.Maybe ProgressCounter),
      -- | The time at which the operation was created by the API.
      createTime :: (Core.Maybe Core.DateTime),
      -- | The time at which execution was completed.
      endTime :: (Core.Maybe Core.DateTime),
      -- | A link to audit and error logs in the log viewer. Error logs are generated only by some operations, listed at <https://cloud.google.com/healthcare/docs/how-tos/logging Viewing error logs in Cloud Logging>.
      logsUrl :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OperationMetadata' with the minimum fields required to make a request.
  newOperationMetadata ::
    OperationMetadata
  newOperationMetadata =
    OperationMetadata
      { apiMethodName = Core.Nothing,
        cancelRequested = Core.Nothing,
        counter = Core.Nothing,
        createTime = Core.Nothing,
        endTime = Core.Nothing,
        logsUrl = Core.Nothing
      }
  
  instance Core.FromJSON OperationMetadata where
    parseJSON =
      Core.withObject
        "OperationMetadata"
        ( \o ->
            OperationMetadata
              Core.<$> (o Core..:? "apiMethodName")
              Core.<*> (o Core..:? "cancelRequested")
              Core.<*> (o Core..:? "counter")
              Core.<*> (o Core..:? "createTime")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "logsUrl")
        )
  
  instance Core.ToJSON OperationMetadata where
    toJSON OperationMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("apiMethodName" Core..=) Core.<$> apiMethodName,
              ("cancelRequested" Core..=) Core.<$> cancelRequested,
              ("counter" Core..=) Core.<$> counter,
              ("createTime" Core..=) Core.<$> createTime,
              ("endTime" Core..=) Core.<$> endTime,
              ("logsUrl" Core..=) Core.<$> logsUrl
            ]
        )
  
  -- | The content of a HL7v2 message in a structured format.
  --
  -- /See:/ 'newParsedData' smart constructor.
  newtype ParsedData = ParsedData
    { segments :: (Core.Maybe [Segment])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParsedData' with the minimum fields required to make a request.
  newParsedData ::
    ParsedData
  newParsedData = ParsedData {segments = Core.Nothing}
  
  instance Core.FromJSON ParsedData where
    parseJSON =
      Core.withObject
        "ParsedData"
        (\o -> ParsedData Core.<$> (o Core..:? "segments"))
  
  instance Core.ToJSON ParsedData where
    toJSON ParsedData {..} =
      Core.object
        (Core.catMaybes [("segments" Core..=) Core.<$> segments])
  
  -- | The configuration for the parser. It determines how the server parses the messages.
  --
  -- /See:/ 'newParserConfig' smart constructor.
  data ParserConfig = ParserConfig
    { -- | Optional. Determines whether messages with no header are allowed.
      allowNullHeader :: (Core.Maybe Core.Bool),
      -- | Optional. Schemas used to parse messages in this store, if schematized parsing is desired.
      schema :: (Core.Maybe SchemaPackage),
      -- | Optional. Byte(s) to use as the segment terminator. If this is unset, \'\\r\' is used as segment terminator, matching the HL7 version 2 specification.
      segmentTerminator :: (Core.Maybe Core.Base64),
      -- | Immutable. Determines the version of both the default parser to be used when @schema@ is not given, as well as the schematized parser used when @schema@ is specified. This field is immutable after HL7v2 store creation.
      version :: (Core.Maybe ParserConfig_Version)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParserConfig' with the minimum fields required to make a request.
  newParserConfig ::
    ParserConfig
  newParserConfig =
    ParserConfig
      { allowNullHeader = Core.Nothing,
        schema = Core.Nothing,
        segmentTerminator = Core.Nothing,
        version = Core.Nothing
      }
  
  instance Core.FromJSON ParserConfig where
    parseJSON =
      Core.withObject
        "ParserConfig"
        ( \o ->
            ParserConfig
              Core.<$> (o Core..:? "allowNullHeader")
              Core.<*> (o Core..:? "schema")
              Core.<*> (o Core..:? "segmentTerminator")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON ParserConfig where
    toJSON ParserConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("allowNullHeader" Core..=) Core.<$> allowNullHeader,
              ("schema" Core..=) Core.<$> schema,
              ("segmentTerminator" Core..=) Core.<$> segmentTerminator,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | A patient identifier and associated type.
  --
  -- /See:/ 'newPatientId' smart constructor.
  data PatientId = PatientId
    { -- | ID type. For example, MRN or NHS.
      type' :: (Core.Maybe Core.Text),
      -- | The patient\'s unique identifier.
      value :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PatientId' with the minimum fields required to make a request.
  newPatientId ::
    PatientId
  newPatientId =
    PatientId {type' = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON PatientId where
    parseJSON =
      Core.withObject
        "PatientId"
        ( \o ->
            PatientId
              Core.<$> (o Core..:? "type")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON PatientId where
    toJSON PatientId {..} =
      Core.object
        ( Core.catMaybes
            [ ("type" Core..=) Core.<$> type',
              ("value" Core..=) Core.<$> value
            ]
        )
  
  -- | Apply consents given by a list of patients.
  --
  -- /See:/ 'newPatientScope' smart constructor.
  newtype PatientScope = PatientScope
    { -- | Optional. The list of patient IDs whose Consent resources will be enforced. At most 10,000 patients can be specified. An empty list is equivalent to all patients (meaning the entire FHIR store).
      patientIds :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PatientScope' with the minimum fields required to make a request.
  newPatientScope ::
    PatientScope
  newPatientScope = PatientScope {patientIds = Core.Nothing}
  
  instance Core.FromJSON PatientScope where
    parseJSON =
      Core.withObject
        "PatientScope"
        (\o -> PatientScope Core.<$> (o Core..:? "patientIds"))
  
  instance Core.ToJSON PatientScope where
    toJSON PatientScope {..} =
      Core.object
        (Core.catMaybes [("patientIds" Core..=) Core.<$> patientIds])
  
  -- | 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
            ]
        )
  
  -- | ProgressCounter provides counters to describe an operation\'s progress.
  --
  -- /See:/ 'newProgressCounter' smart constructor.
  data ProgressCounter = ProgressCounter
    { -- | The number of units that failed in the operation.
      failure :: (Core.Maybe Core.Int64),
      -- | The number of units that are pending in the operation.
      pending :: (Core.Maybe Core.Int64),
      -- | The number of units that succeeded in the operation.
      success :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ProgressCounter' with the minimum fields required to make a request.
  newProgressCounter ::
    ProgressCounter
  newProgressCounter =
    ProgressCounter
      { failure = Core.Nothing,
        pending = Core.Nothing,
        success = Core.Nothing
      }
  
  instance Core.FromJSON ProgressCounter where
    parseJSON =
      Core.withObject
        "ProgressCounter"
        ( \o ->
            ProgressCounter
              Core.<$> (o Core..:? "failure" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "pending" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "success" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON ProgressCounter where
    toJSON ProgressCounter {..} =
      Core.object
        ( Core.catMaybes
            [ ("failure" Core..=) Core.. Core.AsText Core.<$> failure,
              ("pending" Core..=) Core.. Core.AsText Core.<$> pending,
              ("success" Core..=) Core.. Core.AsText Core.<$> success
            ]
        )
  
  -- | The Pub\/Sub output destination. The Cloud Healthcare Service Agent requires the @roles\/pubsub.publisher@ Cloud IAM role on the Pub\/Sub topic.
  --
  -- /See:/ 'newPubsubDestination' smart constructor.
  newtype PubsubDestination = PubsubDestination
    { -- | The <https://cloud.google.com/pubsub/docs/ Pub\/Sub> topic that Pub\/Sub messages are published on. Supplied by the client. The @PubsubMessage@ contains the following fields: * @PubsubMessage.Data@ contains the resource name. * @PubsubMessage.MessageId@ is the ID of this notification. It is guaranteed to be unique within the topic. * @PubsubMessage.PublishTime@ is the time when the message was published. <https://cloud.google.com/pubsub/docs/overview#names Topic names> must be scoped to a project. The Cloud Healthcare API service account, service-PROJECT_NUMBER\@gcp-sa-healthcare.iam.gserviceaccount.com, must have publisher permissions on the given Pub\/Sub topic. Not having adequate permissions causes the calls that send notifications to fail.
      pubsubTopic :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PubsubDestination' with the minimum fields required to make a request.
  newPubsubDestination ::
    PubsubDestination
  newPubsubDestination =
    PubsubDestination {pubsubTopic = Core.Nothing}
  
  instance Core.FromJSON PubsubDestination where
    parseJSON =
      Core.withObject
        "PubsubDestination"
        (\o -> PubsubDestination Core.<$> (o Core..:? "pubsubTopic"))
  
  instance Core.ToJSON PubsubDestination where
    toJSON PubsubDestination {..} =
      Core.object
        (Core.catMaybes [("pubsubTopic" Core..=) Core.<$> pubsubTopic])
  
  -- | Queries all data_ids that are consented for a given use in the given consent store and writes them to a specified destination. The returned Operation includes a progress counter for the number of User data mappings processed. Errors are logged to Cloud Logging (see [Viewing error logs in Cloud Logging] (https:\/\/cloud.google.com\/healthcare\/docs\/how-tos\/logging) and [QueryAccessibleData] for a sample log entry).
  --
  -- /See:/ 'newQueryAccessibleDataRequest' smart constructor.
  data QueryAccessibleDataRequest = QueryAccessibleDataRequest
    { -- | The Cloud Storage destination. The Cloud Healthcare API service account must have the @roles\/storage.objectAdmin@ Cloud IAM role for this Cloud Storage location.
      gcsDestination :: (Core.Maybe GoogleCloudHealthcareV1ConsentGcsDestination),
      -- | The values of request attributes associated with this access request.
      requestAttributes :: (Core.Maybe QueryAccessibleDataRequest_RequestAttributes),
      -- | Optional. The values of resource attributes associated with the type of resources being requested. If no values are specified, then all resource types are included in the output.
      resourceAttributes :: (Core.Maybe QueryAccessibleDataRequest_ResourceAttributes)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'QueryAccessibleDataRequest' with the minimum fields required to make a request.
  newQueryAccessibleDataRequest ::
    QueryAccessibleDataRequest
  newQueryAccessibleDataRequest =
    QueryAccessibleDataRequest
      { gcsDestination = Core.Nothing,
        requestAttributes = Core.Nothing,
        resourceAttributes = Core.Nothing
      }
  
  instance Core.FromJSON QueryAccessibleDataRequest where
    parseJSON =
      Core.withObject
        "QueryAccessibleDataRequest"
        ( \o ->
            QueryAccessibleDataRequest
              Core.<$> (o Core..:? "gcsDestination")
              Core.<*> (o Core..:? "requestAttributes")
              Core.<*> (o Core..:? "resourceAttributes")
        )
  
  instance Core.ToJSON QueryAccessibleDataRequest where
    toJSON QueryAccessibleDataRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("gcsDestination" Core..=) Core.<$> gcsDestination,
              ("requestAttributes" Core..=) Core.<$> requestAttributes,
              ("resourceAttributes" Core..=) Core.<$> resourceAttributes
            ]
        )
  
  -- | The values of request attributes associated with this access request.
  --
  -- /See:/ 'newQueryAccessibleDataRequest_RequestAttributes' smart constructor.
  newtype QueryAccessibleDataRequest_RequestAttributes = QueryAccessibleDataRequest_RequestAttributes
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'QueryAccessibleDataRequest_RequestAttributes' with the minimum fields required to make a request.
  newQueryAccessibleDataRequest_RequestAttributes ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    QueryAccessibleDataRequest_RequestAttributes
  newQueryAccessibleDataRequest_RequestAttributes additional =
    QueryAccessibleDataRequest_RequestAttributes
      { additional =
          additional
      }
  
  instance Core.FromJSON QueryAccessibleDataRequest_RequestAttributes where
    parseJSON =
      Core.withObject
        "QueryAccessibleDataRequest_RequestAttributes"
        ( \o ->
            QueryAccessibleDataRequest_RequestAttributes
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON QueryAccessibleDataRequest_RequestAttributes where
    toJSON QueryAccessibleDataRequest_RequestAttributes {..} =
      Core.toJSON additional
  
  -- | Optional. The values of resource attributes associated with the type of resources being requested. If no values are specified, then all resource types are included in the output.
  --
  -- /See:/ 'newQueryAccessibleDataRequest_ResourceAttributes' smart constructor.
  newtype QueryAccessibleDataRequest_ResourceAttributes = QueryAccessibleDataRequest_ResourceAttributes
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'QueryAccessibleDataRequest_ResourceAttributes' with the minimum fields required to make a request.
  newQueryAccessibleDataRequest_ResourceAttributes ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    QueryAccessibleDataRequest_ResourceAttributes
  newQueryAccessibleDataRequest_ResourceAttributes additional =
    QueryAccessibleDataRequest_ResourceAttributes
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      QueryAccessibleDataRequest_ResourceAttributes
    where
    parseJSON =
      Core.withObject
        "QueryAccessibleDataRequest_ResourceAttributes"
        ( \o ->
            QueryAccessibleDataRequest_ResourceAttributes
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON QueryAccessibleDataRequest_ResourceAttributes where
    toJSON QueryAccessibleDataRequest_ResourceAttributes {..} =
      Core.toJSON additional
  
  -- | Response for successful QueryAccessibleData operations. This structure is included in the response upon operation completion.
  --
  -- /See:/ 'newQueryAccessibleDataResponse' smart constructor.
  newtype QueryAccessibleDataResponse = QueryAccessibleDataResponse
    { -- | List of files, each of which contains a list of data_id(s) that are consented for a specified use in the request.
      gcsUris :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'QueryAccessibleDataResponse' with the minimum fields required to make a request.
  newQueryAccessibleDataResponse ::
    QueryAccessibleDataResponse
  newQueryAccessibleDataResponse =
    QueryAccessibleDataResponse {gcsUris = Core.Nothing}
  
  instance Core.FromJSON QueryAccessibleDataResponse where
    parseJSON =
      Core.withObject
        "QueryAccessibleDataResponse"
        ( \o ->
            QueryAccessibleDataResponse Core.<$> (o Core..:? "gcsUris")
        )
  
  instance Core.ToJSON QueryAccessibleDataResponse where
    toJSON QueryAccessibleDataResponse {..} =
      Core.object
        (Core.catMaybes [("gcsUris" Core..=) Core.<$> gcsUris])
  
  -- | Define how to redact sensitive values. Default behaviour is erase. For example, \"My name is Jane.\" becomes \"My name is .\"
  --
  -- /See:/ 'newRedactConfig' smart constructor.
  data RedactConfig = RedactConfig
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RedactConfig' with the minimum fields required to make a request.
  newRedactConfig ::
    RedactConfig
  newRedactConfig = RedactConfig
  
  instance Core.FromJSON RedactConfig where
    parseJSON =
      Core.withObject "RedactConfig" (\o -> Core.pure RedactConfig)
  
  instance Core.ToJSON RedactConfig where
    toJSON = Core.const Core.emptyObject
  
  -- | Rejects the latest revision of the specified Consent by committing a new revision with @state@ updated to @REJECTED@. If the latest revision of the given Consent is in the @REJECTED@ state, no new revision is committed.
  --
  -- /See:/ 'newRejectConsentRequest' smart constructor.
  newtype RejectConsentRequest = RejectConsentRequest
    { -- | Optional. The resource name of the Consent artifact that contains documentation of the user\'s rejection of the draft Consent, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/consentArtifacts\/{consent_artifact_id}@. If the draft Consent had a Consent artifact, this Consent artifact overwrites it.
      consentArtifact :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RejectConsentRequest' with the minimum fields required to make a request.
  newRejectConsentRequest ::
    RejectConsentRequest
  newRejectConsentRequest =
    RejectConsentRequest {consentArtifact = Core.Nothing}
  
  instance Core.FromJSON RejectConsentRequest where
    parseJSON =
      Core.withObject
        "RejectConsentRequest"
        ( \o ->
            RejectConsentRequest Core.<$> (o Core..:? "consentArtifact")
        )
  
  instance Core.ToJSON RejectConsentRequest where
    toJSON RejectConsentRequest {..} =
      Core.object
        ( Core.catMaybes
            [("consentArtifact" Core..=) Core.<$> consentArtifact]
        )
  
  -- | When using the INSPECT/AND/TRANSFORM action, each match is replaced with the name of the info/type. For example, \"My name is Jane\" becomes \"My name is [PERSON/NAME].\" The TRANSFORM action is equivalent to redacting.
  --
  -- /See:/ 'newReplaceWithInfoTypeConfig' smart constructor.
  data ReplaceWithInfoTypeConfig = ReplaceWithInfoTypeConfig
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReplaceWithInfoTypeConfig' with the minimum fields required to make a request.
  newReplaceWithInfoTypeConfig ::
    ReplaceWithInfoTypeConfig
  newReplaceWithInfoTypeConfig = ReplaceWithInfoTypeConfig
  
  instance Core.FromJSON ReplaceWithInfoTypeConfig where
    parseJSON =
      Core.withObject
        "ReplaceWithInfoTypeConfig"
        (\o -> Core.pure ReplaceWithInfoTypeConfig)
  
  instance Core.ToJSON ReplaceWithInfoTypeConfig where
    toJSON = Core.const Core.emptyObject
  
  -- | A list of FHIR resources.
  --
  -- /See:/ 'newResources' smart constructor.
  newtype Resources = Resources
    { -- | List of resources IDs. For example, \"Patient\/1234\".
      resources :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Resources' with the minimum fields required to make a request.
  newResources ::
    Resources
  newResources = Resources {resources = Core.Nothing}
  
  instance Core.FromJSON Resources where
    parseJSON =
      Core.withObject
        "Resources"
        (\o -> Resources Core.<$> (o Core..:? "resources"))
  
  instance Core.ToJSON Resources where
    toJSON Resources {..} =
      Core.object
        (Core.catMaybes [("resources" Core..=) Core.<$> resources])
  
  -- | The consent evaluation result for a single @data_id@.
  --
  -- /See:/ 'newResult' smart constructor.
  data Result = Result
    { -- | The resource names of all evaluated Consents mapped to their evaluation.
      consentDetails :: (Core.Maybe Result_ConsentDetails),
      -- | Whether the resource is consented for the given use.
      consented :: (Core.Maybe Core.Bool),
      -- | The unique identifier of the evaluated resource.
      dataId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Result' with the minimum fields required to make a request.
  newResult ::
    Result
  newResult =
    Result
      { consentDetails = Core.Nothing,
        consented = Core.Nothing,
        dataId = Core.Nothing
      }
  
  instance Core.FromJSON Result where
    parseJSON =
      Core.withObject
        "Result"
        ( \o ->
            Result
              Core.<$> (o Core..:? "consentDetails")
              Core.<*> (o Core..:? "consented")
              Core.<*> (o Core..:? "dataId")
        )
  
  instance Core.ToJSON Result where
    toJSON Result {..} =
      Core.object
        ( Core.catMaybes
            [ ("consentDetails" Core..=) Core.<$> consentDetails,
              ("consented" Core..=) Core.<$> consented,
              ("dataId" Core..=) Core.<$> dataId
            ]
        )
  
  -- | The resource names of all evaluated Consents mapped to their evaluation.
  --
  -- /See:/ 'newResult_ConsentDetails' smart constructor.
  newtype Result_ConsentDetails = Result_ConsentDetails
    { additional :: (Core.HashMap Core.Text ConsentEvaluation)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Result_ConsentDetails' with the minimum fields required to make a request.
  newResult_ConsentDetails ::
    -- |  See 'additional'.
    Core.HashMap Core.Text ConsentEvaluation ->
    Result_ConsentDetails
  newResult_ConsentDetails additional =
    Result_ConsentDetails {additional = additional}
  
  instance Core.FromJSON Result_ConsentDetails where
    parseJSON =
      Core.withObject
        "Result_ConsentDetails"
        (\o -> Result_ConsentDetails Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Result_ConsentDetails where
    toJSON Result_ConsentDetails {..} = Core.toJSON additional
  
  -- | Revokes the latest revision of the specified Consent by committing a new revision with @state@ updated to @REVOKED@. If the latest revision of the given Consent is in the @REVOKED@ state, no new revision is committed.
  --
  -- /See:/ 'newRevokeConsentRequest' smart constructor.
  newtype RevokeConsentRequest = RevokeConsentRequest
    { -- | Optional. The resource name of the Consent artifact that contains proof of the user\'s revocation of the Consent, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/consentArtifacts\/{consent_artifact_id}@.
      consentArtifact :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RevokeConsentRequest' with the minimum fields required to make a request.
  newRevokeConsentRequest ::
    RevokeConsentRequest
  newRevokeConsentRequest =
    RevokeConsentRequest {consentArtifact = Core.Nothing}
  
  instance Core.FromJSON RevokeConsentRequest where
    parseJSON =
      Core.withObject
        "RevokeConsentRequest"
        ( \o ->
            RevokeConsentRequest Core.<$> (o Core..:? "consentArtifact")
        )
  
  instance Core.ToJSON RevokeConsentRequest where
    toJSON RevokeConsentRequest {..} =
      Core.object
        ( Core.catMaybes
            [("consentArtifact" Core..=) Core.<$> consentArtifact]
        )
  
  --
  -- /See:/ 'newRollbackFhirResourceFilteringFields' smart constructor.
  data RollbackFhirResourceFilteringFields = RollbackFhirResourceFilteringFields
    { -- | Optional. A filter expression that matches data in the @Resource.meta@ element. Supports all filters in <https://google.aip.dev/160 AIP-160> except the \"has\" (@:@) operator. Supports the following custom functions: * @tag(\"\") = \"\"@ for tag filtering. * @extension_value_ts(\"\") =@ for filtering extensions with a timestamp, where \`@is a Unix timestamp. Supports the@>@,@\<@,@\<=@,@>=@, and@!=\` comparison operators.
      metadataFilter :: (Core.Maybe Core.Text),
      -- | Optional. A list of operation IDs to roll back.
      operationIds :: (Core.Maybe [Core.Word64])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RollbackFhirResourceFilteringFields' with the minimum fields required to make a request.
  newRollbackFhirResourceFilteringFields ::
    RollbackFhirResourceFilteringFields
  newRollbackFhirResourceFilteringFields =
    RollbackFhirResourceFilteringFields
      { metadataFilter =
          Core.Nothing,
        operationIds = Core.Nothing
      }
  
  instance Core.FromJSON RollbackFhirResourceFilteringFields where
    parseJSON =
      Core.withObject
        "RollbackFhirResourceFilteringFields"
        ( \o ->
            RollbackFhirResourceFilteringFields
              Core.<$> (o Core..:? "metadataFilter")
              Core.<*> ( o
                           Core..:? "operationIds"
                           Core.<&> Core.fmap (Core.fmap Core.fromAsText)
                       )
        )
  
  instance Core.ToJSON RollbackFhirResourceFilteringFields where
    toJSON RollbackFhirResourceFilteringFields {..} =
      Core.object
        ( Core.catMaybes
            [ ("metadataFilter" Core..=) Core.<$> metadataFilter,
              ("operationIds" Core..=)
                Core.. Core.fmap Core.AsText
                Core.<$> operationIds
            ]
        )
  
  --
  -- /See:/ 'newRollbackFhirResourcesRequest' smart constructor.
  data RollbackFhirResourcesRequest = RollbackFhirResourcesRequest
    { -- | Optional. CREATE\/UPDATE\/DELETE\/ALL for reverting all txns of a certain type.
      changeType :: (Core.Maybe RollbackFhirResourcesRequest_ChangeType),
      -- | Optional. Specifies whether to exclude earlier rollbacks.
      excludeRollbacks :: (Core.Maybe Core.Bool),
      -- | Optional. Parameters for filtering resources
      filteringFields :: (Core.Maybe RollbackFhirResourceFilteringFields),
      -- | Optional. When enabled, changes will be reverted without explicit confirmation
      force :: (Core.Maybe Core.Bool),
      -- | Optional. Cloud Storage object containing list of {resourceType}\/{resourceId} lines, identifying resources to be reverted
      inputGcsObject :: (Core.Maybe Core.Text),
      -- | Required. Bucket to deposit result
      resultGcsBucket :: (Core.Maybe Core.Text),
      -- | Required. Time point to rollback to.
      rollbackTime :: (Core.Maybe Core.DateTime),
      -- | Optional. If specified, revert only resources of these types
      type' :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RollbackFhirResourcesRequest' with the minimum fields required to make a request.
  newRollbackFhirResourcesRequest ::
    RollbackFhirResourcesRequest
  newRollbackFhirResourcesRequest =
    RollbackFhirResourcesRequest
      { changeType = Core.Nothing,
        excludeRollbacks = Core.Nothing,
        filteringFields = Core.Nothing,
        force = Core.Nothing,
        inputGcsObject = Core.Nothing,
        resultGcsBucket = Core.Nothing,
        rollbackTime = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON RollbackFhirResourcesRequest where
    parseJSON =
      Core.withObject
        "RollbackFhirResourcesRequest"
        ( \o ->
            RollbackFhirResourcesRequest
              Core.<$> (o Core..:? "changeType")
              Core.<*> (o Core..:? "excludeRollbacks")
              Core.<*> (o Core..:? "filteringFields")
              Core.<*> (o Core..:? "force")
              Core.<*> (o Core..:? "inputGcsObject")
              Core.<*> (o Core..:? "resultGcsBucket")
              Core.<*> (o Core..:? "rollbackTime")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON RollbackFhirResourcesRequest where
    toJSON RollbackFhirResourcesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("changeType" Core..=) Core.<$> changeType,
              ("excludeRollbacks" Core..=) Core.<$> excludeRollbacks,
              ("filteringFields" Core..=) Core.<$> filteringFields,
              ("force" Core..=) Core.<$> force,
              ("inputGcsObject" Core..=) Core.<$> inputGcsObject,
              ("resultGcsBucket" Core..=) Core.<$> resultGcsBucket,
              ("rollbackTime" Core..=) Core.<$> rollbackTime,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Final response of rollback FIHR resources request.
  --
  -- /See:/ 'newRollbackFhirResourcesResponse' smart constructor.
  newtype RollbackFhirResourcesResponse = RollbackFhirResourcesResponse
    { -- | The name of the FHIR store to rollback, in the format of \"projects\/{project/id}\/locations\/{location/id}\/datasets\/{dataset/id} \/fhirStores\/{fhir/store_id}\".
      fhirStore :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RollbackFhirResourcesResponse' with the minimum fields required to make a request.
  newRollbackFhirResourcesResponse ::
    RollbackFhirResourcesResponse
  newRollbackFhirResourcesResponse =
    RollbackFhirResourcesResponse {fhirStore = Core.Nothing}
  
  instance Core.FromJSON RollbackFhirResourcesResponse where
    parseJSON =
      Core.withObject
        "RollbackFhirResourcesResponse"
        ( \o ->
            RollbackFhirResourcesResponse Core.<$> (o Core..:? "fhirStore")
        )
  
  instance Core.ToJSON RollbackFhirResourcesResponse where
    toJSON RollbackFhirResourcesResponse {..} =
      Core.object
        (Core.catMaybes [("fhirStore" Core..=) Core.<$> fhirStore])
  
  -- | Filtering fields for an HL7v2 rollback. Currently only supports a list of operation ids to roll back.
  --
  -- /See:/ 'newRollbackHL7MessagesFilteringFields' smart constructor.
  newtype RollbackHL7MessagesFilteringFields = RollbackHL7MessagesFilteringFields
    { -- | Optional. A list of operation IDs to roll back.
      operationIds :: (Core.Maybe [Core.Word64])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RollbackHL7MessagesFilteringFields' with the minimum fields required to make a request.
  newRollbackHL7MessagesFilteringFields ::
    RollbackHL7MessagesFilteringFields
  newRollbackHL7MessagesFilteringFields =
    RollbackHL7MessagesFilteringFields {operationIds = Core.Nothing}
  
  instance Core.FromJSON RollbackHL7MessagesFilteringFields where
    parseJSON =
      Core.withObject
        "RollbackHL7MessagesFilteringFields"
        ( \o ->
            RollbackHL7MessagesFilteringFields
              Core.<$> ( o
                           Core..:? "operationIds"
                           Core.<&> Core.fmap (Core.fmap Core.fromAsText)
                       )
        )
  
  instance Core.ToJSON RollbackHL7MessagesFilteringFields where
    toJSON RollbackHL7MessagesFilteringFields {..} =
      Core.object
        ( Core.catMaybes
            [ ("operationIds" Core..=)
                Core.. Core.fmap Core.AsText
                Core.<$> operationIds
            ]
        )
  
  -- | Point in time recovery rollback request.
  --
  -- /See:/ 'newRollbackHl7V2MessagesRequest' smart constructor.
  data RollbackHl7V2MessagesRequest = RollbackHl7V2MessagesRequest
    { -- | Optional. CREATE\/UPDATE\/DELETE\/ALL for reverting all txns of a certain type.
      changeType :: (Core.Maybe RollbackHl7V2MessagesRequest_ChangeType),
      -- | Optional. Specifies whether to exclude earlier rollbacks.
      excludeRollbacks :: (Core.Maybe Core.Bool),
      -- | Optional. Parameters for filtering.
      filteringFields :: (Core.Maybe RollbackHL7MessagesFilteringFields),
      -- | Optional. When enabled, changes will be reverted without explicit confirmation.
      force :: (Core.Maybe Core.Bool),
      -- | Optional. Cloud storage object containing list of {resourceId} lines, identifying resources to be reverted
      inputGcsObject :: (Core.Maybe Core.Text),
      -- | Required. Bucket to deposit result
      resultGcsBucket :: (Core.Maybe Core.Text),
      -- | Required. Times point to rollback to.
      rollbackTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RollbackHl7V2MessagesRequest' with the minimum fields required to make a request.
  newRollbackHl7V2MessagesRequest ::
    RollbackHl7V2MessagesRequest
  newRollbackHl7V2MessagesRequest =
    RollbackHl7V2MessagesRequest
      { changeType = Core.Nothing,
        excludeRollbacks = Core.Nothing,
        filteringFields = Core.Nothing,
        force = Core.Nothing,
        inputGcsObject = Core.Nothing,
        resultGcsBucket = Core.Nothing,
        rollbackTime = Core.Nothing
      }
  
  instance Core.FromJSON RollbackHl7V2MessagesRequest where
    parseJSON =
      Core.withObject
        "RollbackHl7V2MessagesRequest"
        ( \o ->
            RollbackHl7V2MessagesRequest
              Core.<$> (o Core..:? "changeType")
              Core.<*> (o Core..:? "excludeRollbacks")
              Core.<*> (o Core..:? "filteringFields")
              Core.<*> (o Core..:? "force")
              Core.<*> (o Core..:? "inputGcsObject")
              Core.<*> (o Core..:? "resultGcsBucket")
              Core.<*> (o Core..:? "rollbackTime")
        )
  
  instance Core.ToJSON RollbackHl7V2MessagesRequest where
    toJSON RollbackHl7V2MessagesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("changeType" Core..=) Core.<$> changeType,
              ("excludeRollbacks" Core..=) Core.<$> excludeRollbacks,
              ("filteringFields" Core..=) Core.<$> filteringFields,
              ("force" Core..=) Core.<$> force,
              ("inputGcsObject" Core..=) Core.<$> inputGcsObject,
              ("resultGcsBucket" Core..=) Core.<$> resultGcsBucket,
              ("rollbackTime" Core..=) Core.<$> rollbackTime
            ]
        )
  
  -- | Final response of rollback HL7v2 messages request.
  --
  -- /See:/ 'newRollbackHl7V2MessagesResponse' smart constructor.
  newtype RollbackHl7V2MessagesResponse = RollbackHl7V2MessagesResponse
    { -- | The name of the HL7v2 store to rollback, in the format of \"projects\/{project/id}\/locations\/{location/id}\/datasets\/{dataset/id} \/hl7v2Stores\/{hl7v2/store_id}\".
      hl7v2Store :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RollbackHl7V2MessagesResponse' with the minimum fields required to make a request.
  newRollbackHl7V2MessagesResponse ::
    RollbackHl7V2MessagesResponse
  newRollbackHl7V2MessagesResponse =
    RollbackHl7V2MessagesResponse {hl7v2Store = Core.Nothing}
  
  instance Core.FromJSON RollbackHl7V2MessagesResponse where
    parseJSON =
      Core.withObject
        "RollbackHl7V2MessagesResponse"
        ( \o ->
            RollbackHl7V2MessagesResponse Core.<$> (o Core..:? "hl7v2Store")
        )
  
  instance Core.ToJSON RollbackHl7V2MessagesResponse where
    toJSON RollbackHl7V2MessagesResponse {..} =
      Core.object
        (Core.catMaybes [("hl7v2Store" Core..=) Core.<$> hl7v2Store])
  
  -- | Configuration for the FHIR BigQuery schema. Determines how the server generates the schema.
  --
  -- /See:/ 'newSchemaConfig' smart constructor.
  data SchemaConfig = SchemaConfig
    { -- | The configuration for exported BigQuery tables to be partitioned by FHIR resource\'s last updated time column.
      lastUpdatedPartitionConfig :: (Core.Maybe TimePartitioning),
      -- | The depth for all recursive structures in the output analytics schema. For example, @concept@ in the CodeSystem resource is a recursive structure; when the depth is 2, the CodeSystem table will have a column called @concept.concept@ but not @concept.concept.concept@. If not specified or set to 0, the server will use the default value 2. The maximum depth allowed is 5.
      recursiveStructureDepth :: (Core.Maybe Core.Int64),
      -- | Specifies the output schema type. Schema type is required.
      schemaType :: (Core.Maybe SchemaConfig_SchemaType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SchemaConfig' with the minimum fields required to make a request.
  newSchemaConfig ::
    SchemaConfig
  newSchemaConfig =
    SchemaConfig
      { lastUpdatedPartitionConfig = Core.Nothing,
        recursiveStructureDepth = Core.Nothing,
        schemaType = Core.Nothing
      }
  
  instance Core.FromJSON SchemaConfig where
    parseJSON =
      Core.withObject
        "SchemaConfig"
        ( \o ->
            SchemaConfig
              Core.<$> (o Core..:? "lastUpdatedPartitionConfig")
              Core.<*> ( o
                           Core..:? "recursiveStructureDepth"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "schemaType")
        )
  
  instance Core.ToJSON SchemaConfig where
    toJSON SchemaConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("lastUpdatedPartitionConfig" Core..=)
                Core.<$> lastUpdatedPartitionConfig,
              ("recursiveStructureDepth" Core..=)
                Core.. Core.AsText
                Core.<$> recursiveStructureDepth,
              ("schemaType" Core..=) Core.<$> schemaType
            ]
        )
  
  -- | An HL7v2 logical group construct.
  --
  -- /See:/ 'newSchemaGroup' smart constructor.
  data SchemaGroup = SchemaGroup
    { -- | True indicates that this is a choice group, meaning that only one of its segments can exist in a given message.
      choice :: (Core.Maybe Core.Bool),
      -- | The maximum number of times this group can be repeated. 0 or -1 means unbounded.
      maxOccurs :: (Core.Maybe Core.Int32),
      -- | Nested groups and\/or segments.
      members :: (Core.Maybe [GroupOrSegment]),
      -- | The minimum number of times this group must be present\/repeated.
      minOccurs :: (Core.Maybe Core.Int32),
      -- | The name of this group. For example, \"ORDER_DETAIL\".
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SchemaGroup' with the minimum fields required to make a request.
  newSchemaGroup ::
    SchemaGroup
  newSchemaGroup =
    SchemaGroup
      { choice = Core.Nothing,
        maxOccurs = Core.Nothing,
        members = Core.Nothing,
        minOccurs = Core.Nothing,
        name = Core.Nothing
      }
  
  instance Core.FromJSON SchemaGroup where
    parseJSON =
      Core.withObject
        "SchemaGroup"
        ( \o ->
            SchemaGroup
              Core.<$> (o Core..:? "choice")
              Core.<*> (o Core..:? "maxOccurs")
              Core.<*> (o Core..:? "members")
              Core.<*> (o Core..:? "minOccurs")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON SchemaGroup where
    toJSON SchemaGroup {..} =
      Core.object
        ( Core.catMaybes
            [ ("choice" Core..=) Core.<$> choice,
              ("maxOccurs" Core..=) Core.<$> maxOccurs,
              ("members" Core..=) Core.<$> members,
              ("minOccurs" Core..=) Core.<$> minOccurs,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | A schema package contains a set of schemas and type definitions.
  --
  -- /See:/ 'newSchemaPackage' smart constructor.
  data SchemaPackage = SchemaPackage
    { -- | Optional. Flag to ignore all min_occurs restrictions in the schema. This means that incoming messages can omit any group, segment, field, component, or subcomponent.
      ignoreMinOccurs :: (Core.Maybe Core.Bool),
      -- | Optional. Schema configs that are layered based on their VersionSources that match the incoming message. Schema configs present in higher indices override those in lower indices with the same message type and trigger event if their VersionSources all match an incoming message.
      schemas :: (Core.Maybe [Hl7SchemaConfig]),
      -- | Optional. Determines how messages that fail to parse are handled.
      schematizedParsingType :: (Core.Maybe SchemaPackage_SchematizedParsingType),
      -- | Optional. Schema type definitions that are layered based on their VersionSources that match the incoming message. Type definitions present in higher indices override those in lower indices with the same type name if their VersionSources all match an incoming message.
      types :: (Core.Maybe [Hl7TypesConfig]),
      -- | Optional. Determines how unexpected segments (segments not matched to the schema) are handled.
      unexpectedSegmentHandling :: (Core.Maybe SchemaPackage_UnexpectedSegmentHandling)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SchemaPackage' with the minimum fields required to make a request.
  newSchemaPackage ::
    SchemaPackage
  newSchemaPackage =
    SchemaPackage
      { ignoreMinOccurs = Core.Nothing,
        schemas = Core.Nothing,
        schematizedParsingType = Core.Nothing,
        types = Core.Nothing,
        unexpectedSegmentHandling = Core.Nothing
      }
  
  instance Core.FromJSON SchemaPackage where
    parseJSON =
      Core.withObject
        "SchemaPackage"
        ( \o ->
            SchemaPackage
              Core.<$> (o Core..:? "ignoreMinOccurs")
              Core.<*> (o Core..:? "schemas")
              Core.<*> (o Core..:? "schematizedParsingType")
              Core.<*> (o Core..:? "types")
              Core.<*> (o Core..:? "unexpectedSegmentHandling")
        )
  
  instance Core.ToJSON SchemaPackage where
    toJSON SchemaPackage {..} =
      Core.object
        ( Core.catMaybes
            [ ("ignoreMinOccurs" Core..=) Core.<$> ignoreMinOccurs,
              ("schemas" Core..=) Core.<$> schemas,
              ("schematizedParsingType" Core..=) Core.<$> schematizedParsingType,
              ("types" Core..=) Core.<$> types,
              ("unexpectedSegmentHandling" Core..=)
                Core.<$> unexpectedSegmentHandling
            ]
        )
  
  -- | An HL7v2 Segment.
  --
  -- /See:/ 'newSchemaSegment' smart constructor.
  data SchemaSegment = SchemaSegment
    { -- | The maximum number of times this segment can be present in this group. 0 or -1 means unbounded.
      maxOccurs :: (Core.Maybe Core.Int32),
      -- | The minimum number of times this segment can be present in this group.
      minOccurs :: (Core.Maybe Core.Int32),
      -- | The Segment type. For example, \"PID\".
      type' :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SchemaSegment' with the minimum fields required to make a request.
  newSchemaSegment ::
    SchemaSegment
  newSchemaSegment =
    SchemaSegment
      { maxOccurs = Core.Nothing,
        minOccurs = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON SchemaSegment where
    parseJSON =
      Core.withObject
        "SchemaSegment"
        ( \o ->
            SchemaSegment
              Core.<$> (o Core..:? "maxOccurs")
              Core.<*> (o Core..:? "minOccurs")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON SchemaSegment where
    toJSON SchemaSegment {..} =
      Core.object
        ( Core.catMaybes
            [ ("maxOccurs" Core..=) Core.<$> maxOccurs,
              ("minOccurs" Core..=) Core.<$> minOccurs,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | The content of an HL7v2 message in a structured format as specified by a schema.
  --
  -- /See:/ 'newSchematizedData' smart constructor.
  data SchematizedData = SchematizedData
    { -- | JSON output of the parser.
      data' :: (Core.Maybe Core.Text),
      -- | The error output of the parser.
      error :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SchematizedData' with the minimum fields required to make a request.
  newSchematizedData ::
    SchematizedData
  newSchematizedData =
    SchematizedData {data' = Core.Nothing, error = Core.Nothing}
  
  instance Core.FromJSON SchematizedData where
    parseJSON =
      Core.withObject
        "SchematizedData"
        ( \o ->
            SchematizedData
              Core.<$> (o Core..:? "data")
              Core.<*> (o Core..:? "error")
        )
  
  instance Core.ToJSON SchematizedData where
    toJSON SchematizedData {..} =
      Core.object
        ( Core.catMaybes
            [ ("data" Core..=) Core.<$> data',
              ("error" Core..=) Core.<$> error
            ]
        )
  
  -- | Request to search the resources in the specified FHIR store.
  --
  -- /See:/ 'newSearchResourcesRequest' smart constructor.
  newtype SearchResourcesRequest = SearchResourcesRequest
    { -- | Optional. The FHIR resource type to search, such as Patient or Observation. For a complete list, see the FHIR Resource Index (<http://hl7.org/implement/standards/fhir/DSTU2/resourcelist.html DSTU2>, <http://hl7.org/implement/standards/fhir/STU3/resourcelist.html STU3>, <http://hl7.org/implement/standards/fhir/R4/resourcelist.html R4>).
      resourceType :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SearchResourcesRequest' with the minimum fields required to make a request.
  newSearchResourcesRequest ::
    SearchResourcesRequest
  newSearchResourcesRequest =
    SearchResourcesRequest {resourceType = Core.Nothing}
  
  instance Core.FromJSON SearchResourcesRequest where
    parseJSON =
      Core.withObject
        "SearchResourcesRequest"
        ( \o ->
            SearchResourcesRequest Core.<$> (o Core..:? "resourceType")
        )
  
  instance Core.ToJSON SearchResourcesRequest where
    toJSON SearchResourcesRequest {..} =
      Core.object
        (Core.catMaybes [("resourceType" Core..=) Core.<$> resourceType])
  
  -- | A segment in a structured format.
  --
  -- /See:/ 'newSegment' smart constructor.
  data Segment = Segment
    { -- | A mapping from the positional location to the value. The key string uses zero-based indexes separated by dots to identify Fields, components and sub-components. A bracket notation is also used to identify different instances of a repeated field. Regex for key: (\\d+)([\\d+])?(.\\d+)?(.\\d+)? Examples of (key, value) pairs: * (0.1, \"hemoglobin\") denotes that the first component of Field 0 has the value \"hemoglobin\". * (1.1.2, \"CBC\") denotes that the second sub-component of the first component of Field 1 has the value \"CBC\". * (1[0].1, \"HbA1c\") denotes that the first component of the first Instance of Field 1, which is repeated, has the value \"HbA1c\".
      fields :: (Core.Maybe Segment_Fields),
      -- | A string that indicates the type of segment. For example, EVN or PID.
      segmentId :: (Core.Maybe Core.Text),
      -- | Set ID for segments that can be in a set. This can be empty if it\'s missing or isn\'t applicable.
      setId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Segment' with the minimum fields required to make a request.
  newSegment ::
    Segment
  newSegment =
    Segment
      { fields = Core.Nothing,
        segmentId = Core.Nothing,
        setId = Core.Nothing
      }
  
  instance Core.FromJSON Segment where
    parseJSON =
      Core.withObject
        "Segment"
        ( \o ->
            Segment
              Core.<$> (o Core..:? "fields")
              Core.<*> (o Core..:? "segmentId")
              Core.<*> (o Core..:? "setId")
        )
  
  instance Core.ToJSON Segment where
    toJSON Segment {..} =
      Core.object
        ( Core.catMaybes
            [ ("fields" Core..=) Core.<$> fields,
              ("segmentId" Core..=) Core.<$> segmentId,
              ("setId" Core..=) Core.<$> setId
            ]
        )
  
  -- | A mapping from the positional location to the value. The key string uses zero-based indexes separated by dots to identify Fields, components and sub-components. A bracket notation is also used to identify different instances of a repeated field. Regex for key: (\\d+)([\\d+])?(.\\d+)?(.\\d+)? Examples of (key, value) pairs: * (0.1, \"hemoglobin\") denotes that the first component of Field 0 has the value \"hemoglobin\". * (1.1.2, \"CBC\") denotes that the second sub-component of the first component of Field 1 has the value \"CBC\". * (1[0].1, \"HbA1c\") denotes that the first component of the first Instance of Field 1, which is repeated, has the value \"HbA1c\".
  --
  -- /See:/ 'newSegment_Fields' smart constructor.
  newtype Segment_Fields = Segment_Fields
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Segment_Fields' with the minimum fields required to make a request.
  newSegment_Fields ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Segment_Fields
  newSegment_Fields additional =
    Segment_Fields {additional = additional}
  
  instance Core.FromJSON Segment_Fields where
    parseJSON =
      Core.withObject
        "Segment_Fields"
        (\o -> Segment_Fields Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Segment_Fields where
    toJSON Segment_Fields {..} = Core.toJSON additional
  
  -- | SeriesMetrics contains metrics describing a DICOM series.
  --
  -- /See:/ 'newSeriesMetrics' smart constructor.
  data SeriesMetrics = SeriesMetrics
    { -- | Total blob storage bytes for all instances in the series.
      blobStorageSizeBytes :: (Core.Maybe Core.Int64),
      -- | Number of instances in the series.
      instanceCount :: (Core.Maybe Core.Int64),
      -- | The series resource path. For example, @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/dicomStores\/{dicom_store_id}\/dicomWeb\/studies\/{study_uid}\/series\/{series_uid}@.
      series :: (Core.Maybe Core.Text),
      -- | Total structured storage bytes for all instances in the series.
      structuredStorageSizeBytes :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SeriesMetrics' with the minimum fields required to make a request.
  newSeriesMetrics ::
    SeriesMetrics
  newSeriesMetrics =
    SeriesMetrics
      { blobStorageSizeBytes = Core.Nothing,
        instanceCount = Core.Nothing,
        series = Core.Nothing,
        structuredStorageSizeBytes = Core.Nothing
      }
  
  instance Core.FromJSON SeriesMetrics where
    parseJSON =
      Core.withObject
        "SeriesMetrics"
        ( \o ->
            SeriesMetrics
              Core.<$> ( o
                           Core..:? "blobStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "instanceCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "series")
              Core.<*> ( o
                           Core..:? "structuredStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON SeriesMetrics where
    toJSON SeriesMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("blobStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> blobStorageSizeBytes,
              ("instanceCount" Core..=)
                Core.. Core.AsText
                Core.<$> instanceCount,
              ("series" Core..=) Core.<$> series,
              ("structuredStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> structuredStorageSizeBytes
            ]
        )
  
  -- | Request message for @SetBlobStorageSettings@ method.
  --
  -- /See:/ 'newSetBlobStorageSettingsRequest' smart constructor.
  data SetBlobStorageSettingsRequest = SetBlobStorageSettingsRequest
    { -- | The blob storage settings to update for the specified resources. Only fields listed in @update_mask@ are applied.
      blobStorageSettings :: (Core.Maybe BlobStorageSettings),
      -- | Optional. A filter configuration. If @filter_config@ is specified, set the value of @resource@ to the resource name of a DICOM store in the format @projects\/{projectID}\/locations\/{locationID}\/datasets\/{datasetID}\/dicomStores\/{dicomStoreID}@.
      filterConfig :: (Core.Maybe DicomFilterConfig)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SetBlobStorageSettingsRequest' with the minimum fields required to make a request.
  newSetBlobStorageSettingsRequest ::
    SetBlobStorageSettingsRequest
  newSetBlobStorageSettingsRequest =
    SetBlobStorageSettingsRequest
      { blobStorageSettings = Core.Nothing,
        filterConfig = Core.Nothing
      }
  
  instance Core.FromJSON SetBlobStorageSettingsRequest where
    parseJSON =
      Core.withObject
        "SetBlobStorageSettingsRequest"
        ( \o ->
            SetBlobStorageSettingsRequest
              Core.<$> (o Core..:? "blobStorageSettings")
              Core.<*> (o Core..:? "filterConfig")
        )
  
  instance Core.ToJSON SetBlobStorageSettingsRequest where
    toJSON SetBlobStorageSettingsRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("blobStorageSettings" Core..=) Core.<$> blobStorageSettings,
              ("filterConfig" Core..=) Core.<$> filterConfig
            ]
        )
  
  -- | Returns additional info in regards to a completed set blob storage settings API.
  --
  -- /See:/ 'newSetBlobStorageSettingsResponse' smart constructor.
  data SetBlobStorageSettingsResponse = SetBlobStorageSettingsResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SetBlobStorageSettingsResponse' with the minimum fields required to make a request.
  newSetBlobStorageSettingsResponse ::
    SetBlobStorageSettingsResponse
  newSetBlobStorageSettingsResponse = SetBlobStorageSettingsResponse
  
  instance Core.FromJSON SetBlobStorageSettingsResponse where
    parseJSON =
      Core.withObject
        "SetBlobStorageSettingsResponse"
        (\o -> Core.pure SetBlobStorageSettingsResponse)
  
  instance Core.ToJSON SetBlobStorageSettingsResponse 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
            ]
        )
  
  -- | User signature.
  --
  -- /See:/ 'newSignature' smart constructor.
  data Signature = Signature
    { -- | Optional. An image of the user\'s signature.
      image :: (Core.Maybe Image),
      -- | Optional. Metadata associated with the user\'s signature. For example, the user\'s name or the user\'s title.
      metadata :: (Core.Maybe Signature_Metadata),
      -- | Optional. Timestamp of the signature.
      signatureTime :: (Core.Maybe Core.DateTime),
      -- | Required. User\'s UUID provided by the client.
      userId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Signature' with the minimum fields required to make a request.
  newSignature ::
    Signature
  newSignature =
    Signature
      { image = Core.Nothing,
        metadata = Core.Nothing,
        signatureTime = Core.Nothing,
        userId = Core.Nothing
      }
  
  instance Core.FromJSON Signature where
    parseJSON =
      Core.withObject
        "Signature"
        ( \o ->
            Signature
              Core.<$> (o Core..:? "image")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "signatureTime")
              Core.<*> (o Core..:? "userId")
        )
  
  instance Core.ToJSON Signature where
    toJSON Signature {..} =
      Core.object
        ( Core.catMaybes
            [ ("image" Core..=) Core.<$> image,
              ("metadata" Core..=) Core.<$> metadata,
              ("signatureTime" Core..=) Core.<$> signatureTime,
              ("userId" Core..=) Core.<$> userId
            ]
        )
  
  -- | Optional. Metadata associated with the user\'s signature. For example, the user\'s name or the user\'s title.
  --
  -- /See:/ 'newSignature_Metadata' smart constructor.
  newtype Signature_Metadata = Signature_Metadata
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Signature_Metadata' with the minimum fields required to make a request.
  newSignature_Metadata ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Signature_Metadata
  newSignature_Metadata additional =
    Signature_Metadata {additional = additional}
  
  instance Core.FromJSON Signature_Metadata where
    parseJSON =
      Core.withObject
        "Signature_Metadata"
        (\o -> Signature_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Signature_Metadata where
    toJSON Signature_Metadata {..} = Core.toJSON additional
  
  -- | 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
  
  -- | StorageInfo encapsulates all the storage info of a resource.
  --
  -- /See:/ 'newStorageInfo' smart constructor.
  data StorageInfo = StorageInfo
    { -- | Info about the data stored in blob storage for the resource.
      blobStorageInfo :: (Core.Maybe BlobStorageInfo),
      -- | The resource whose storage info is returned. For example: @projects\/{projectID}\/locations\/{locationID}\/datasets\/{datasetID}\/dicomStores\/{dicomStoreID}\/dicomWeb\/studies\/{studyUID}\/series\/{seriesUID}\/instances\/{instanceUID}@
      referencedResource :: (Core.Maybe Core.Text),
      -- | Info about the data stored in structured storage for the resource.
      structuredStorageInfo :: (Core.Maybe StructuredStorageInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StorageInfo' with the minimum fields required to make a request.
  newStorageInfo ::
    StorageInfo
  newStorageInfo =
    StorageInfo
      { blobStorageInfo = Core.Nothing,
        referencedResource = Core.Nothing,
        structuredStorageInfo = Core.Nothing
      }
  
  instance Core.FromJSON StorageInfo where
    parseJSON =
      Core.withObject
        "StorageInfo"
        ( \o ->
            StorageInfo
              Core.<$> (o Core..:? "blobStorageInfo")
              Core.<*> (o Core..:? "referencedResource")
              Core.<*> (o Core..:? "structuredStorageInfo")
        )
  
  instance Core.ToJSON StorageInfo where
    toJSON StorageInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("blobStorageInfo" Core..=) Core.<$> blobStorageInfo,
              ("referencedResource" Core..=) Core.<$> referencedResource,
              ("structuredStorageInfo" Core..=) Core.<$> structuredStorageInfo
            ]
        )
  
  -- | Contains configuration for streaming FHIR export.
  --
  -- /See:/ 'newStreamConfig' smart constructor.
  data StreamConfig = StreamConfig
    { -- | Optional. The destination BigQuery structure that contains both the dataset location and corresponding schema config. The output is organized in one table per resource type. The server reuses the existing tables (if any) that are named after the resource types. For example, \"Patient\", \"Observation\". When there is no existing table for a given resource type, the server attempts to create one. When a table schema doesn\'t align with the schema config, either because of existing incompatible schema or out of band incompatible modification, the server does not stream in new data. BigQuery imposes a 1 MB limit on streaming insert row size, therefore any resource mutation that generates more than 1 MB of BigQuery data is not streamed. One resolution in this case is to delete the incompatible table and let the server recreate one, though the newly created table only contains data after the table recreation. Results are written to BigQuery tables according to the parameters in
      -- BigQueryDestination.WriteDisposition. Different versions of the same resource are distinguishable by the meta.versionId and meta.lastUpdated columns. The operation (CREATE\/UPDATE\/DELETE) that results in the new version is recorded in the meta.tag. The tables contain all historical resource versions since streaming was enabled. For query convenience, the server also creates one view per table of the same name containing only the current resource version. The streamed data in the BigQuery dataset is not guaranteed to be completely unique. The combination of the id and meta.versionId columns should ideally identify a single unique row. But in rare cases, duplicates may exist. At query time, users may use the SQL select statement to keep only one of the duplicate rows given an id and meta.versionId pair. Alternatively, the server created view mentioned above also filters out duplicates. If a resource mutation cannot be streamed to BigQuery, errors are logged to Cloud Logging. For more information, see
      -- <https://cloud.google.com/healthcare/docs/how-tos/logging Viewing error logs in Cloud Logging>).
      bigqueryDestination :: (Core.Maybe GoogleCloudHealthcareV1FhirBigQueryDestination),
      -- | The destination FHIR store for de-identified resources. After this field is added, all subsequent creates\/updates\/patches to the source store will be de-identified using the provided configuration and applied to the destination store. Resources deleted from the source store will be deleted from the destination store. Importing resources to the source store will not trigger the streaming. If the source store already contains resources when this option is enabled, those resources will not be copied to the destination store unless they are subsequently updated. This may result in invalid references in the destination store. Before adding this config, you must grant the healthcare.fhirResources.update permission on the destination store to your project\'s __Cloud Healthcare Service Agent__ <https://cloud.google.com/healthcare/docs/how-tos/permissions-healthcare-api-gcp-products#the_cloud_healthcare_service_agent service account>. The destination store must set enable/update/create to true. The destination store
      -- must have disable/referential/integrity set to true. If a resource cannot be de-identified, errors will be logged to Cloud Logging (see <https://cloud.google.com/healthcare/docs/how-tos/logging Viewing error logs in Cloud Logging>).
      deidentifiedStoreDestination :: (Core.Maybe DeidentifiedStoreDestination),
      -- | Optional. Supply a FHIR resource type (such as \"Patient\" or \"Observation\"). See https:\/\/www.hl7.org\/fhir\/valueset-resource-types.html for a list of all FHIR resource types. The server treats an empty list as an intent to stream all the supported resource types in this FHIR store.
      resourceTypes :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamConfig' with the minimum fields required to make a request.
  newStreamConfig ::
    StreamConfig
  newStreamConfig =
    StreamConfig
      { bigqueryDestination = Core.Nothing,
        deidentifiedStoreDestination = Core.Nothing,
        resourceTypes = Core.Nothing
      }
  
  instance Core.FromJSON StreamConfig where
    parseJSON =
      Core.withObject
        "StreamConfig"
        ( \o ->
            StreamConfig
              Core.<$> (o Core..:? "bigqueryDestination")
              Core.<*> (o Core..:? "deidentifiedStoreDestination")
              Core.<*> (o Core..:? "resourceTypes")
        )
  
  instance Core.ToJSON StreamConfig where
    toJSON StreamConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("bigqueryDestination" Core..=) Core.<$> bigqueryDestination,
              ("deidentifiedStoreDestination" Core..=)
                Core.<$> deidentifiedStoreDestination,
              ("resourceTypes" Core..=) Core.<$> resourceTypes
            ]
        )
  
  -- | StructuredStorageInfo contains details about the data stored in Structured Storage for the referenced resource.
  --
  -- /See:/ 'newStructuredStorageInfo' smart constructor.
  newtype StructuredStorageInfo = StructuredStorageInfo
    { -- | Size in bytes of data stored in structured storage.
      sizeBytes :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StructuredStorageInfo' with the minimum fields required to make a request.
  newStructuredStorageInfo ::
    StructuredStorageInfo
  newStructuredStorageInfo =
    StructuredStorageInfo {sizeBytes = Core.Nothing}
  
  instance Core.FromJSON StructuredStorageInfo where
    parseJSON =
      Core.withObject
        "StructuredStorageInfo"
        ( \o ->
            StructuredStorageInfo
              Core.<$> (o Core..:? "sizeBytes" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON StructuredStorageInfo where
    toJSON StructuredStorageInfo {..} =
      Core.object
        ( Core.catMaybes
            [("sizeBytes" Core..=) Core.. Core.AsText Core.<$> sizeBytes]
        )
  
  -- | StudyMetrics contains metrics describing a DICOM study.
  --
  -- /See:/ 'newStudyMetrics' smart constructor.
  data StudyMetrics = StudyMetrics
    { -- | Total blob storage bytes for all instances in the study.
      blobStorageSizeBytes :: (Core.Maybe Core.Int64),
      -- | Number of instances in the study.
      instanceCount :: (Core.Maybe Core.Int64),
      -- | Number of series in the study.
      seriesCount :: (Core.Maybe Core.Int64),
      -- | Total structured storage bytes for all instances in the study.
      structuredStorageSizeBytes :: (Core.Maybe Core.Int64),
      -- | The study resource path. For example, @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/dicomStores\/{dicom_store_id}\/dicomWeb\/studies\/{study_uid}@.
      study :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StudyMetrics' with the minimum fields required to make a request.
  newStudyMetrics ::
    StudyMetrics
  newStudyMetrics =
    StudyMetrics
      { blobStorageSizeBytes = Core.Nothing,
        instanceCount = Core.Nothing,
        seriesCount = Core.Nothing,
        structuredStorageSizeBytes = Core.Nothing,
        study = Core.Nothing
      }
  
  instance Core.FromJSON StudyMetrics where
    parseJSON =
      Core.withObject
        "StudyMetrics"
        ( \o ->
            StudyMetrics
              Core.<$> ( o
                           Core..:? "blobStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "instanceCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "seriesCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> ( o
                           Core..:? "structuredStorageSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "study")
        )
  
  instance Core.ToJSON StudyMetrics where
    toJSON StudyMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("blobStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> blobStorageSizeBytes,
              ("instanceCount" Core..=)
                Core.. Core.AsText
                Core.<$> instanceCount,
              ("seriesCount" Core..=) Core.. Core.AsText Core.<$> seriesCount,
              ("structuredStorageSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> structuredStorageSizeBytes,
              ("study" Core..=) Core.<$> study
            ]
        )
  
  -- | List of tags to be filtered.
  --
  -- /See:/ 'newTagFilterList' smart constructor.
  newtype TagFilterList = TagFilterList
    { -- | Optional. Tags to be filtered. Tags must be DICOM Data Elements, File Meta Elements, or Directory Structuring Elements, as defined at: http:\/\/dicom.nema.org\/medical\/dicom\/current\/output\/html\/part06.html#table_6-1,. They may be provided by \"Keyword\" or \"Tag\". For example \"PatientID\", \"00100010\".
      tags :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TagFilterList' with the minimum fields required to make a request.
  newTagFilterList ::
    TagFilterList
  newTagFilterList = TagFilterList {tags = Core.Nothing}
  
  instance Core.FromJSON TagFilterList where
    parseJSON =
      Core.withObject
        "TagFilterList"
        (\o -> TagFilterList Core.<$> (o Core..:? "tags"))
  
  instance Core.ToJSON TagFilterList where
    toJSON TagFilterList {..} =
      Core.object (Core.catMaybes [("tags" Core..=) Core.<$> tags])
  
  -- | 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])
  
  --
  -- /See:/ 'newTextConfig' smart constructor.
  data TextConfig = TextConfig
    { -- | Optional. Transformations to apply to the detected data, overridden by @exclude_info_types@.
      additionalTransformations :: (Core.Maybe [InfoTypeTransformation]),
      -- | Optional. InfoTypes to skip transforming, overriding @additional_transformations@.
      excludeInfoTypes :: (Core.Maybe [Core.Text]),
      -- | Optional. The transformations to apply to the detected data. Deprecated. Use @additional_transformations@ instead.
      transformations :: (Core.Maybe [InfoTypeTransformation])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TextConfig' with the minimum fields required to make a request.
  newTextConfig ::
    TextConfig
  newTextConfig =
    TextConfig
      { additionalTransformations = Core.Nothing,
        excludeInfoTypes = Core.Nothing,
        transformations = Core.Nothing
      }
  
  instance Core.FromJSON TextConfig where
    parseJSON =
      Core.withObject
        "TextConfig"
        ( \o ->
            TextConfig
              Core.<$> (o Core..:? "additionalTransformations")
              Core.<*> (o Core..:? "excludeInfoTypes")
              Core.<*> (o Core..:? "transformations")
        )
  
  instance Core.ToJSON TextConfig where
    toJSON TextConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("additionalTransformations" Core..=)
                Core.<$> additionalTransformations,
              ("excludeInfoTypes" Core..=) Core.<$> excludeInfoTypes,
              ("transformations" Core..=) Core.<$> transformations
            ]
        )
  
  -- | A span of text in the provided document.
  --
  -- /See:/ 'newTextSpan' smart constructor.
  data TextSpan = TextSpan
    { -- | The unicode codepoint index of the beginning of this span.
      beginOffset :: (Core.Maybe Core.Int32),
      -- | The original text contained in this span.
      content :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TextSpan' with the minimum fields required to make a request.
  newTextSpan ::
    TextSpan
  newTextSpan =
    TextSpan {beginOffset = Core.Nothing, content = Core.Nothing}
  
  instance Core.FromJSON TextSpan where
    parseJSON =
      Core.withObject
        "TextSpan"
        ( \o ->
            TextSpan
              Core.<$> (o Core..:? "beginOffset")
              Core.<*> (o Core..:? "content")
        )
  
  instance Core.ToJSON TextSpan where
    toJSON TextSpan {..} =
      Core.object
        ( Core.catMaybes
            [ ("beginOffset" Core..=) Core.<$> beginOffset,
              ("content" Core..=) Core.<$> content
            ]
        )
  
  -- | Configuration for FHIR BigQuery time-partitioned tables.
  --
  -- /See:/ 'newTimePartitioning' smart constructor.
  data TimePartitioning = TimePartitioning
    { -- | Number of milliseconds for which to keep the storage for a partition.
      expirationMs :: (Core.Maybe Core.Int64),
      -- | Type of partitioning.
      type' :: (Core.Maybe TimePartitioning_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TimePartitioning' with the minimum fields required to make a request.
  newTimePartitioning ::
    TimePartitioning
  newTimePartitioning =
    TimePartitioning
      { expirationMs = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON TimePartitioning where
    parseJSON =
      Core.withObject
        "TimePartitioning"
        ( \o ->
            TimePartitioning
              Core.<$> (o Core..:? "expirationMs" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON TimePartitioning where
    toJSON TimePartitioning {..} =
      Core.object
        ( Core.catMaybes
            [ ("expirationMs" Core..=) Core.. Core.AsText Core.<$> expirationMs,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Apply consents given by patients whose most recent consent changes are in the time range. Note that after identifying these patients, the server applies all Consent resources given by those patients, not just the Consent resources within the timestamp in the range.
  --
  -- /See:/ 'newTimeRange' smart constructor.
  data TimeRange = TimeRange
    { -- | Optional. The latest consent change time, in format YYYY-MM-DDThh:mm:ss.sss+zz:zz If not specified, the system uses the time when ApplyConsents was called.
      end :: (Core.Maybe Core.Text),
      -- | Optional. The earliest consent change time, in format YYYY-MM-DDThh:mm:ss.sss+zz:zz If not specified, the system uses the FHIR store creation time.
      start :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TimeRange' with the minimum fields required to make a request.
  newTimeRange ::
    TimeRange
  newTimeRange = TimeRange {end = Core.Nothing, start = Core.Nothing}
  
  instance Core.FromJSON TimeRange where
    parseJSON =
      Core.withObject
        "TimeRange"
        ( \o ->
            TimeRange
              Core.<$> (o Core..:? "end")
              Core.<*> (o Core..:? "start")
        )
  
  instance Core.ToJSON TimeRange where
    toJSON TimeRange {..} =
      Core.object
        ( Core.catMaybes
            [("end" Core..=) Core.<$> end, ("start" Core..=) Core.<$> start]
        )
  
  -- | A type definition for some HL7v2 type (incl. Segments and Datatypes).
  --
  -- /See:/ 'newType' smart constructor.
  data Type = Type
    { -- | The (sub) fields this type has (if not primitive).
      fields :: (Core.Maybe [Field]),
      -- | The name of this type. This would be the segment or datatype name. For example, \"PID\" or \"XPN\".
      name :: (Core.Maybe Core.Text),
      -- | If this is a primitive type then this field is the type of the primitive For example, STRING. Leave unspecified for composite types.
      primitive' :: (Core.Maybe Type_Primitive)
    }
    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
      { fields = Core.Nothing,
        name = Core.Nothing,
        primitive' = Core.Nothing
      }
  
  instance Core.FromJSON Type where
    parseJSON =
      Core.withObject
        "Type"
        ( \o ->
            Type
              Core.<$> (o Core..:? "fields")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "primitive")
        )
  
  instance Core.ToJSON Type where
    toJSON Type {..} =
      Core.object
        ( Core.catMaybes
            [ ("fields" Core..=) Core.<$> fields,
              ("name" Core..=) Core.<$> name,
              ("primitive" Core..=) Core.<$> primitive'
            ]
        )
  
  -- | Maps a resource to the associated user and Attributes.
  --
  -- /See:/ 'newUserDataMapping' smart constructor.
  data UserDataMapping = UserDataMapping
    { -- | Output only. Indicates the time when this mapping was archived.
      archiveTime :: (Core.Maybe Core.DateTime),
      -- | Output only. Indicates whether this mapping is archived.
      archived :: (Core.Maybe Core.Bool),
      -- | Required. A unique identifier for the mapped resource.
      dataId :: (Core.Maybe Core.Text),
      -- | Resource name of the User data mapping, of the form @projects\/{project_id}\/locations\/{location_id}\/datasets\/{dataset_id}\/consentStores\/{consent_store_id}\/userDataMappings\/{user_data_mapping_id}@.
      name :: (Core.Maybe Core.Text),
      -- | Attributes of the resource. Only explicitly set attributes are displayed here. Attribute definitions with defaults set implicitly apply to these User data mappings. Attributes listed here must be single valued, that is, exactly one value is specified for the field \"values\" in each Attribute.
      resourceAttributes :: (Core.Maybe [Attribute]),
      -- | Required. User\'s UUID provided by the client.
      userId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UserDataMapping' with the minimum fields required to make a request.
  newUserDataMapping ::
    UserDataMapping
  newUserDataMapping =
    UserDataMapping
      { archiveTime = Core.Nothing,
        archived = Core.Nothing,
        dataId = Core.Nothing,
        name = Core.Nothing,
        resourceAttributes = Core.Nothing,
        userId = Core.Nothing
      }
  
  instance Core.FromJSON UserDataMapping where
    parseJSON =
      Core.withObject
        "UserDataMapping"
        ( \o ->
            UserDataMapping
              Core.<$> (o Core..:? "archiveTime")
              Core.<*> (o Core..:? "archived")
              Core.<*> (o Core..:? "dataId")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "resourceAttributes")
              Core.<*> (o Core..:? "userId")
        )
  
  instance Core.ToJSON UserDataMapping where
    toJSON UserDataMapping {..} =
      Core.object
        ( Core.catMaybes
            [ ("archiveTime" Core..=) Core.<$> archiveTime,
              ("archived" Core..=) Core.<$> archived,
              ("dataId" Core..=) Core.<$> dataId,
              ("name" Core..=) Core.<$> name,
              ("resourceAttributes" Core..=) Core.<$> resourceAttributes,
              ("userId" Core..=) Core.<$> userId
            ]
        )
  
  -- | Contains the configuration for FHIR profiles and validation.
  --
  -- /See:/ 'newValidationConfig' smart constructor.
  data ValidationConfig = ValidationConfig
    { -- | Optional. Whether to disable FHIRPath validation for incoming resources. The default value is false. Set this to true to disable checking incoming resources for conformance against FHIRPath requirement defined in the FHIR specification. This property only affects resource types that do not have profiles configured for them, any rules in enabled implementation guides will still be enforced.
      disableFhirpathValidation :: (Core.Maybe Core.Bool),
      -- | Optional. Whether to disable profile validation for this FHIR store. The default value is false. Set this to true to disable checking incoming resources for conformance against structure definitions in this FHIR store.
      disableProfileValidation :: (Core.Maybe Core.Bool),
      -- | Optional. Whether to disable reference type validation for incoming resources. The default value is false. Set this to true to disable checking incoming resources for conformance against reference type requirement defined in the FHIR specification. This property only affects resource types that do not have profiles configured for them, any rules in enabled implementation guides will still be enforced.
      disableReferenceTypeValidation :: (Core.Maybe Core.Bool),
      -- | Optional. Whether to disable required fields validation for incoming resources. The default value is false. Set this to true to disable checking incoming resources for conformance against required fields requirement defined in the FHIR specification. This property only affects resource types that do not have profiles configured for them, any rules in enabled implementation guides will still be enforced.
      disableRequiredFieldValidation :: (Core.Maybe Core.Bool),
      -- | Optional. A list of implementation guide URLs in this FHIR store that are used to configure the profiles to use for validation. For example, to use the US Core profiles for validation, set @enabled_implementation_guides@ to @[\"http:\/\/hl7.org\/fhir\/us\/core\/ImplementationGuide\/ig\"]@. If @enabled_implementation_guides@ is empty or omitted, then incoming resources are only required to conform to the base FHIR profiles. Otherwise, a resource must conform to at least one profile listed in the @global@ property of one of the enabled ImplementationGuides. The Cloud Healthcare API does not currently enforce all of the rules in a StructureDefinition. The following rules are supported: - min\/max - minValue\/maxValue - maxLength - type - fixed[x] - pattern[x] on simple types - slicing, when using \"value\" as the discriminator type When a URL cannot be resolved (for example, in a type assertion), the server does not return an error.
      enabledImplementationGuides :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ValidationConfig' with the minimum fields required to make a request.
  newValidationConfig ::
    ValidationConfig
  newValidationConfig =
    ValidationConfig
      { disableFhirpathValidation = Core.Nothing,
        disableProfileValidation = Core.Nothing,
        disableReferenceTypeValidation = Core.Nothing,
        disableRequiredFieldValidation = Core.Nothing,
        enabledImplementationGuides = Core.Nothing
      }
  
  instance Core.FromJSON ValidationConfig where
    parseJSON =
      Core.withObject
        "ValidationConfig"
        ( \o ->
            ValidationConfig
              Core.<$> (o Core..:? "disableFhirpathValidation")
              Core.<*> (o Core..:? "disableProfileValidation")
              Core.<*> (o Core..:? "disableReferenceTypeValidation")
              Core.<*> (o Core..:? "disableRequiredFieldValidation")
              Core.<*> (o Core..:? "enabledImplementationGuides")
        )
  
  instance Core.ToJSON ValidationConfig where
    toJSON ValidationConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("disableFhirpathValidation" Core..=)
                Core.<$> disableFhirpathValidation,
              ("disableProfileValidation" Core..=)
                Core.<$> disableProfileValidation,
              ("disableReferenceTypeValidation" Core..=)
                Core.<$> disableReferenceTypeValidation,
              ("disableRequiredFieldValidation" Core..=)
                Core.<$> disableRequiredFieldValidation,
              ("enabledImplementationGuides" Core..=)
                Core.<$> enabledImplementationGuides
            ]
        )
  
  -- | Describes a selector for extracting and matching an MSH field to a value.
  --
  -- /See:/ 'newVersionSource' smart constructor.
  data VersionSource = VersionSource
    { -- | The field to extract from the MSH segment. For example, \"3.1\" or \"18[1].1\".
      mshField :: (Core.Maybe Core.Text),
      -- | The value to match with the field. For example, \"My Application Name\" or \"2.3\".
      value :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'VersionSource' with the minimum fields required to make a request.
  newVersionSource ::
    VersionSource
  newVersionSource =
    VersionSource {mshField = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON VersionSource where
    parseJSON =
      Core.withObject
        "VersionSource"
        ( \o ->
            VersionSource
              Core.<$> (o Core..:? "mshField")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON VersionSource where
    toJSON VersionSource {..} =
      Core.object
        ( Core.catMaybes
            [ ("mshField" Core..=) Core.<$> mshField,
              ("value" Core..=) Core.<$> value
            ]
        )
  