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.ServiceControl.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.ServiceControl.Internal.Product
    ( -- * Api
      Api (..),
      newApi,
  
      -- * AttributeContext
      AttributeContext (..),
      newAttributeContext,
  
      -- * AttributeContext_ExtensionsItem
      AttributeContext_ExtensionsItem (..),
      newAttributeContext_ExtensionsItem,
  
      -- * AuditLog
      AuditLog (..),
      newAuditLog,
  
      -- * AuditLog_Metadata
      AuditLog_Metadata (..),
      newAuditLog_Metadata,
  
      -- * AuditLog_Request
      AuditLog_Request (..),
      newAuditLog_Request,
  
      -- * AuditLog_ResourceOriginalState
      AuditLog_ResourceOriginalState (..),
      newAuditLog_ResourceOriginalState,
  
      -- * AuditLog_Response
      AuditLog_Response (..),
      newAuditLog_Response,
  
      -- * AuditLog_ServiceData
      AuditLog_ServiceData (..),
      newAuditLog_ServiceData,
  
      -- * Auth
      Auth (..),
      newAuth,
  
      -- * Auth_Claims
      Auth_Claims (..),
      newAuth_Claims,
  
      -- * AuthenticationInfo
      AuthenticationInfo (..),
      newAuthenticationInfo,
  
      -- * AuthenticationInfo_ThirdPartyPrincipal
      AuthenticationInfo_ThirdPartyPrincipal (..),
      newAuthenticationInfo_ThirdPartyPrincipal,
  
      -- * AuthorizationInfo
      AuthorizationInfo (..),
      newAuthorizationInfo,
  
      -- * CheckRequest
      CheckRequest (..),
      newCheckRequest,
  
      -- * CheckResponse
      CheckResponse (..),
      newCheckResponse,
  
      -- * CheckResponse_DynamicMetadata
      CheckResponse_DynamicMetadata (..),
      newCheckResponse_DynamicMetadata,
  
      -- * CheckResponse_Headers
      CheckResponse_Headers (..),
      newCheckResponse_Headers,
  
      -- * FirstPartyPrincipal
      FirstPartyPrincipal (..),
      newFirstPartyPrincipal,
  
      -- * FirstPartyPrincipal_ServiceMetadata
      FirstPartyPrincipal_ServiceMetadata (..),
      newFirstPartyPrincipal_ServiceMetadata,
  
      -- * OrgPolicyViolationInfo
      OrgPolicyViolationInfo (..),
      newOrgPolicyViolationInfo,
  
      -- * OrgPolicyViolationInfo_Payload
      OrgPolicyViolationInfo_Payload (..),
      newOrgPolicyViolationInfo_Payload,
  
      -- * OrgPolicyViolationInfo_ResourceTags
      OrgPolicyViolationInfo_ResourceTags (..),
      newOrgPolicyViolationInfo_ResourceTags,
  
      -- * Peer
      Peer (..),
      newPeer,
  
      -- * Peer_Labels
      Peer_Labels (..),
      newPeer_Labels,
  
      -- * PolicyViolationInfo
      PolicyViolationInfo (..),
      newPolicyViolationInfo,
  
      -- * ReportRequest
      ReportRequest (..),
      newReportRequest,
  
      -- * ReportResponse
      ReportResponse (..),
      newReportResponse,
  
      -- * ReportResponse_Extensions
      ReportResponse_Extensions (..),
      newReportResponse_Extensions,
  
      -- * Request'
      Request' (..),
      newRequest,
  
      -- * Request_Headers
      Request_Headers (..),
      newRequest_Headers,
  
      -- * RequestMetadata
      RequestMetadata (..),
      newRequestMetadata,
  
      -- * Resource
      Resource (..),
      newResource,
  
      -- * Resource_Annotations
      Resource_Annotations (..),
      newResource_Annotations,
  
      -- * Resource_Labels
      Resource_Labels (..),
      newResource_Labels,
  
      -- * ResourceInfo
      ResourceInfo (..),
      newResourceInfo,
  
      -- * ResourceLocation
      ResourceLocation (..),
      newResourceLocation,
  
      -- * Response
      Response (..),
      newResponse,
  
      -- * Response_Headers
      Response_Headers (..),
      newResponse_Headers,
  
      -- * ServiceAccountDelegationInfo
      ServiceAccountDelegationInfo (..),
      newServiceAccountDelegationInfo,
  
      -- * ServiceDelegationHistory
      ServiceDelegationHistory (..),
      newServiceDelegationHistory,
  
      -- * ServiceMetadata
      ServiceMetadata (..),
      newServiceMetadata,
  
      -- * ServiceMetadata_JobMetadata
      ServiceMetadata_JobMetadata (..),
      newServiceMetadata_JobMetadata,
  
      -- * SpanContext
      SpanContext (..),
      newSpanContext,
  
      -- * Status
      Status (..),
      newStatus,
  
      -- * Status_DetailsItem
      Status_DetailsItem (..),
      newStatus_DetailsItem,
  
      -- * ThirdPartyPrincipal
      ThirdPartyPrincipal (..),
      newThirdPartyPrincipal,
  
      -- * ThirdPartyPrincipal_ThirdPartyClaims
      ThirdPartyPrincipal_ThirdPartyClaims (..),
      newThirdPartyPrincipal_ThirdPartyClaims,
  
      -- * V2HttpRequest
      V2HttpRequest (..),
      newV2HttpRequest,
  
      -- * V2LogEntry
      V2LogEntry (..),
      newV2LogEntry,
  
      -- * V2LogEntry_Labels
      V2LogEntry_Labels (..),
      newV2LogEntry_Labels,
  
      -- * V2LogEntry_MonitoredResourceLabels
      V2LogEntry_MonitoredResourceLabels (..),
      newV2LogEntry_MonitoredResourceLabels,
  
      -- * V2LogEntry_ProtoPayload
      V2LogEntry_ProtoPayload (..),
      newV2LogEntry_ProtoPayload,
  
      -- * V2LogEntry_StructPayload
      V2LogEntry_StructPayload (..),
      newV2LogEntry_StructPayload,
  
      -- * V2LogEntryOperation
      V2LogEntryOperation (..),
      newV2LogEntryOperation,
  
      -- * V2LogEntrySourceLocation
      V2LogEntrySourceLocation (..),
      newV2LogEntrySourceLocation,
  
      -- * V2ResourceEvent
      V2ResourceEvent (..),
      newV2ResourceEvent,
  
      -- * V2ResourceEvent_Payload
      V2ResourceEvent_Payload (..),
      newV2ResourceEvent_Payload,
  
      -- * ViolationInfo
      ViolationInfo (..),
      newViolationInfo,
    )
  where
  
  import Gogol.Prelude qualified as Core
  import Gogol.ServiceControl.Internal.Sum
  
  -- | This message defines attributes associated with API operations, such as a network API request. The terminology is based on the conventions used by Google APIs, Istio, and OpenAPI.
  --
  -- /See:/ 'newApi' smart constructor.
  data Api = Api
    { -- | The API operation name. For gRPC requests, it is the fully qualified API method name, such as \"google.pubsub.v1.Publisher.Publish\". For OpenAPI requests, it is the @operationId@, such as \"getPet\".
      operation :: (Core.Maybe Core.Text),
      -- | The API protocol used for sending the request, such as \"http\", \"https\", \"grpc\", or \"internal\".
      protocol :: (Core.Maybe Core.Text),
      -- | The API service name. It is a logical identifier for a networked API, such as \"pubsub.googleapis.com\". The naming syntax depends on the API management system being used for handling the request.
      service :: (Core.Maybe Core.Text),
      -- | The API version associated with the API operation above, such as \"v1\" or \"v1alpha1\".
      version :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Api' with the minimum fields required to make a request.
  newApi ::
    Api
  newApi =
    Api
      { operation = Core.Nothing,
        protocol = Core.Nothing,
        service = Core.Nothing,
        version = Core.Nothing
      }
  
  instance Core.FromJSON Api where
    parseJSON =
      Core.withObject
        "Api"
        ( \o ->
            Api
              Core.<$> (o Core..:? "operation")
              Core.<*> (o Core..:? "protocol")
              Core.<*> (o Core..:? "service")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON Api where
    toJSON Api {..} =
      Core.object
        ( Core.catMaybes
            [ ("operation" Core..=) Core.<$> operation,
              ("protocol" Core..=) Core.<$> protocol,
              ("service" Core..=) Core.<$> service,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | This message defines the standard attribute vocabulary for Google APIs. An attribute is a piece of metadata that describes an activity on a network service. For example, the size of an HTTP request, or the status code of an HTTP response. Each attribute has a type and a name, which is logically defined as a proto message field in @AttributeContext@. The field type becomes the attribute type, and the field path becomes the attribute name. For example, the attribute @source.ip@ maps to field @AttributeContext.source.ip@. This message definition is guaranteed not to have any wire breaking change. So you can use it directly for passing attributes across different systems. NOTE: Different system may generate different subset of attributes. Please verify the system specification before relying on an attribute generated a system.
  --
  -- /See:/ 'newAttributeContext' smart constructor.
  data AttributeContext = AttributeContext
    { -- | Represents an API operation that is involved to a network activity.
      api :: (Core.Maybe Api),
      -- | The destination of a network activity, such as accepting a TCP connection. In a multi hop network activity, the destination represents the receiver of the last hop.
      destination :: (Core.Maybe Peer),
      -- | Supports extensions for advanced use cases, such as logs and metrics.
      extensions :: (Core.Maybe [AttributeContext_ExtensionsItem]),
      -- | The origin of a network activity. In a multi hop network activity, the origin represents the sender of the first hop. For the first hop, the @source@ and the @origin@ must have the same content.
      origin :: (Core.Maybe Peer),
      -- | Represents a network request, such as an HTTP request.
      request' :: (Core.Maybe Request'),
      -- | Represents a target resource that is involved with a network activity. If multiple resources are involved with an activity, this must be the primary one.
      resource :: (Core.Maybe Resource),
      -- | Represents a network response, such as an HTTP response.
      response :: (Core.Maybe Response),
      -- | The source of a network activity, such as starting a TCP connection. In a multi hop network activity, the source represents the sender of the last hop.
      source :: (Core.Maybe Peer)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AttributeContext' with the minimum fields required to make a request.
  newAttributeContext ::
    AttributeContext
  newAttributeContext =
    AttributeContext
      { api = Core.Nothing,
        destination = Core.Nothing,
        extensions = Core.Nothing,
        origin = Core.Nothing,
        request' = Core.Nothing,
        resource = Core.Nothing,
        response = Core.Nothing,
        source = Core.Nothing
      }
  
  instance Core.FromJSON AttributeContext where
    parseJSON =
      Core.withObject
        "AttributeContext"
        ( \o ->
            AttributeContext
              Core.<$> (o Core..:? "api")
              Core.<*> (o Core..:? "destination")
              Core.<*> (o Core..:? "extensions")
              Core.<*> (o Core..:? "origin")
              Core.<*> (o Core..:? "request")
              Core.<*> (o Core..:? "resource")
              Core.<*> (o Core..:? "response")
              Core.<*> (o Core..:? "source")
        )
  
  instance Core.ToJSON AttributeContext where
    toJSON AttributeContext {..} =
      Core.object
        ( Core.catMaybes
            [ ("api" Core..=) Core.<$> api,
              ("destination" Core..=) Core.<$> destination,
              ("extensions" Core..=) Core.<$> extensions,
              ("origin" Core..=) Core.<$> origin,
              ("request" Core..=) Core.<$> request',
              ("resource" Core..=) Core.<$> resource,
              ("response" Core..=) Core.<$> response,
              ("source" Core..=) Core.<$> source
            ]
        )
  
  --
  -- /See:/ 'newAttributeContext_ExtensionsItem' smart constructor.
  newtype AttributeContext_ExtensionsItem = AttributeContext_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 'AttributeContext_ExtensionsItem' with the minimum fields required to make a request.
  newAttributeContext_ExtensionsItem ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    AttributeContext_ExtensionsItem
  newAttributeContext_ExtensionsItem additional =
    AttributeContext_ExtensionsItem {additional = additional}
  
  instance Core.FromJSON AttributeContext_ExtensionsItem where
    parseJSON =
      Core.withObject
        "AttributeContext_ExtensionsItem"
        ( \o ->
            AttributeContext_ExtensionsItem Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON AttributeContext_ExtensionsItem where
    toJSON AttributeContext_ExtensionsItem {..} = Core.toJSON additional
  
  -- | Common audit log format for Google Cloud Platform API operations.
  --
  -- /See:/ 'newAuditLog' smart constructor.
  data AuditLog = AuditLog
    { -- | Authentication information.
      authenticationInfo :: (Core.Maybe AuthenticationInfo),
      -- | Authorization information. If there are multiple resources or permissions involved, then there is one AuthorizationInfo element for each {resource, permission} tuple.
      authorizationInfo :: (Core.Maybe [AuthorizationInfo]),
      -- | Other service-specific data about the request, response, and other information associated with the current audited event.
      metadata :: (Core.Maybe AuditLog_Metadata),
      -- | The name of the service method or operation. For API calls, this should be the name of the API method. For example, \"google.cloud.bigquery.v2.TableService.InsertTable\" \"google.logging.v2.ConfigServiceV2.CreateSink\"
      methodName :: (Core.Maybe Core.Text),
      -- | The number of items returned from a List or Query API method, if applicable.
      numResponseItems :: (Core.Maybe Core.Int64),
      -- | Indicates the policy violations for this request. If the request is denied by the policy, violation information will be logged here.
      policyViolationInfo :: (Core.Maybe PolicyViolationInfo),
      -- | The operation request. This may not include all request parameters, such as those that are too large, privacy-sensitive, or duplicated elsewhere in the log record. It should never include user-generated data, such as file contents. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
      request' :: (Core.Maybe AuditLog_Request),
      -- | Metadata about the operation.
      requestMetadata :: (Core.Maybe RequestMetadata),
      -- | The resource location information.
      resourceLocation :: (Core.Maybe ResourceLocation),
      -- | The resource or collection that is the target of the operation. The name is a scheme-less URI, not including the API service name. For example: \"projects\/PROJECT/ID\/zones\/us-central1-a\/instances\" \"projects\/PROJECT/ID\/datasets\/DATASET_ID\"
      resourceName :: (Core.Maybe Core.Text),
      -- | The resource\'s original state before mutation. Present only for operations which have successfully modified the targeted resource(s). In general, this field should contain all changed fields, except those that are already been included in @request@, @response@, @metadata@ or @service_data@ fields. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
      resourceOriginalState :: (Core.Maybe AuditLog_ResourceOriginalState),
      -- | The operation response. This may not include all response elements, such as those that are too large, privacy-sensitive, or duplicated elsewhere in the log record. It should never include user-generated data, such as file contents. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
      response :: (Core.Maybe AuditLog_Response),
      -- | Deprecated. Use the @metadata@ field instead. Other service-specific data about the request, response, and other activities.
      serviceData :: (Core.Maybe AuditLog_ServiceData),
      -- | The name of the API service performing the operation. For example, @\"compute.googleapis.com\"@.
      serviceName :: (Core.Maybe Core.Text),
      -- | The status of the overall operation.
      status :: (Core.Maybe Status)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuditLog' with the minimum fields required to make a request.
  newAuditLog ::
    AuditLog
  newAuditLog =
    AuditLog
      { authenticationInfo = Core.Nothing,
        authorizationInfo = Core.Nothing,
        metadata = Core.Nothing,
        methodName = Core.Nothing,
        numResponseItems = Core.Nothing,
        policyViolationInfo = Core.Nothing,
        request' = Core.Nothing,
        requestMetadata = Core.Nothing,
        resourceLocation = Core.Nothing,
        resourceName = Core.Nothing,
        resourceOriginalState = Core.Nothing,
        response = Core.Nothing,
        serviceData = Core.Nothing,
        serviceName = Core.Nothing,
        status = Core.Nothing
      }
  
  instance Core.FromJSON AuditLog where
    parseJSON =
      Core.withObject
        "AuditLog"
        ( \o ->
            AuditLog
              Core.<$> (o Core..:? "authenticationInfo")
              Core.<*> (o Core..:? "authorizationInfo")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "methodName")
              Core.<*> (o Core..:? "numResponseItems" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "policyViolationInfo")
              Core.<*> (o Core..:? "request")
              Core.<*> (o Core..:? "requestMetadata")
              Core.<*> (o Core..:? "resourceLocation")
              Core.<*> (o Core..:? "resourceName")
              Core.<*> (o Core..:? "resourceOriginalState")
              Core.<*> (o Core..:? "response")
              Core.<*> (o Core..:? "serviceData")
              Core.<*> (o Core..:? "serviceName")
              Core.<*> (o Core..:? "status")
        )
  
  instance Core.ToJSON AuditLog where
    toJSON AuditLog {..} =
      Core.object
        ( Core.catMaybes
            [ ("authenticationInfo" Core..=) Core.<$> authenticationInfo,
              ("authorizationInfo" Core..=) Core.<$> authorizationInfo,
              ("metadata" Core..=) Core.<$> metadata,
              ("methodName" Core..=) Core.<$> methodName,
              ("numResponseItems" Core..=)
                Core.. Core.AsText
                Core.<$> numResponseItems,
              ("policyViolationInfo" Core..=) Core.<$> policyViolationInfo,
              ("request" Core..=) Core.<$> request',
              ("requestMetadata" Core..=) Core.<$> requestMetadata,
              ("resourceLocation" Core..=) Core.<$> resourceLocation,
              ("resourceName" Core..=) Core.<$> resourceName,
              ("resourceOriginalState" Core..=) Core.<$> resourceOriginalState,
              ("response" Core..=) Core.<$> response,
              ("serviceData" Core..=) Core.<$> serviceData,
              ("serviceName" Core..=) Core.<$> serviceName,
              ("status" Core..=) Core.<$> status
            ]
        )
  
  -- | Other service-specific data about the request, response, and other information associated with the current audited event.
  --
  -- /See:/ 'newAuditLog_Metadata' smart constructor.
  newtype AuditLog_Metadata = AuditLog_Metadata
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuditLog_Metadata' with the minimum fields required to make a request.
  newAuditLog_Metadata ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    AuditLog_Metadata
  newAuditLog_Metadata additional =
    AuditLog_Metadata {additional = additional}
  
  instance Core.FromJSON AuditLog_Metadata where
    parseJSON =
      Core.withObject
        "AuditLog_Metadata"
        (\o -> AuditLog_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON AuditLog_Metadata where
    toJSON AuditLog_Metadata {..} = Core.toJSON additional
  
  -- | The operation request. This may not include all request parameters, such as those that are too large, privacy-sensitive, or duplicated elsewhere in the log record. It should never include user-generated data, such as file contents. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
  --
  -- /See:/ 'newAuditLog_Request' smart constructor.
  newtype AuditLog_Request = AuditLog_Request
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuditLog_Request' with the minimum fields required to make a request.
  newAuditLog_Request ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    AuditLog_Request
  newAuditLog_Request additional =
    AuditLog_Request {additional = additional}
  
  instance Core.FromJSON AuditLog_Request where
    parseJSON =
      Core.withObject
        "AuditLog_Request"
        (\o -> AuditLog_Request Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON AuditLog_Request where
    toJSON AuditLog_Request {..} = Core.toJSON additional
  
  -- | The resource\'s original state before mutation. Present only for operations which have successfully modified the targeted resource(s). In general, this field should contain all changed fields, except those that are already been included in @request@, @response@, @metadata@ or @service_data@ fields. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
  --
  -- /See:/ 'newAuditLog_ResourceOriginalState' smart constructor.
  newtype AuditLog_ResourceOriginalState = AuditLog_ResourceOriginalState
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuditLog_ResourceOriginalState' with the minimum fields required to make a request.
  newAuditLog_ResourceOriginalState ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    AuditLog_ResourceOriginalState
  newAuditLog_ResourceOriginalState additional =
    AuditLog_ResourceOriginalState {additional = additional}
  
  instance Core.FromJSON AuditLog_ResourceOriginalState where
    parseJSON =
      Core.withObject
        "AuditLog_ResourceOriginalState"
        ( \o ->
            AuditLog_ResourceOriginalState Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON AuditLog_ResourceOriginalState where
    toJSON AuditLog_ResourceOriginalState {..} = Core.toJSON additional
  
  -- | The operation response. This may not include all response elements, such as those that are too large, privacy-sensitive, or duplicated elsewhere in the log record. It should never include user-generated data, such as file contents. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
  --
  -- /See:/ 'newAuditLog_Response' smart constructor.
  newtype AuditLog_Response = AuditLog_Response
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuditLog_Response' with the minimum fields required to make a request.
  newAuditLog_Response ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    AuditLog_Response
  newAuditLog_Response additional =
    AuditLog_Response {additional = additional}
  
  instance Core.FromJSON AuditLog_Response where
    parseJSON =
      Core.withObject
        "AuditLog_Response"
        (\o -> AuditLog_Response Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON AuditLog_Response where
    toJSON AuditLog_Response {..} = Core.toJSON additional
  
  -- | Deprecated. Use the @metadata@ field instead. Other service-specific data about the request, response, and other activities.
  --
  -- /See:/ 'newAuditLog_ServiceData' smart constructor.
  newtype AuditLog_ServiceData = AuditLog_ServiceData
    { -- | 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 'AuditLog_ServiceData' with the minimum fields required to make a request.
  newAuditLog_ServiceData ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    AuditLog_ServiceData
  newAuditLog_ServiceData additional =
    AuditLog_ServiceData {additional = additional}
  
  instance Core.FromJSON AuditLog_ServiceData where
    parseJSON =
      Core.withObject
        "AuditLog_ServiceData"
        (\o -> AuditLog_ServiceData Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON AuditLog_ServiceData where
    toJSON AuditLog_ServiceData {..} = Core.toJSON additional
  
  -- | This message defines request authentication attributes. Terminology is based on the JSON Web Token (JWT) standard, but the terms also correlate to concepts in other standards.
  --
  -- /See:/ 'newAuth' smart constructor.
  data Auth = Auth
    { -- | A list of access level resource names that allow resources to be accessed by authenticated requester. It is part of Secure GCP processing for the incoming request. An access level string has the format: \"\/\/{api/service/name}\/accessPolicies\/{policy/id}\/accessLevels\/{short/name}\" Example: \"\/\/accesscontextmanager.googleapis.com\/accessPolicies\/MY/POLICY/ID\/accessLevels\/MY_LEVEL\"
      accessLevels :: (Core.Maybe [Core.Text]),
      -- | The intended audience(s) for this authentication information. Reflects the audience (@aud@) claim within a JWT. The audience value(s) depends on the @issuer@, but typically include one or more of the following pieces of information: * The services intended to receive the credential. For example, [\"https:\/\/pubsub.googleapis.com\/\", \"https:\/\/storage.googleapis.com\/\"]. * A set of service-based scopes. For example, [\"https:\/\/www.googleapis.com\/auth\/cloud-platform\"]. * The client id of an app, such as the Firebase project id for JWTs from Firebase Auth. Consult the documentation for the credential issuer to determine the information provided.
      audiences :: (Core.Maybe [Core.Text]),
      -- | Structured claims presented with the credential. JWTs include @{key: value}@ pairs for standard and private claims. The following is a subset of the standard required and optional claims that would typically be presented for a Google-based JWT: {\'iss\': \'accounts.google.com\', \'sub\': \'113289723416554971153\', \'aud\': [\'123456789012\', \'pubsub.googleapis.com\'], \'azp\': \'123456789012.apps.googleusercontent.com\', \'email\': \'jsmith\@example.com\', \'iat\': 1353601026, \'exp\': 1353604926} SAML assertions are similarly specified, but with an identity provider dependent structure.
      claims :: (Core.Maybe Auth_Claims),
      -- | The authorized presenter of the credential. Reflects the optional Authorized Presenter (@azp@) claim within a JWT or the OAuth client id. For example, a Google Cloud Platform client id looks as follows: \"123456789012.apps.googleusercontent.com\".
      presenter :: (Core.Maybe Core.Text),
      -- | The authenticated principal. Reflects the issuer (@iss@) and subject (@sub@) claims within a JWT. The issuer and subject should be @\/@ delimited, with @\/@ percent-encoded within the subject fragment. For Google accounts, the principal format is: \"https:\/\/accounts.google.com\/{id}\"
      principal :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Auth' with the minimum fields required to make a request.
  newAuth ::
    Auth
  newAuth =
    Auth
      { accessLevels = Core.Nothing,
        audiences = Core.Nothing,
        claims = Core.Nothing,
        presenter = Core.Nothing,
        principal = Core.Nothing
      }
  
  instance Core.FromJSON Auth where
    parseJSON =
      Core.withObject
        "Auth"
        ( \o ->
            Auth
              Core.<$> (o Core..:? "accessLevels")
              Core.<*> (o Core..:? "audiences")
              Core.<*> (o Core..:? "claims")
              Core.<*> (o Core..:? "presenter")
              Core.<*> (o Core..:? "principal")
        )
  
  instance Core.ToJSON Auth where
    toJSON Auth {..} =
      Core.object
        ( Core.catMaybes
            [ ("accessLevels" Core..=) Core.<$> accessLevels,
              ("audiences" Core..=) Core.<$> audiences,
              ("claims" Core..=) Core.<$> claims,
              ("presenter" Core..=) Core.<$> presenter,
              ("principal" Core..=) Core.<$> principal
            ]
        )
  
  -- | Structured claims presented with the credential. JWTs include @{key: value}@ pairs for standard and private claims. The following is a subset of the standard required and optional claims that would typically be presented for a Google-based JWT: {\'iss\': \'accounts.google.com\', \'sub\': \'113289723416554971153\', \'aud\': [\'123456789012\', \'pubsub.googleapis.com\'], \'azp\': \'123456789012.apps.googleusercontent.com\', \'email\': \'jsmith\@example.com\', \'iat\': 1353601026, \'exp\': 1353604926} SAML assertions are similarly specified, but with an identity provider dependent structure.
  --
  -- /See:/ 'newAuth_Claims' smart constructor.
  newtype Auth_Claims = Auth_Claims
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Auth_Claims' with the minimum fields required to make a request.
  newAuth_Claims ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Auth_Claims
  newAuth_Claims additional = Auth_Claims {additional = additional}
  
  instance Core.FromJSON Auth_Claims where
    parseJSON =
      Core.withObject
        "Auth_Claims"
        (\o -> Auth_Claims Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Auth_Claims where
    toJSON Auth_Claims {..} = Core.toJSON additional
  
  -- | Authentication information for the operation.
  --
  -- /See:/ 'newAuthenticationInfo' smart constructor.
  data AuthenticationInfo = AuthenticationInfo
    { -- | The authority selector specified by the requestor, if any. It is not guaranteed that the principal was allowed to use this authority.
      authoritySelector :: (Core.Maybe Core.Text),
      -- | The email address of the authenticated user (or service account on behalf of third party principal) making the request. For third party identity callers, the @principal_subject@ field is populated instead of this field. For privacy reasons, the principal email address is sometimes redacted. For more information, see <https://cloud.google.com/logging/docs/audit#user-id Caller identities in audit logs>.
      principalEmail :: (Core.Maybe Core.Text),
      -- | String representation of identity of requesting party. Populated for both first and third party identities.
      principalSubject :: (Core.Maybe Core.Text),
      -- | Identity delegation history of an authenticated service account that makes the request. It contains information on the real authorities that try to access GCP resources by delegating on a service account. When multiple authorities present, they are guaranteed to be sorted based on the original ordering of the identity delegation events.
      serviceAccountDelegationInfo :: (Core.Maybe [ServiceAccountDelegationInfo]),
      -- | The name of the service account key used to create or exchange credentials for authenticating the service account making the request. This is a scheme-less URI full resource name. For example: \"\/\/iam.googleapis.com\/projects\/{PROJECT_ID}\/serviceAccounts\/{ACCOUNT}\/keys\/{key}\"
      serviceAccountKeyName :: (Core.Maybe Core.Text),
      -- | Records the history of delegated resource access across Google services.
      serviceDelegationHistory :: (Core.Maybe ServiceDelegationHistory),
      -- | The third party identification (if any) of the authenticated user making the request. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
      thirdPartyPrincipal :: (Core.Maybe AuthenticationInfo_ThirdPartyPrincipal)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuthenticationInfo' with the minimum fields required to make a request.
  newAuthenticationInfo ::
    AuthenticationInfo
  newAuthenticationInfo =
    AuthenticationInfo
      { authoritySelector = Core.Nothing,
        principalEmail = Core.Nothing,
        principalSubject = Core.Nothing,
        serviceAccountDelegationInfo = Core.Nothing,
        serviceAccountKeyName = Core.Nothing,
        serviceDelegationHistory = Core.Nothing,
        thirdPartyPrincipal = Core.Nothing
      }
  
  instance Core.FromJSON AuthenticationInfo where
    parseJSON =
      Core.withObject
        "AuthenticationInfo"
        ( \o ->
            AuthenticationInfo
              Core.<$> (o Core..:? "authoritySelector")
              Core.<*> (o Core..:? "principalEmail")
              Core.<*> (o Core..:? "principalSubject")
              Core.<*> (o Core..:? "serviceAccountDelegationInfo")
              Core.<*> (o Core..:? "serviceAccountKeyName")
              Core.<*> (o Core..:? "serviceDelegationHistory")
              Core.<*> (o Core..:? "thirdPartyPrincipal")
        )
  
  instance Core.ToJSON AuthenticationInfo where
    toJSON AuthenticationInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("authoritySelector" Core..=) Core.<$> authoritySelector,
              ("principalEmail" Core..=) Core.<$> principalEmail,
              ("principalSubject" Core..=) Core.<$> principalSubject,
              ("serviceAccountDelegationInfo" Core..=)
                Core.<$> serviceAccountDelegationInfo,
              ("serviceAccountKeyName" Core..=) Core.<$> serviceAccountKeyName,
              ("serviceDelegationHistory" Core..=)
                Core.<$> serviceDelegationHistory,
              ("thirdPartyPrincipal" Core..=) Core.<$> thirdPartyPrincipal
            ]
        )
  
  -- | The third party identification (if any) of the authenticated user making the request. When the JSON object represented here has a proto equivalent, the proto name will be indicated in the @\@type@ property.
  --
  -- /See:/ 'newAuthenticationInfo_ThirdPartyPrincipal' smart constructor.
  newtype AuthenticationInfo_ThirdPartyPrincipal = AuthenticationInfo_ThirdPartyPrincipal
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuthenticationInfo_ThirdPartyPrincipal' with the minimum fields required to make a request.
  newAuthenticationInfo_ThirdPartyPrincipal ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    AuthenticationInfo_ThirdPartyPrincipal
  newAuthenticationInfo_ThirdPartyPrincipal additional =
    AuthenticationInfo_ThirdPartyPrincipal {additional = additional}
  
  instance Core.FromJSON AuthenticationInfo_ThirdPartyPrincipal where
    parseJSON =
      Core.withObject
        "AuthenticationInfo_ThirdPartyPrincipal"
        ( \o ->
            AuthenticationInfo_ThirdPartyPrincipal
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON AuthenticationInfo_ThirdPartyPrincipal where
    toJSON AuthenticationInfo_ThirdPartyPrincipal {..} =
      Core.toJSON additional
  
  -- | Authorization information for the operation.
  --
  -- /See:/ 'newAuthorizationInfo' smart constructor.
  data AuthorizationInfo = AuthorizationInfo
    { -- | Whether or not authorization for @resource@ and @permission@ was granted.
      granted :: (Core.Maybe Core.Bool),
      -- | The required IAM permission.
      permission :: (Core.Maybe Core.Text),
      -- | The type of the permission that was checked. For data access audit logs this corresponds with the permission type that must be enabled in the project\/folder\/organization IAM policy in order for the log to be written.
      permissionType :: (Core.Maybe AuthorizationInfo_PermissionType),
      -- | The resource being accessed, as a REST-style or cloud resource string. For example: bigquery.googleapis.com\/projects\/PROJECTID\/datasets\/DATASETID or projects\/PROJECTID\/datasets\/DATASETID
      resource :: (Core.Maybe Core.Text),
      -- | Resource attributes used in IAM condition evaluation. This field contains resource attributes like resource type and resource name. To get the whole view of the attributes used in IAM condition evaluation, the user must also look into @AuditLog.request_metadata.request_attributes@.
      resourceAttributes :: (Core.Maybe Resource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuthorizationInfo' with the minimum fields required to make a request.
  newAuthorizationInfo ::
    AuthorizationInfo
  newAuthorizationInfo =
    AuthorizationInfo
      { granted = Core.Nothing,
        permission = Core.Nothing,
        permissionType = Core.Nothing,
        resource = Core.Nothing,
        resourceAttributes = Core.Nothing
      }
  
  instance Core.FromJSON AuthorizationInfo where
    parseJSON =
      Core.withObject
        "AuthorizationInfo"
        ( \o ->
            AuthorizationInfo
              Core.<$> (o Core..:? "granted")
              Core.<*> (o Core..:? "permission")
              Core.<*> (o Core..:? "permissionType")
              Core.<*> (o Core..:? "resource")
              Core.<*> (o Core..:? "resourceAttributes")
        )
  
  instance Core.ToJSON AuthorizationInfo where
    toJSON AuthorizationInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("granted" Core..=) Core.<$> granted,
              ("permission" Core..=) Core.<$> permission,
              ("permissionType" Core..=) Core.<$> permissionType,
              ("resource" Core..=) Core.<$> resource,
              ("resourceAttributes" Core..=) Core.<$> resourceAttributes
            ]
        )
  
  -- | Request message for the Check method.
  --
  -- /See:/ 'newCheckRequest' smart constructor.
  data CheckRequest = CheckRequest
    { -- | Describes attributes about the operation being executed by the service.
      attributes :: (Core.Maybe AttributeContext),
      -- | Optional. Contains a comma-separated list of flags.
      flags :: (Core.Maybe Core.Text),
      -- | Describes the resources and the policies applied to each resource.
      resources :: (Core.Maybe [ResourceInfo]),
      -- | Specifies the version of the service configuration that should be used to process the request. Must not be empty. Set this field to \'latest\' to specify using the latest configuration.
      serviceConfigId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckRequest' with the minimum fields required to make a request.
  newCheckRequest ::
    CheckRequest
  newCheckRequest =
    CheckRequest
      { attributes = Core.Nothing,
        flags = Core.Nothing,
        resources = Core.Nothing,
        serviceConfigId = Core.Nothing
      }
  
  instance Core.FromJSON CheckRequest where
    parseJSON =
      Core.withObject
        "CheckRequest"
        ( \o ->
            CheckRequest
              Core.<$> (o Core..:? "attributes")
              Core.<*> (o Core..:? "flags")
              Core.<*> (o Core..:? "resources")
              Core.<*> (o Core..:? "serviceConfigId")
        )
  
  instance Core.ToJSON CheckRequest where
    toJSON CheckRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("attributes" Core..=) Core.<$> attributes,
              ("flags" Core..=) Core.<$> flags,
              ("resources" Core..=) Core.<$> resources,
              ("serviceConfigId" Core..=) Core.<$> serviceConfigId
            ]
        )
  
  -- | Response message for the Check method.
  --
  -- /See:/ 'newCheckResponse' smart constructor.
  data CheckResponse = CheckResponse
    { -- | Optional response metadata that will be emitted as dynamic metadata to be consumed by the caller of ServiceController. For compatibility with the ext_authz interface.
      dynamicMetadata :: (Core.Maybe CheckResponse_DynamicMetadata),
      -- | Returns a set of request contexts generated from the @CheckRequest@.
      headers :: (Core.Maybe CheckResponse_Headers),
      -- | Operation is allowed when this field is not set. Any non-\'OK\' status indicates a denial; google.rpc.Status.details would contain additional details about the denial.
      status :: (Core.Maybe Status)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckResponse' with the minimum fields required to make a request.
  newCheckResponse ::
    CheckResponse
  newCheckResponse =
    CheckResponse
      { dynamicMetadata = Core.Nothing,
        headers = Core.Nothing,
        status = Core.Nothing
      }
  
  instance Core.FromJSON CheckResponse where
    parseJSON =
      Core.withObject
        "CheckResponse"
        ( \o ->
            CheckResponse
              Core.<$> (o Core..:? "dynamicMetadata")
              Core.<*> (o Core..:? "headers")
              Core.<*> (o Core..:? "status")
        )
  
  instance Core.ToJSON CheckResponse where
    toJSON CheckResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("dynamicMetadata" Core..=) Core.<$> dynamicMetadata,
              ("headers" Core..=) Core.<$> headers,
              ("status" Core..=) Core.<$> status
            ]
        )
  
  -- | Optional response metadata that will be emitted as dynamic metadata to be consumed by the caller of ServiceController. For compatibility with the ext_authz interface.
  --
  -- /See:/ 'newCheckResponse_DynamicMetadata' smart constructor.
  newtype CheckResponse_DynamicMetadata = CheckResponse_DynamicMetadata
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckResponse_DynamicMetadata' with the minimum fields required to make a request.
  newCheckResponse_DynamicMetadata ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    CheckResponse_DynamicMetadata
  newCheckResponse_DynamicMetadata additional =
    CheckResponse_DynamicMetadata {additional = additional}
  
  instance Core.FromJSON CheckResponse_DynamicMetadata where
    parseJSON =
      Core.withObject
        "CheckResponse_DynamicMetadata"
        ( \o ->
            CheckResponse_DynamicMetadata Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON CheckResponse_DynamicMetadata where
    toJSON CheckResponse_DynamicMetadata {..} = Core.toJSON additional
  
  -- | Returns a set of request contexts generated from the @CheckRequest@.
  --
  -- /See:/ 'newCheckResponse_Headers' smart constructor.
  newtype CheckResponse_Headers = CheckResponse_Headers
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CheckResponse_Headers' with the minimum fields required to make a request.
  newCheckResponse_Headers ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    CheckResponse_Headers
  newCheckResponse_Headers additional =
    CheckResponse_Headers {additional = additional}
  
  instance Core.FromJSON CheckResponse_Headers where
    parseJSON =
      Core.withObject
        "CheckResponse_Headers"
        (\o -> CheckResponse_Headers Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON CheckResponse_Headers where
    toJSON CheckResponse_Headers {..} = Core.toJSON additional
  
  -- | First party identity principal.
  --
  -- /See:/ 'newFirstPartyPrincipal' smart constructor.
  data FirstPartyPrincipal = FirstPartyPrincipal
    { -- | The email address of a Google account. .
      principalEmail :: (Core.Maybe Core.Text),
      -- | Metadata about the service that uses the service account. .
      serviceMetadata :: (Core.Maybe FirstPartyPrincipal_ServiceMetadata)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FirstPartyPrincipal' with the minimum fields required to make a request.
  newFirstPartyPrincipal ::
    FirstPartyPrincipal
  newFirstPartyPrincipal =
    FirstPartyPrincipal
      { principalEmail = Core.Nothing,
        serviceMetadata = Core.Nothing
      }
  
  instance Core.FromJSON FirstPartyPrincipal where
    parseJSON =
      Core.withObject
        "FirstPartyPrincipal"
        ( \o ->
            FirstPartyPrincipal
              Core.<$> (o Core..:? "principalEmail")
              Core.<*> (o Core..:? "serviceMetadata")
        )
  
  instance Core.ToJSON FirstPartyPrincipal where
    toJSON FirstPartyPrincipal {..} =
      Core.object
        ( Core.catMaybes
            [ ("principalEmail" Core..=) Core.<$> principalEmail,
              ("serviceMetadata" Core..=) Core.<$> serviceMetadata
            ]
        )
  
  -- | Metadata about the service that uses the service account. .
  --
  -- /See:/ 'newFirstPartyPrincipal_ServiceMetadata' smart constructor.
  newtype FirstPartyPrincipal_ServiceMetadata = FirstPartyPrincipal_ServiceMetadata
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FirstPartyPrincipal_ServiceMetadata' with the minimum fields required to make a request.
  newFirstPartyPrincipal_ServiceMetadata ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    FirstPartyPrincipal_ServiceMetadata
  newFirstPartyPrincipal_ServiceMetadata additional =
    FirstPartyPrincipal_ServiceMetadata {additional = additional}
  
  instance Core.FromJSON FirstPartyPrincipal_ServiceMetadata where
    parseJSON =
      Core.withObject
        "FirstPartyPrincipal_ServiceMetadata"
        ( \o ->
            FirstPartyPrincipal_ServiceMetadata
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON FirstPartyPrincipal_ServiceMetadata where
    toJSON FirstPartyPrincipal_ServiceMetadata {..} =
      Core.toJSON additional
  
  -- | Represents OrgPolicy Violation information.
  --
  -- /See:/ 'newOrgPolicyViolationInfo' smart constructor.
  data OrgPolicyViolationInfo = OrgPolicyViolationInfo
    { -- | Optional. Deprecated. Resource payload that is currently in scope and is subjected to orgpolicy conditions. This payload may be the subset of the actual Resource that may come in the request.
      payload :: (Core.Maybe OrgPolicyViolationInfo_Payload),
      -- | Optional. Deprecated. Tags referenced on the resource at the time of evaluation.
      resourceTags :: (Core.Maybe OrgPolicyViolationInfo_ResourceTags),
      -- | Optional. Resource type that the orgpolicy is checked against. Example: compute.googleapis.com\/Instance, store.googleapis.com\/bucket
      resourceType :: (Core.Maybe Core.Text),
      -- | Optional. Policy violations
      violationInfo :: (Core.Maybe [ViolationInfo])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OrgPolicyViolationInfo' with the minimum fields required to make a request.
  newOrgPolicyViolationInfo ::
    OrgPolicyViolationInfo
  newOrgPolicyViolationInfo =
    OrgPolicyViolationInfo
      { payload = Core.Nothing,
        resourceTags = Core.Nothing,
        resourceType = Core.Nothing,
        violationInfo = Core.Nothing
      }
  
  instance Core.FromJSON OrgPolicyViolationInfo where
    parseJSON =
      Core.withObject
        "OrgPolicyViolationInfo"
        ( \o ->
            OrgPolicyViolationInfo
              Core.<$> (o Core..:? "payload")
              Core.<*> (o Core..:? "resourceTags")
              Core.<*> (o Core..:? "resourceType")
              Core.<*> (o Core..:? "violationInfo")
        )
  
  instance Core.ToJSON OrgPolicyViolationInfo where
    toJSON OrgPolicyViolationInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("payload" Core..=) Core.<$> payload,
              ("resourceTags" Core..=) Core.<$> resourceTags,
              ("resourceType" Core..=) Core.<$> resourceType,
              ("violationInfo" Core..=) Core.<$> violationInfo
            ]
        )
  
  -- | Optional. Deprecated. Resource payload that is currently in scope and is subjected to orgpolicy conditions. This payload may be the subset of the actual Resource that may come in the request.
  --
  -- /See:/ 'newOrgPolicyViolationInfo_Payload' smart constructor.
  newtype OrgPolicyViolationInfo_Payload = OrgPolicyViolationInfo_Payload
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OrgPolicyViolationInfo_Payload' with the minimum fields required to make a request.
  newOrgPolicyViolationInfo_Payload ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    OrgPolicyViolationInfo_Payload
  newOrgPolicyViolationInfo_Payload additional =
    OrgPolicyViolationInfo_Payload {additional = additional}
  
  instance Core.FromJSON OrgPolicyViolationInfo_Payload where
    parseJSON =
      Core.withObject
        "OrgPolicyViolationInfo_Payload"
        ( \o ->
            OrgPolicyViolationInfo_Payload Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON OrgPolicyViolationInfo_Payload where
    toJSON OrgPolicyViolationInfo_Payload {..} = Core.toJSON additional
  
  -- | Optional. Deprecated. Tags referenced on the resource at the time of evaluation.
  --
  -- /See:/ 'newOrgPolicyViolationInfo_ResourceTags' smart constructor.
  newtype OrgPolicyViolationInfo_ResourceTags = OrgPolicyViolationInfo_ResourceTags
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OrgPolicyViolationInfo_ResourceTags' with the minimum fields required to make a request.
  newOrgPolicyViolationInfo_ResourceTags ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    OrgPolicyViolationInfo_ResourceTags
  newOrgPolicyViolationInfo_ResourceTags additional =
    OrgPolicyViolationInfo_ResourceTags {additional = additional}
  
  instance Core.FromJSON OrgPolicyViolationInfo_ResourceTags where
    parseJSON =
      Core.withObject
        "OrgPolicyViolationInfo_ResourceTags"
        ( \o ->
            OrgPolicyViolationInfo_ResourceTags
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON OrgPolicyViolationInfo_ResourceTags where
    toJSON OrgPolicyViolationInfo_ResourceTags {..} =
      Core.toJSON additional
  
  -- | This message defines attributes for a node that handles a network request. The node can be either a service or an application that sends, forwards, or receives the request. Service peers should fill in @principal@ and @labels@ as appropriate.
  --
  -- /See:/ 'newPeer' smart constructor.
  data Peer = Peer
    { -- | The IP address of the peer.
      ip :: (Core.Maybe Core.Text),
      -- | The labels associated with the peer.
      labels :: (Core.Maybe Peer_Labels),
      -- | The network port of the peer.
      port :: (Core.Maybe Core.Int64),
      -- | The identity of this peer. Similar to @Request.auth.principal@, but relative to the peer instead of the request. For example, the identity associated with a load balancer that forwarded the request.
      principal :: (Core.Maybe Core.Text),
      -- | The CLDR country\/region code associated with the above IP address. If the IP address is private, the @region_code@ should reflect the physical location where this peer is running.
      regionCode :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Peer' with the minimum fields required to make a request.
  newPeer ::
    Peer
  newPeer =
    Peer
      { ip = Core.Nothing,
        labels = Core.Nothing,
        port = Core.Nothing,
        principal = Core.Nothing,
        regionCode = Core.Nothing
      }
  
  instance Core.FromJSON Peer where
    parseJSON =
      Core.withObject
        "Peer"
        ( \o ->
            Peer
              Core.<$> (o Core..:? "ip")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "port" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "principal")
              Core.<*> (o Core..:? "regionCode")
        )
  
  instance Core.ToJSON Peer where
    toJSON Peer {..} =
      Core.object
        ( Core.catMaybes
            [ ("ip" Core..=) Core.<$> ip,
              ("labels" Core..=) Core.<$> labels,
              ("port" Core..=) Core.. Core.AsText Core.<$> port,
              ("principal" Core..=) Core.<$> principal,
              ("regionCode" Core..=) Core.<$> regionCode
            ]
        )
  
  -- | The labels associated with the peer.
  --
  -- /See:/ 'newPeer_Labels' smart constructor.
  newtype Peer_Labels = Peer_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Peer_Labels' with the minimum fields required to make a request.
  newPeer_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Peer_Labels
  newPeer_Labels additional = Peer_Labels {additional = additional}
  
  instance Core.FromJSON Peer_Labels where
    parseJSON =
      Core.withObject
        "Peer_Labels"
        (\o -> Peer_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Peer_Labels where
    toJSON Peer_Labels {..} = Core.toJSON additional
  
  -- | Information related to policy violations for this request.
  --
  -- /See:/ 'newPolicyViolationInfo' smart constructor.
  newtype PolicyViolationInfo = PolicyViolationInfo
    { -- | Indicates the orgpolicy violations for this resource.
      orgPolicyViolationInfo :: (Core.Maybe OrgPolicyViolationInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PolicyViolationInfo' with the minimum fields required to make a request.
  newPolicyViolationInfo ::
    PolicyViolationInfo
  newPolicyViolationInfo =
    PolicyViolationInfo {orgPolicyViolationInfo = Core.Nothing}
  
  instance Core.FromJSON PolicyViolationInfo where
    parseJSON =
      Core.withObject
        "PolicyViolationInfo"
        ( \o ->
            PolicyViolationInfo Core.<$> (o Core..:? "orgPolicyViolationInfo")
        )
  
  instance Core.ToJSON PolicyViolationInfo where
    toJSON PolicyViolationInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("orgPolicyViolationInfo" Core..=)
                Core.<$> orgPolicyViolationInfo
            ]
        )
  
  -- | Request message for the Report method.
  --
  -- /See:/ 'newReportRequest' smart constructor.
  data ReportRequest = ReportRequest
    { -- | Describes the list of operations to be reported. Each operation is represented as an AttributeContext, and contains all attributes around an API access.
      operations :: (Core.Maybe [AttributeContext]),
      -- | Specifies the version of the service configuration that should be used to process the request. Must not be empty. Set this field to \'latest\' to specify using the latest configuration.
      serviceConfigId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReportRequest' with the minimum fields required to make a request.
  newReportRequest ::
    ReportRequest
  newReportRequest =
    ReportRequest
      { operations = Core.Nothing,
        serviceConfigId = Core.Nothing
      }
  
  instance Core.FromJSON ReportRequest where
    parseJSON =
      Core.withObject
        "ReportRequest"
        ( \o ->
            ReportRequest
              Core.<$> (o Core..:? "operations")
              Core.<*> (o Core..:? "serviceConfigId")
        )
  
  instance Core.ToJSON ReportRequest where
    toJSON ReportRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("operations" Core..=) Core.<$> operations,
              ("serviceConfigId" Core..=) Core.<$> serviceConfigId
            ]
        )
  
  -- | Response message for the Report method.
  --
  -- /See:/ 'newReportResponse' smart constructor.
  newtype ReportResponse = ReportResponse
    { -- | The extension field to store serialized OTel responses. e.g. ExportLogsServiceResponse, ExportMetricsServiceResponse.
      extensions :: (Core.Maybe ReportResponse_Extensions)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReportResponse' with the minimum fields required to make a request.
  newReportResponse ::
    ReportResponse
  newReportResponse = ReportResponse {extensions = Core.Nothing}
  
  instance Core.FromJSON ReportResponse where
    parseJSON =
      Core.withObject
        "ReportResponse"
        (\o -> ReportResponse Core.<$> (o Core..:? "extensions"))
  
  instance Core.ToJSON ReportResponse where
    toJSON ReportResponse {..} =
      Core.object
        (Core.catMaybes [("extensions" Core..=) Core.<$> extensions])
  
  -- | The extension field to store serialized OTel responses. e.g. ExportLogsServiceResponse, ExportMetricsServiceResponse.
  --
  -- /See:/ 'newReportResponse_Extensions' smart constructor.
  newtype ReportResponse_Extensions = ReportResponse_Extensions
    { -- | 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 'ReportResponse_Extensions' with the minimum fields required to make a request.
  newReportResponse_Extensions ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    ReportResponse_Extensions
  newReportResponse_Extensions additional =
    ReportResponse_Extensions {additional = additional}
  
  instance Core.FromJSON ReportResponse_Extensions where
    parseJSON =
      Core.withObject
        "ReportResponse_Extensions"
        ( \o ->
            ReportResponse_Extensions Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON ReportResponse_Extensions where
    toJSON ReportResponse_Extensions {..} = Core.toJSON additional
  
  -- | This message defines attributes for an HTTP request. If the actual request is not an HTTP request, the runtime system should try to map the actual request to an equivalent HTTP request.
  --
  -- /See:/ 'newRequest' smart constructor.
  data Request' = Request'
    { -- | The request authentication. May be absent for unauthenticated requests. Derived from the HTTP request @Authorization@ header or equivalent.
      auth :: (Core.Maybe Auth),
      -- | The HTTP request headers. If multiple headers share the same key, they must be merged according to the HTTP spec. All header keys must be lowercased, because HTTP header keys are case-insensitive.
      headers :: (Core.Maybe Request_Headers),
      -- | The HTTP request @Host@ header value.
      host :: (Core.Maybe Core.Text),
      -- | The unique ID for a request, which can be propagated to downstream systems. The ID should have low probability of collision within a single day for a specific service.
      id :: (Core.Maybe Core.Text),
      -- | The HTTP request method, such as @GET@, @POST@.
      method :: (Core.Maybe Core.Text),
      -- | The values from Origin header from the HTTP request, such as \"https:\/\/console.cloud.google.com\". Modern browsers can only have one origin. Special browsers and\/or HTTP clients may require multiple origins.
      origin :: (Core.Maybe Core.Text),
      -- | The HTTP URL path, excluding the query parameters.
      path :: (Core.Maybe Core.Text),
      -- | The network protocol used with the request, such as \"http\/1.1\", \"spdy\/3\", \"h2\", \"h2c\", \"webrtc\", \"tcp\", \"udp\", \"quic\". See https:\/\/www.iana.org\/assignments\/tls-extensiontype-values\/tls-extensiontype-values.xhtml#alpn-protocol-ids for details.
      protocol :: (Core.Maybe Core.Text),
      -- | The HTTP URL query in the format of @name1=value1&name2=value2@, as it appears in the first line of the HTTP request. No decoding is performed.
      query :: (Core.Maybe Core.Text),
      -- | A special parameter for request reason. It is used by security systems to associate auditing information with a request.
      reason :: (Core.Maybe Core.Text),
      -- | The HTTP URL scheme, such as @http@ and @https@.
      scheme :: (Core.Maybe Core.Text),
      -- | The HTTP request size in bytes. If unknown, it must be -1.
      size :: (Core.Maybe Core.Int64),
      -- | The timestamp when the @destination@ service receives the last byte of the request.
      time :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Request' with the minimum fields required to make a request.
  newRequest ::
    Request'
  newRequest =
    Request'
      { auth = Core.Nothing,
        headers = Core.Nothing,
        host = Core.Nothing,
        id = Core.Nothing,
        method = Core.Nothing,
        origin = Core.Nothing,
        path = Core.Nothing,
        protocol = Core.Nothing,
        query = Core.Nothing,
        reason = Core.Nothing,
        scheme = Core.Nothing,
        size = Core.Nothing,
        time = Core.Nothing
      }
  
  instance Core.FromJSON Request' where
    parseJSON =
      Core.withObject
        "Request'"
        ( \o ->
            Request'
              Core.<$> (o Core..:? "auth")
              Core.<*> (o Core..:? "headers")
              Core.<*> (o Core..:? "host")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "method")
              Core.<*> (o Core..:? "origin")
              Core.<*> (o Core..:? "path")
              Core.<*> (o Core..:? "protocol")
              Core.<*> (o Core..:? "query")
              Core.<*> (o Core..:? "reason")
              Core.<*> (o Core..:? "scheme")
              Core.<*> (o Core..:? "size" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "time")
        )
  
  instance Core.ToJSON Request' where
    toJSON Request' {..} =
      Core.object
        ( Core.catMaybes
            [ ("auth" Core..=) Core.<$> auth,
              ("headers" Core..=) Core.<$> headers,
              ("host" Core..=) Core.<$> host,
              ("id" Core..=) Core.<$> id,
              ("method" Core..=) Core.<$> method,
              ("origin" Core..=) Core.<$> origin,
              ("path" Core..=) Core.<$> path,
              ("protocol" Core..=) Core.<$> protocol,
              ("query" Core..=) Core.<$> query,
              ("reason" Core..=) Core.<$> reason,
              ("scheme" Core..=) Core.<$> scheme,
              ("size" Core..=) Core.. Core.AsText Core.<$> size,
              ("time" Core..=) Core.<$> time
            ]
        )
  
  -- | The HTTP request headers. If multiple headers share the same key, they must be merged according to the HTTP spec. All header keys must be lowercased, because HTTP header keys are case-insensitive.
  --
  -- /See:/ 'newRequest_Headers' smart constructor.
  newtype Request_Headers = Request_Headers
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Request_Headers' with the minimum fields required to make a request.
  newRequest_Headers ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Request_Headers
  newRequest_Headers additional =
    Request_Headers {additional = additional}
  
  instance Core.FromJSON Request_Headers where
    parseJSON =
      Core.withObject
        "Request_Headers"
        (\o -> Request_Headers Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Request_Headers where
    toJSON Request_Headers {..} = Core.toJSON additional
  
  -- | Metadata about the request.
  --
  -- /See:/ 'newRequestMetadata' smart constructor.
  data RequestMetadata = RequestMetadata
    { -- | The IP address of the caller. For a caller from the internet, this will be the public IPv4 or IPv6 address. For calls made from inside Google\'s internal production network from one GCP service to another, @caller_ip@ will be redacted to \"private\". For a caller from a Compute Engine VM with a external IP address, @caller_ip@ will be the VM\'s external IP address. For a caller from a Compute Engine VM without a external IP address, if the VM is in the same organization (or project) as the accessed resource, @caller_ip@ will be the VM\'s internal IPv4 address, otherwise @caller_ip@ will be redacted to \"gce-internal-ip\". See https:\/\/cloud.google.com\/compute\/docs\/vpc\/ for more information.
      callerIp :: (Core.Maybe Core.Text),
      -- | The network of the caller. Set only if the network host project is part of the same GCP organization (or project) as the accessed resource. See https:\/\/cloud.google.com\/compute\/docs\/vpc\/ for more information. This is a scheme-less URI full resource name. For example: \"\/\/compute.googleapis.com\/projects\/PROJECT/ID\/global\/networks\/NETWORK/ID\"
      callerNetwork :: (Core.Maybe Core.Text),
      -- | The user agent of the caller. This information is not authenticated and should be treated accordingly. For example: + @google-api-python-client\/1.4.0@: The request was made by the Google API client for Python. + @Cloud SDK Command Line Tool apitools-client\/1.0 gcloud\/0.9.62@: The request was made by the Google Cloud SDK CLI (gcloud). + @AppEngine-Google; (+http:\/\/code.google.com\/appengine; appid: s~my-project@: The request was made from the @my-project@ App Engine app.
      callerSuppliedUserAgent :: (Core.Maybe Core.Text),
      -- | The destination of a network activity, such as accepting a TCP connection. In a multi hop network activity, the destination represents the receiver of the last hop. Only two fields are used in this message, Peer.port and Peer.ip. These fields are optionally populated by those services utilizing the IAM condition feature.
      destinationAttributes :: (Core.Maybe Peer),
      -- | Request attributes used in IAM condition evaluation. This field contains request attributes like request time and access levels associated with the request. To get the whole view of the attributes used in IAM condition evaluation, the user must also look into @AuditLog.authentication_info.resource_attributes@.
      requestAttributes :: (Core.Maybe Request')
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RequestMetadata' with the minimum fields required to make a request.
  newRequestMetadata ::
    RequestMetadata
  newRequestMetadata =
    RequestMetadata
      { callerIp = Core.Nothing,
        callerNetwork = Core.Nothing,
        callerSuppliedUserAgent = Core.Nothing,
        destinationAttributes = Core.Nothing,
        requestAttributes = Core.Nothing
      }
  
  instance Core.FromJSON RequestMetadata where
    parseJSON =
      Core.withObject
        "RequestMetadata"
        ( \o ->
            RequestMetadata
              Core.<$> (o Core..:? "callerIp")
              Core.<*> (o Core..:? "callerNetwork")
              Core.<*> (o Core..:? "callerSuppliedUserAgent")
              Core.<*> (o Core..:? "destinationAttributes")
              Core.<*> (o Core..:? "requestAttributes")
        )
  
  instance Core.ToJSON RequestMetadata where
    toJSON RequestMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("callerIp" Core..=) Core.<$> callerIp,
              ("callerNetwork" Core..=) Core.<$> callerNetwork,
              ("callerSuppliedUserAgent" Core..=)
                Core.<$> callerSuppliedUserAgent,
              ("destinationAttributes" Core..=) Core.<$> destinationAttributes,
              ("requestAttributes" Core..=) Core.<$> requestAttributes
            ]
        )
  
  -- | This message defines core attributes for a resource. A resource is an addressable (named) entity provided by the destination service. For example, a file stored on a network storage service.
  --
  -- /See:/ 'newResource' smart constructor.
  data Resource = Resource
    { -- | Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https:\/\/kubernetes.io\/docs\/concepts\/overview\/working-with-objects\/annotations\/
      annotations :: (Core.Maybe Resource_Annotations),
      -- | Output only. The timestamp when the resource was created. This may be either the time creation was initiated or when it was completed.
      createTime :: (Core.Maybe Core.DateTime),
      -- | Output only. The timestamp when the resource was deleted. If the resource is not deleted, this must be empty.
      deleteTime :: (Core.Maybe Core.DateTime),
      -- | Mutable. The display name set by clients. Must be \<= 63 characters.
      displayName :: (Core.Maybe Core.Text),
      -- | Output only. An opaque value that uniquely identifies a version or generation of a resource. It can be used to confirm that the client and server agree on the ordering of a resource being written.
      etag :: (Core.Maybe Core.Text),
      -- | The labels or tags on the resource, such as AWS resource tags and Kubernetes resource labels.
      labels :: (Core.Maybe Resource_Labels),
      -- | Immutable. The location of the resource. The location encoding is specific to the service provider, and new encoding may be introduced as the service evolves. For Google Cloud products, the encoding is what is used by Google Cloud APIs, such as @us-east1@, @aws-us-east-1@, and @azure-eastus2@. The semantics of @location@ is identical to the @cloud.googleapis.com\/location@ label used by some Google Cloud APIs.
      location :: (Core.Maybe Core.Text),
      -- | The stable identifier (name) of a resource on the @service@. A resource can be logically identified as \"\/\/{resource.service}\/{resource.name}\". The differences between a resource name and a URI are: * Resource name is a logical identifier, independent of network protocol and API version. For example, @\/\/pubsub.googleapis.com\/projects\/123\/topics\/news-feed@. * URI often includes protocol and version information, so it can be used directly by applications. For example, @https:\/\/pubsub.googleapis.com\/v1\/projects\/123\/topics\/news-feed@. See https:\/\/cloud.google.com\/apis\/design\/resource_names for details.
      name :: (Core.Maybe Core.Text),
      -- | The name of the service that this resource belongs to, such as @pubsub.googleapis.com@. The service may be different from the DNS hostname that actually serves the request.
      service :: (Core.Maybe Core.Text),
      -- | The type of the resource. The syntax is platform-specific because different platforms define their resources differently. For Google APIs, the type format must be \"{service}\/{kind}\", such as \"pubsub.googleapis.com\/Topic\".
      type' :: (Core.Maybe Core.Text),
      -- | The unique identifier of the resource. UID is unique in the time and space for this resource within the scope of the service. It is typically generated by the server on successful creation of a resource and must not be changed. UID is used to uniquely identify resources with resource name reuses. This should be a UUID4.
      uid :: (Core.Maybe Core.Text),
      -- | Output only. The timestamp when the resource was last updated. Any change to the resource made by users must refresh this value. Changes to a resource made by the service should refresh this value.
      updateTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Resource' with the minimum fields required to make a request.
  newResource ::
    Resource
  newResource =
    Resource
      { annotations = Core.Nothing,
        createTime = Core.Nothing,
        deleteTime = Core.Nothing,
        displayName = Core.Nothing,
        etag = Core.Nothing,
        labels = Core.Nothing,
        location = Core.Nothing,
        name = Core.Nothing,
        service = Core.Nothing,
        type' = Core.Nothing,
        uid = Core.Nothing,
        updateTime = Core.Nothing
      }
  
  instance Core.FromJSON Resource where
    parseJSON =
      Core.withObject
        "Resource"
        ( \o ->
            Resource
              Core.<$> (o Core..:? "annotations")
              Core.<*> (o Core..:? "createTime")
              Core.<*> (o Core..:? "deleteTime")
              Core.<*> (o Core..:? "displayName")
              Core.<*> (o Core..:? "etag")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "service")
              Core.<*> (o Core..:? "type")
              Core.<*> (o Core..:? "uid")
              Core.<*> (o Core..:? "updateTime")
        )
  
  instance Core.ToJSON Resource where
    toJSON Resource {..} =
      Core.object
        ( Core.catMaybes
            [ ("annotations" Core..=) Core.<$> annotations,
              ("createTime" Core..=) Core.<$> createTime,
              ("deleteTime" Core..=) Core.<$> deleteTime,
              ("displayName" Core..=) Core.<$> displayName,
              ("etag" Core..=) Core.<$> etag,
              ("labels" Core..=) Core.<$> labels,
              ("location" Core..=) Core.<$> location,
              ("name" Core..=) Core.<$> name,
              ("service" Core..=) Core.<$> service,
              ("type" Core..=) Core.<$> type',
              ("uid" Core..=) Core.<$> uid,
              ("updateTime" Core..=) Core.<$> updateTime
            ]
        )
  
  -- | Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https:\/\/kubernetes.io\/docs\/concepts\/overview\/working-with-objects\/annotations\/
  --
  -- /See:/ 'newResource_Annotations' smart constructor.
  newtype Resource_Annotations = Resource_Annotations
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Resource_Annotations' with the minimum fields required to make a request.
  newResource_Annotations ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Resource_Annotations
  newResource_Annotations additional =
    Resource_Annotations {additional = additional}
  
  instance Core.FromJSON Resource_Annotations where
    parseJSON =
      Core.withObject
        "Resource_Annotations"
        (\o -> Resource_Annotations Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Resource_Annotations where
    toJSON Resource_Annotations {..} = Core.toJSON additional
  
  -- | The labels or tags on the resource, such as AWS resource tags and Kubernetes resource labels.
  --
  -- /See:/ 'newResource_Labels' smart constructor.
  newtype Resource_Labels = Resource_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Resource_Labels' with the minimum fields required to make a request.
  newResource_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Resource_Labels
  newResource_Labels additional =
    Resource_Labels {additional = additional}
  
  instance Core.FromJSON Resource_Labels where
    parseJSON =
      Core.withObject
        "Resource_Labels"
        (\o -> Resource_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Resource_Labels where
    toJSON Resource_Labels {..} = Core.toJSON additional
  
  -- | Describes a resource referenced in the request.
  --
  -- /See:/ 'newResourceInfo' smart constructor.
  data ResourceInfo = ResourceInfo
    { -- | Optional. The identifier of the container of this resource. For Google Cloud APIs, the resource container must be one of the following formats: - @projects\/@ - @folders\/@ - @organizations\/@ Required for the policy enforcement on the container level (e.g. VPCSC, Location Policy check, Org Policy check).
      container :: (Core.Maybe Core.Text),
      -- | Optional. The location of the resource, it must be a valid zone, region or multiregion, for example: \"europe-west4\", \"northamerica-northeast1-a\". Required for location policy check.
      location :: (Core.Maybe Core.Text),
      -- | The name of the resource referenced in the request.
      name :: (Core.Maybe Core.Text),
      -- | The resource permission needed for this request. The format must be \"{service}\/{plural}.{verb}\".
      permission :: (Core.Maybe Core.Text),
      -- | The resource type in the format of \"{service}\/{kind}\".
      type' :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceInfo' with the minimum fields required to make a request.
  newResourceInfo ::
    ResourceInfo
  newResourceInfo =
    ResourceInfo
      { container = Core.Nothing,
        location = Core.Nothing,
        name = Core.Nothing,
        permission = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON ResourceInfo where
    parseJSON =
      Core.withObject
        "ResourceInfo"
        ( \o ->
            ResourceInfo
              Core.<$> (o Core..:? "container")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "permission")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON ResourceInfo where
    toJSON ResourceInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("container" Core..=) Core.<$> container,
              ("location" Core..=) Core.<$> location,
              ("name" Core..=) Core.<$> name,
              ("permission" Core..=) Core.<$> permission,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Location information about a resource.
  --
  -- /See:/ 'newResourceLocation' smart constructor.
  data ResourceLocation = ResourceLocation
    { -- | The locations of a resource after the execution of the operation. Requests to create or delete a location based resource must populate the \'current/locations\' field and not the \'original/locations\' field. For example: \"europe-west1-a\" \"us-east1\" \"nam3\"
      currentLocations :: (Core.Maybe [Core.Text]),
      -- | The locations of a resource prior to the execution of the operation. Requests that mutate the resource\'s location must populate both the \'original/locations\' as well as the \'current/locations\' fields. For example: \"europe-west1-a\" \"us-east1\" \"nam3\"
      originalLocations :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceLocation' with the minimum fields required to make a request.
  newResourceLocation ::
    ResourceLocation
  newResourceLocation =
    ResourceLocation
      { currentLocations = Core.Nothing,
        originalLocations = Core.Nothing
      }
  
  instance Core.FromJSON ResourceLocation where
    parseJSON =
      Core.withObject
        "ResourceLocation"
        ( \o ->
            ResourceLocation
              Core.<$> (o Core..:? "currentLocations")
              Core.<*> (o Core..:? "originalLocations")
        )
  
  instance Core.ToJSON ResourceLocation where
    toJSON ResourceLocation {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentLocations" Core..=) Core.<$> currentLocations,
              ("originalLocations" Core..=) Core.<$> originalLocations
            ]
        )
  
  -- | This message defines attributes for a typical network response. It generally models semantics of an HTTP response.
  --
  -- /See:/ 'newResponse' smart constructor.
  data Response = Response
    { -- | The amount of time it takes the backend service to fully respond to a request. Measured from when the destination service starts to send the request to the backend until when the destination service receives the complete response from the backend.
      backendLatency :: (Core.Maybe Core.Duration),
      -- | The HTTP response status code, such as @200@ and @404@.
      code :: (Core.Maybe Core.Int64),
      -- | The HTTP response headers. If multiple headers share the same key, they must be merged according to HTTP spec. All header keys must be lowercased, because HTTP header keys are case-insensitive.
      headers :: (Core.Maybe Response_Headers),
      -- | The HTTP response size in bytes. If unknown, it must be -1.
      size :: (Core.Maybe Core.Int64),
      -- | The timestamp when the @destination@ service sends the last byte of the response.
      time :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Response' with the minimum fields required to make a request.
  newResponse ::
    Response
  newResponse =
    Response
      { backendLatency = Core.Nothing,
        code = Core.Nothing,
        headers = Core.Nothing,
        size = Core.Nothing,
        time = Core.Nothing
      }
  
  instance Core.FromJSON Response where
    parseJSON =
      Core.withObject
        "Response"
        ( \o ->
            Response
              Core.<$> (o Core..:? "backendLatency")
              Core.<*> (o Core..:? "code" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "headers")
              Core.<*> (o Core..:? "size" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "time")
        )
  
  instance Core.ToJSON Response where
    toJSON Response {..} =
      Core.object
        ( Core.catMaybes
            [ ("backendLatency" Core..=) Core.<$> backendLatency,
              ("code" Core..=) Core.. Core.AsText Core.<$> code,
              ("headers" Core..=) Core.<$> headers,
              ("size" Core..=) Core.. Core.AsText Core.<$> size,
              ("time" Core..=) Core.<$> time
            ]
        )
  
  -- | The HTTP response headers. If multiple headers share the same key, they must be merged according to HTTP spec. All header keys must be lowercased, because HTTP header keys are case-insensitive.
  --
  -- /See:/ 'newResponse_Headers' smart constructor.
  newtype Response_Headers = Response_Headers
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Response_Headers' with the minimum fields required to make a request.
  newResponse_Headers ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Response_Headers
  newResponse_Headers additional =
    Response_Headers {additional = additional}
  
  instance Core.FromJSON Response_Headers where
    parseJSON =
      Core.withObject
        "Response_Headers"
        (\o -> Response_Headers Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Response_Headers where
    toJSON Response_Headers {..} = Core.toJSON additional
  
  -- | Identity delegation history of an authenticated service account.
  --
  -- /See:/ 'newServiceAccountDelegationInfo' smart constructor.
  data ServiceAccountDelegationInfo = ServiceAccountDelegationInfo
    { -- | First party (Google) identity as the real authority.
      firstPartyPrincipal :: (Core.Maybe FirstPartyPrincipal),
      -- | A string representing the principal/subject associated with the identity. For most identities, the format will be @principal:\/\/iam.googleapis.com\/{identity pool name}\/subject\/{subject)@ except for some GKE identities (GKE/WORKLOAD, FREEFORM, GKE/HUB/WORKLOAD) that are still in the legacy format @serviceAccount:{identity pool name}[{subject}]@
      principalSubject :: (Core.Maybe Core.Text),
      -- | Third party identity as the real authority.
      thirdPartyPrincipal :: (Core.Maybe ThirdPartyPrincipal)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ServiceAccountDelegationInfo' with the minimum fields required to make a request.
  newServiceAccountDelegationInfo ::
    ServiceAccountDelegationInfo
  newServiceAccountDelegationInfo =
    ServiceAccountDelegationInfo
      { firstPartyPrincipal = Core.Nothing,
        principalSubject = Core.Nothing,
        thirdPartyPrincipal = Core.Nothing
      }
  
  instance Core.FromJSON ServiceAccountDelegationInfo where
    parseJSON =
      Core.withObject
        "ServiceAccountDelegationInfo"
        ( \o ->
            ServiceAccountDelegationInfo
              Core.<$> (o Core..:? "firstPartyPrincipal")
              Core.<*> (o Core..:? "principalSubject")
              Core.<*> (o Core..:? "thirdPartyPrincipal")
        )
  
  instance Core.ToJSON ServiceAccountDelegationInfo where
    toJSON ServiceAccountDelegationInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("firstPartyPrincipal" Core..=) Core.<$> firstPartyPrincipal,
              ("principalSubject" Core..=) Core.<$> principalSubject,
              ("thirdPartyPrincipal" Core..=) Core.<$> thirdPartyPrincipal
            ]
        )
  
  -- | The history of delegation across multiple services as the result of the original user\'s action. Such as \"service A uses its own account to do something for user B\". This differs from ServiceAccountDelegationInfo, which only tracks the history of direct token exchanges (impersonation).
  --
  -- /See:/ 'newServiceDelegationHistory' smart constructor.
  data ServiceDelegationHistory = ServiceDelegationHistory
    { -- | The original end user who initiated the request to GCP.
      originalPrincipal :: (Core.Maybe Core.Text),
      -- | Data identifying the service specific jobs or units of work that were involved in a chain of service calls.
      serviceMetadata :: (Core.Maybe [ServiceMetadata])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ServiceDelegationHistory' with the minimum fields required to make a request.
  newServiceDelegationHistory ::
    ServiceDelegationHistory
  newServiceDelegationHistory =
    ServiceDelegationHistory
      { originalPrincipal = Core.Nothing,
        serviceMetadata = Core.Nothing
      }
  
  instance Core.FromJSON ServiceDelegationHistory where
    parseJSON =
      Core.withObject
        "ServiceDelegationHistory"
        ( \o ->
            ServiceDelegationHistory
              Core.<$> (o Core..:? "originalPrincipal")
              Core.<*> (o Core..:? "serviceMetadata")
        )
  
  instance Core.ToJSON ServiceDelegationHistory where
    toJSON ServiceDelegationHistory {..} =
      Core.object
        ( Core.catMaybes
            [ ("originalPrincipal" Core..=) Core.<$> originalPrincipal,
              ("serviceMetadata" Core..=) Core.<$> serviceMetadata
            ]
        )
  
  -- | Metadata describing the service and additional service specific information used to identify the job or unit of work at hand.
  --
  -- /See:/ 'newServiceMetadata' smart constructor.
  data ServiceMetadata = ServiceMetadata
    { -- | Additional metadata provided by service teams to describe service specific job information that was triggered by the original principal.
      jobMetadata :: (Core.Maybe ServiceMetadata_JobMetadata),
      -- | A string representing the principal/subject associated with the identity. For most identities, the format will be @principal:\/\/iam.googleapis.com\/{identity pool name}\/subject\/{subject)@ except for some GKE identities (GKE/WORKLOAD, FREEFORM, GKE/HUB/WORKLOAD) that are still in the legacy format @serviceAccount:{identity pool name}[{subject}]@ If the identity is a Google account (e.g. workspace user account or service account), this will be the email of the prefixed by @serviceAccount:@. For example: @serviceAccount:my-service-account\@project-1.iam.gserviceaccount.com@. If the identity is an individual user, the identity will be formatted as: @user:user_ABC\@email.com@.
      principalSubject :: (Core.Maybe Core.Text),
      -- | The service\'s fully qualified domain name, e.g. \"dataproc.googleapis.com\".
      serviceDomain :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ServiceMetadata' with the minimum fields required to make a request.
  newServiceMetadata ::
    ServiceMetadata
  newServiceMetadata =
    ServiceMetadata
      { jobMetadata = Core.Nothing,
        principalSubject = Core.Nothing,
        serviceDomain = Core.Nothing
      }
  
  instance Core.FromJSON ServiceMetadata where
    parseJSON =
      Core.withObject
        "ServiceMetadata"
        ( \o ->
            ServiceMetadata
              Core.<$> (o Core..:? "jobMetadata")
              Core.<*> (o Core..:? "principalSubject")
              Core.<*> (o Core..:? "serviceDomain")
        )
  
  instance Core.ToJSON ServiceMetadata where
    toJSON ServiceMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("jobMetadata" Core..=) Core.<$> jobMetadata,
              ("principalSubject" Core..=) Core.<$> principalSubject,
              ("serviceDomain" Core..=) Core.<$> serviceDomain
            ]
        )
  
  -- | Additional metadata provided by service teams to describe service specific job information that was triggered by the original principal.
  --
  -- /See:/ 'newServiceMetadata_JobMetadata' smart constructor.
  newtype ServiceMetadata_JobMetadata = ServiceMetadata_JobMetadata
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ServiceMetadata_JobMetadata' with the minimum fields required to make a request.
  newServiceMetadata_JobMetadata ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    ServiceMetadata_JobMetadata
  newServiceMetadata_JobMetadata additional =
    ServiceMetadata_JobMetadata {additional = additional}
  
  instance Core.FromJSON ServiceMetadata_JobMetadata where
    parseJSON =
      Core.withObject
        "ServiceMetadata_JobMetadata"
        ( \o ->
            ServiceMetadata_JobMetadata Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON ServiceMetadata_JobMetadata where
    toJSON ServiceMetadata_JobMetadata {..} = Core.toJSON additional
  
  -- | The context of a span. This is attached to an Exemplar in Distribution values during aggregation. It contains the name of a span with format: projects\/[PROJECT/ID/OR/NUMBER]\/traces\/[TRACE/ID]\/spans\/[SPAN_ID]
  --
  -- /See:/ 'newSpanContext' smart constructor.
  newtype SpanContext = SpanContext
    { -- | The resource name of the span. The format is: projects\/[PROJECT/ID/OR/NUMBER]\/traces\/[TRACE/ID]\/spans\/[SPAN_ID] @[TRACE_ID]@ is a unique identifier for a trace within a project; it is a 32-character hexadecimal encoding of a 16-byte array. @[SPAN_ID]@ is a unique identifier for a span within a trace; it is a 16-character hexadecimal encoding of an 8-byte array.
      spanName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SpanContext' with the minimum fields required to make a request.
  newSpanContext ::
    SpanContext
  newSpanContext = SpanContext {spanName = Core.Nothing}
  
  instance Core.FromJSON SpanContext where
    parseJSON =
      Core.withObject
        "SpanContext"
        (\o -> SpanContext Core.<$> (o Core..:? "spanName"))
  
  instance Core.ToJSON SpanContext where
    toJSON SpanContext {..} =
      Core.object
        (Core.catMaybes [("spanName" Core..=) Core.<$> spanName])
  
  -- | 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
  
  -- | Third party identity principal.
  --
  -- /See:/ 'newThirdPartyPrincipal' smart constructor.
  newtype ThirdPartyPrincipal = ThirdPartyPrincipal
    { -- | Metadata about third party identity.
      thirdPartyClaims :: (Core.Maybe ThirdPartyPrincipal_ThirdPartyClaims)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ThirdPartyPrincipal' with the minimum fields required to make a request.
  newThirdPartyPrincipal ::
    ThirdPartyPrincipal
  newThirdPartyPrincipal =
    ThirdPartyPrincipal {thirdPartyClaims = Core.Nothing}
  
  instance Core.FromJSON ThirdPartyPrincipal where
    parseJSON =
      Core.withObject
        "ThirdPartyPrincipal"
        ( \o ->
            ThirdPartyPrincipal Core.<$> (o Core..:? "thirdPartyClaims")
        )
  
  instance Core.ToJSON ThirdPartyPrincipal where
    toJSON ThirdPartyPrincipal {..} =
      Core.object
        ( Core.catMaybes
            [("thirdPartyClaims" Core..=) Core.<$> thirdPartyClaims]
        )
  
  -- | Metadata about third party identity.
  --
  -- /See:/ 'newThirdPartyPrincipal_ThirdPartyClaims' smart constructor.
  newtype ThirdPartyPrincipal_ThirdPartyClaims = ThirdPartyPrincipal_ThirdPartyClaims
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ThirdPartyPrincipal_ThirdPartyClaims' with the minimum fields required to make a request.
  newThirdPartyPrincipal_ThirdPartyClaims ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    ThirdPartyPrincipal_ThirdPartyClaims
  newThirdPartyPrincipal_ThirdPartyClaims additional =
    ThirdPartyPrincipal_ThirdPartyClaims {additional = additional}
  
  instance Core.FromJSON ThirdPartyPrincipal_ThirdPartyClaims where
    parseJSON =
      Core.withObject
        "ThirdPartyPrincipal_ThirdPartyClaims"
        ( \o ->
            ThirdPartyPrincipal_ThirdPartyClaims
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON ThirdPartyPrincipal_ThirdPartyClaims where
    toJSON ThirdPartyPrincipal_ThirdPartyClaims {..} =
      Core.toJSON additional
  
  -- | A common proto for logging HTTP requests. Only contains semantics defined by the HTTP specification. Product-specific logging information MUST be defined in a separate message.
  --
  -- /See:/ 'newV2HttpRequest' smart constructor.
  data V2HttpRequest = V2HttpRequest
    { -- | The number of HTTP response bytes inserted into cache. Set only when a cache fill was attempted.
      cacheFillBytes :: (Core.Maybe Core.Int64),
      -- | Whether or not an entity was served from cache (with or without validation).
      cacheHit :: (Core.Maybe Core.Bool),
      -- | Whether or not a cache lookup was attempted.
      cacheLookup :: (Core.Maybe Core.Bool),
      -- | Whether or not the response was validated with the origin server before being served from cache. This field is only meaningful if @cache_hit@ is True.
      cacheValidatedWithOriginServer :: (Core.Maybe Core.Bool),
      -- | The request processing latency on the server, from the time the request was received until the response was sent.
      latency :: (Core.Maybe Core.Duration),
      -- | Protocol used for the request. Examples: \"HTTP\/1.1\", \"HTTP\/2\", \"websocket\"
      protocol :: (Core.Maybe Core.Text),
      -- | The referer URL of the request, as defined in <https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html HTTP\/1.1 Header Field Definitions>.
      referer :: (Core.Maybe Core.Text),
      -- | The IP address (IPv4 or IPv6) of the client that issued the HTTP request. Examples: @\"192.168.1.1\"@, @\"FE80::0202:B3FF:FE1E:8329\"@.
      remoteIp :: (Core.Maybe Core.Text),
      -- | The request method. Examples: @\"GET\"@, @\"HEAD\"@, @\"PUT\"@, @\"POST\"@.
      requestMethod :: (Core.Maybe Core.Text),
      -- | The size of the HTTP request message in bytes, including the request headers and the request body.
      requestSize :: (Core.Maybe Core.Int64),
      -- | The scheme (http, https), the host name, the path, and the query portion of the URL that was requested. Example: @\"http:\/\/example.com\/some\/info?color=red\"@.
      requestUrl :: (Core.Maybe Core.Text),
      -- | The size of the HTTP response message sent back to the client, in bytes, including the response headers and the response body.
      responseSize :: (Core.Maybe Core.Int64),
      -- | The IP address (IPv4 or IPv6) of the origin server that the request was sent to.
      serverIp :: (Core.Maybe Core.Text),
      -- | The response code indicating the status of the response. Examples: 200, 404.
      status :: (Core.Maybe Core.Int32),
      -- | The user agent sent by the client. Example: @\"Mozilla\/4.0 (compatible; MSIE 6.0; Windows 98; Q312461; .NET CLR 1.0.3705)\"@.
      userAgent :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2HttpRequest' with the minimum fields required to make a request.
  newV2HttpRequest ::
    V2HttpRequest
  newV2HttpRequest =
    V2HttpRequest
      { cacheFillBytes = Core.Nothing,
        cacheHit = Core.Nothing,
        cacheLookup = Core.Nothing,
        cacheValidatedWithOriginServer = Core.Nothing,
        latency = Core.Nothing,
        protocol = Core.Nothing,
        referer = Core.Nothing,
        remoteIp = Core.Nothing,
        requestMethod = Core.Nothing,
        requestSize = Core.Nothing,
        requestUrl = Core.Nothing,
        responseSize = Core.Nothing,
        serverIp = Core.Nothing,
        status = Core.Nothing,
        userAgent = Core.Nothing
      }
  
  instance Core.FromJSON V2HttpRequest where
    parseJSON =
      Core.withObject
        "V2HttpRequest"
        ( \o ->
            V2HttpRequest
              Core.<$> (o Core..:? "cacheFillBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "cacheHit")
              Core.<*> (o Core..:? "cacheLookup")
              Core.<*> (o Core..:? "cacheValidatedWithOriginServer")
              Core.<*> (o Core..:? "latency")
              Core.<*> (o Core..:? "protocol")
              Core.<*> (o Core..:? "referer")
              Core.<*> (o Core..:? "remoteIp")
              Core.<*> (o Core..:? "requestMethod")
              Core.<*> (o Core..:? "requestSize" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "requestUrl")
              Core.<*> (o Core..:? "responseSize" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "serverIp")
              Core.<*> (o Core..:? "status")
              Core.<*> (o Core..:? "userAgent")
        )
  
  instance Core.ToJSON V2HttpRequest where
    toJSON V2HttpRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("cacheFillBytes" Core..=)
                Core.. Core.AsText
                Core.<$> cacheFillBytes,
              ("cacheHit" Core..=) Core.<$> cacheHit,
              ("cacheLookup" Core..=) Core.<$> cacheLookup,
              ("cacheValidatedWithOriginServer" Core..=)
                Core.<$> cacheValidatedWithOriginServer,
              ("latency" Core..=) Core.<$> latency,
              ("protocol" Core..=) Core.<$> protocol,
              ("referer" Core..=) Core.<$> referer,
              ("remoteIp" Core..=) Core.<$> remoteIp,
              ("requestMethod" Core..=) Core.<$> requestMethod,
              ("requestSize" Core..=) Core.. Core.AsText Core.<$> requestSize,
              ("requestUrl" Core..=) Core.<$> requestUrl,
              ("responseSize" Core..=) Core.. Core.AsText Core.<$> responseSize,
              ("serverIp" Core..=) Core.<$> serverIp,
              ("status" Core..=) Core.<$> status,
              ("userAgent" Core..=) Core.<$> userAgent
            ]
        )
  
  -- | An individual log entry.
  --
  -- /See:/ 'newV2LogEntry' smart constructor.
  data V2LogEntry = V2LogEntry
    { -- | Optional. Information about the HTTP request associated with this log entry, if applicable.
      httpRequest :: (Core.Maybe V2HttpRequest),
      -- | A unique ID for the log entry used for deduplication. If omitted, the implementation will generate one based on operation_id.
      insertId :: (Core.Maybe Core.Text),
      -- | A set of user-defined (key, value) data that provides additional information about the log entry.
      labels :: (Core.Maybe V2LogEntry_Labels),
      -- | A set of user-defined (key, value) data that provides additional information about the moniotored resource that the log entry belongs to.
      monitoredResourceLabels :: (Core.Maybe V2LogEntry_MonitoredResourceLabels),
      -- | Required. The log to which this log entry belongs. Examples: @\"syslog\"@, @\"book_log\"@.
      name :: (Core.Maybe Core.Text),
      -- | Optional. Information about an operation associated with the log entry, if applicable.
      operation :: (Core.Maybe V2LogEntryOperation),
      -- | The log entry payload, represented as a protocol buffer that is expressed as a JSON object. The only accepted type currently is AuditLog.
      protoPayload :: (Core.Maybe V2LogEntry_ProtoPayload),
      -- | The severity of the log entry. The default value is @LogSeverity.DEFAULT@.
      severity :: (Core.Maybe V2LogEntry_Severity),
      -- | Optional. Source code location information associated with the log entry, if any.
      sourceLocation :: (Core.Maybe V2LogEntrySourceLocation),
      -- | The log entry payload, represented as a structure that is expressed as a JSON object.
      structPayload :: (Core.Maybe V2LogEntry_StructPayload),
      -- | The log entry payload, represented as a Unicode string (UTF-8).
      textPayload :: (Core.Maybe Core.Text),
      -- | The time the event described by the log entry occurred. If omitted, defaults to operation start time.
      timestamp :: (Core.Maybe Core.DateTime),
      -- | Optional. Resource name of the trace associated with the log entry, if any. If this field contains a relative resource name, you can assume the name is relative to @\/\/tracing.googleapis.com@. Example: @projects\/my-projectid\/traces\/06796866738c859f2f19b7cfb3214824@
      trace :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2LogEntry' with the minimum fields required to make a request.
  newV2LogEntry ::
    V2LogEntry
  newV2LogEntry =
    V2LogEntry
      { httpRequest = Core.Nothing,
        insertId = Core.Nothing,
        labels = Core.Nothing,
        monitoredResourceLabels = Core.Nothing,
        name = Core.Nothing,
        operation = Core.Nothing,
        protoPayload = Core.Nothing,
        severity = Core.Nothing,
        sourceLocation = Core.Nothing,
        structPayload = Core.Nothing,
        textPayload = Core.Nothing,
        timestamp = Core.Nothing,
        trace = Core.Nothing
      }
  
  instance Core.FromJSON V2LogEntry where
    parseJSON =
      Core.withObject
        "V2LogEntry"
        ( \o ->
            V2LogEntry
              Core.<$> (o Core..:? "httpRequest")
              Core.<*> (o Core..:? "insertId")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "monitoredResourceLabels")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "operation")
              Core.<*> (o Core..:? "protoPayload")
              Core.<*> (o Core..:? "severity")
              Core.<*> (o Core..:? "sourceLocation")
              Core.<*> (o Core..:? "structPayload")
              Core.<*> (o Core..:? "textPayload")
              Core.<*> (o Core..:? "timestamp")
              Core.<*> (o Core..:? "trace")
        )
  
  instance Core.ToJSON V2LogEntry where
    toJSON V2LogEntry {..} =
      Core.object
        ( Core.catMaybes
            [ ("httpRequest" Core..=) Core.<$> httpRequest,
              ("insertId" Core..=) Core.<$> insertId,
              ("labels" Core..=) Core.<$> labels,
              ("monitoredResourceLabels" Core..=)
                Core.<$> monitoredResourceLabels,
              ("name" Core..=) Core.<$> name,
              ("operation" Core..=) Core.<$> operation,
              ("protoPayload" Core..=) Core.<$> protoPayload,
              ("severity" Core..=) Core.<$> severity,
              ("sourceLocation" Core..=) Core.<$> sourceLocation,
              ("structPayload" Core..=) Core.<$> structPayload,
              ("textPayload" Core..=) Core.<$> textPayload,
              ("timestamp" Core..=) Core.<$> timestamp,
              ("trace" Core..=) Core.<$> trace
            ]
        )
  
  -- | A set of user-defined (key, value) data that provides additional information about the log entry.
  --
  -- /See:/ 'newV2LogEntry_Labels' smart constructor.
  newtype V2LogEntry_Labels = V2LogEntry_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2LogEntry_Labels' with the minimum fields required to make a request.
  newV2LogEntry_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    V2LogEntry_Labels
  newV2LogEntry_Labels additional =
    V2LogEntry_Labels {additional = additional}
  
  instance Core.FromJSON V2LogEntry_Labels where
    parseJSON =
      Core.withObject
        "V2LogEntry_Labels"
        (\o -> V2LogEntry_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON V2LogEntry_Labels where
    toJSON V2LogEntry_Labels {..} = Core.toJSON additional
  
  -- | A set of user-defined (key, value) data that provides additional information about the moniotored resource that the log entry belongs to.
  --
  -- /See:/ 'newV2LogEntry_MonitoredResourceLabels' smart constructor.
  newtype V2LogEntry_MonitoredResourceLabels = V2LogEntry_MonitoredResourceLabels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2LogEntry_MonitoredResourceLabels' with the minimum fields required to make a request.
  newV2LogEntry_MonitoredResourceLabels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    V2LogEntry_MonitoredResourceLabels
  newV2LogEntry_MonitoredResourceLabels additional =
    V2LogEntry_MonitoredResourceLabels {additional = additional}
  
  instance Core.FromJSON V2LogEntry_MonitoredResourceLabels where
    parseJSON =
      Core.withObject
        "V2LogEntry_MonitoredResourceLabels"
        ( \o ->
            V2LogEntry_MonitoredResourceLabels
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON V2LogEntry_MonitoredResourceLabels where
    toJSON V2LogEntry_MonitoredResourceLabels {..} =
      Core.toJSON additional
  
  -- | The log entry payload, represented as a protocol buffer that is expressed as a JSON object. The only accepted type currently is AuditLog.
  --
  -- /See:/ 'newV2LogEntry_ProtoPayload' smart constructor.
  newtype V2LogEntry_ProtoPayload = V2LogEntry_ProtoPayload
    { -- | 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 'V2LogEntry_ProtoPayload' with the minimum fields required to make a request.
  newV2LogEntry_ProtoPayload ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    V2LogEntry_ProtoPayload
  newV2LogEntry_ProtoPayload additional =
    V2LogEntry_ProtoPayload {additional = additional}
  
  instance Core.FromJSON V2LogEntry_ProtoPayload where
    parseJSON =
      Core.withObject
        "V2LogEntry_ProtoPayload"
        (\o -> V2LogEntry_ProtoPayload Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON V2LogEntry_ProtoPayload where
    toJSON V2LogEntry_ProtoPayload {..} = Core.toJSON additional
  
  -- | The log entry payload, represented as a structure that is expressed as a JSON object.
  --
  -- /See:/ 'newV2LogEntry_StructPayload' smart constructor.
  newtype V2LogEntry_StructPayload = V2LogEntry_StructPayload
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2LogEntry_StructPayload' with the minimum fields required to make a request.
  newV2LogEntry_StructPayload ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    V2LogEntry_StructPayload
  newV2LogEntry_StructPayload additional =
    V2LogEntry_StructPayload {additional = additional}
  
  instance Core.FromJSON V2LogEntry_StructPayload where
    parseJSON =
      Core.withObject
        "V2LogEntry_StructPayload"
        (\o -> V2LogEntry_StructPayload Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON V2LogEntry_StructPayload where
    toJSON V2LogEntry_StructPayload {..} = Core.toJSON additional
  
  -- | Additional information about a potentially long-running operation with which a log entry is associated.
  --
  -- /See:/ 'newV2LogEntryOperation' smart constructor.
  data V2LogEntryOperation = V2LogEntryOperation
    { -- | Optional. Set this to True if this is the first log entry in the operation.
      first :: (Core.Maybe Core.Bool),
      -- | Optional. An arbitrary operation identifier. Log entries with the same identifier are assumed to be part of the same operation.
      id :: (Core.Maybe Core.Text),
      -- | Optional. Set this to True if this is the last log entry in the operation.
      last :: (Core.Maybe Core.Bool),
      -- | Optional. An arbitrary producer identifier. The combination of @id@ and @producer@ must be globally unique. Examples for @producer@: @\"MyDivision.MyBigCompany.com\"@, @\"github.com\/MyProject\/MyApplication\"@.
      producer :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2LogEntryOperation' with the minimum fields required to make a request.
  newV2LogEntryOperation ::
    V2LogEntryOperation
  newV2LogEntryOperation =
    V2LogEntryOperation
      { first = Core.Nothing,
        id = Core.Nothing,
        last = Core.Nothing,
        producer = Core.Nothing
      }
  
  instance Core.FromJSON V2LogEntryOperation where
    parseJSON =
      Core.withObject
        "V2LogEntryOperation"
        ( \o ->
            V2LogEntryOperation
              Core.<$> (o Core..:? "first")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "last")
              Core.<*> (o Core..:? "producer")
        )
  
  instance Core.ToJSON V2LogEntryOperation where
    toJSON V2LogEntryOperation {..} =
      Core.object
        ( Core.catMaybes
            [ ("first" Core..=) Core.<$> first,
              ("id" Core..=) Core.<$> id,
              ("last" Core..=) Core.<$> last,
              ("producer" Core..=) Core.<$> producer
            ]
        )
  
  -- | Additional information about the source code location that produced the log entry.
  --
  -- /See:/ 'newV2LogEntrySourceLocation' smart constructor.
  data V2LogEntrySourceLocation = V2LogEntrySourceLocation
    { -- | Optional. Source file name. Depending on the runtime environment, this might be a simple name or a fully-qualified name.
      file :: (Core.Maybe Core.Text),
      -- | Optional. Human-readable name of the function or method being invoked, with optional context such as the class or package name. This information may be used in contexts such as the logs viewer, where a file and line number are less meaningful. The format can vary by language. For example: @qual.if.ied.Class.method@ (Java), @dir\/package.func@ (Go), @function@ (Python).
      function :: (Core.Maybe Core.Text),
      -- | Optional. Line within the source file. 1-based; 0 indicates no line number available.
      line :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2LogEntrySourceLocation' with the minimum fields required to make a request.
  newV2LogEntrySourceLocation ::
    V2LogEntrySourceLocation
  newV2LogEntrySourceLocation =
    V2LogEntrySourceLocation
      { file = Core.Nothing,
        function = Core.Nothing,
        line = Core.Nothing
      }
  
  instance Core.FromJSON V2LogEntrySourceLocation where
    parseJSON =
      Core.withObject
        "V2LogEntrySourceLocation"
        ( \o ->
            V2LogEntrySourceLocation
              Core.<$> (o Core..:? "file")
              Core.<*> (o Core..:? "function")
              Core.<*> (o Core..:? "line" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON V2LogEntrySourceLocation where
    toJSON V2LogEntrySourceLocation {..} =
      Core.object
        ( Core.catMaybes
            [ ("file" Core..=) Core.<$> file,
              ("function" Core..=) Core.<$> function,
              ("line" Core..=) Core.. Core.AsText Core.<$> line
            ]
        )
  
  -- | Report v2 extension proto for passing the resource metadata associated with a resource create\/update\/delete\/undelete event from ESF to Chemist. ResourceEvent proto should be serialized into the ReportRequest.operations.extensions.
  --
  -- /See:/ 'newV2ResourceEvent' smart constructor.
  data V2ResourceEvent = V2ResourceEvent
    { -- | The ESF unique context id of the api request, from which this resource event originated. This field is only needed for CAIS integration via api annotation. See go\/cais-lro-delete for more details.
      contextId :: (Core.Maybe Core.Int64),
      -- | The destinations field determines which backend services should handle the event. This should be specified as a comma-delimited string.
      destinations :: (Core.Maybe Core.Text),
      -- | The parent resource for the resource.
      parent :: (Core.Maybe Resource),
      -- | The api path the resource event was created in. This should match the source of the @payload@ field. For direct integrations with Chemist, this should generally be the RESPONSE. go\/resource-event-pipeline-type
      path :: (Core.Maybe V2ResourceEvent_Path),
      -- | The payload contains metadata associated with the resource event. A ResourceEventPayloadStatus is provided instead if the original payload cannot be returned due to a limitation (e.g. size limit).
      payload :: (Core.Maybe V2ResourceEvent_Payload),
      -- | The resource associated with the event.
      resource :: (Core.Maybe Resource),
      -- | The resource event type determines how the backend service should process the event.
      type' :: (Core.Maybe V2ResourceEvent_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'V2ResourceEvent' with the minimum fields required to make a request.
  newV2ResourceEvent ::
    V2ResourceEvent
  newV2ResourceEvent =
    V2ResourceEvent
      { contextId = Core.Nothing,
        destinations = Core.Nothing,
        parent = Core.Nothing,
        path = Core.Nothing,
        payload = Core.Nothing,
        resource = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON V2ResourceEvent where
    parseJSON =
      Core.withObject
        "V2ResourceEvent"
        ( \o ->
            V2ResourceEvent
              Core.<$> (o Core..:? "contextId" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "destinations")
              Core.<*> (o Core..:? "parent")
              Core.<*> (o Core..:? "path")
              Core.<*> (o Core..:? "payload")
              Core.<*> (o Core..:? "resource")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON V2ResourceEvent where
    toJSON V2ResourceEvent {..} =
      Core.object
        ( Core.catMaybes
            [ ("contextId" Core..=) Core.. Core.AsText Core.<$> contextId,
              ("destinations" Core..=) Core.<$> destinations,
              ("parent" Core..=) Core.<$> parent,
              ("path" Core..=) Core.<$> path,
              ("payload" Core..=) Core.<$> payload,
              ("resource" Core..=) Core.<$> resource,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | The payload contains metadata associated with the resource event. A ResourceEventPayloadStatus is provided instead if the original payload cannot be returned due to a limitation (e.g. size limit).
  --
  -- /See:/ 'newV2ResourceEvent_Payload' smart constructor.
  newtype V2ResourceEvent_Payload = V2ResourceEvent_Payload
    { -- | 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 'V2ResourceEvent_Payload' with the minimum fields required to make a request.
  newV2ResourceEvent_Payload ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    V2ResourceEvent_Payload
  newV2ResourceEvent_Payload additional =
    V2ResourceEvent_Payload {additional = additional}
  
  instance Core.FromJSON V2ResourceEvent_Payload where
    parseJSON =
      Core.withObject
        "V2ResourceEvent_Payload"
        (\o -> V2ResourceEvent_Payload Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON V2ResourceEvent_Payload where
    toJSON V2ResourceEvent_Payload {..} = Core.toJSON additional
  
  -- | Provides information about the Policy violation info for this request.
  --
  -- /See:/ 'newViolationInfo' smart constructor.
  data ViolationInfo = ViolationInfo
    { -- | Optional. Value that is being checked for the policy. This could be in encrypted form (if pii sensitive). This field will only be emitted in LIST_POLICY types
      checkedValue :: (Core.Maybe Core.Text),
      -- | Optional. Constraint name
      constraint :: (Core.Maybe Core.Text),
      -- | Optional. Error message that policy is indicating.
      errorMessage :: (Core.Maybe Core.Text),
      -- | Optional. Indicates the type of the policy.
      policyType :: (Core.Maybe ViolationInfo_PolicyType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ViolationInfo' with the minimum fields required to make a request.
  newViolationInfo ::
    ViolationInfo
  newViolationInfo =
    ViolationInfo
      { checkedValue = Core.Nothing,
        constraint = Core.Nothing,
        errorMessage = Core.Nothing,
        policyType = Core.Nothing
      }
  
  instance Core.FromJSON ViolationInfo where
    parseJSON =
      Core.withObject
        "ViolationInfo"
        ( \o ->
            ViolationInfo
              Core.<$> (o Core..:? "checkedValue")
              Core.<*> (o Core..:? "constraint")
              Core.<*> (o Core..:? "errorMessage")
              Core.<*> (o Core..:? "policyType")
        )
  
  instance Core.ToJSON ViolationInfo where
    toJSON ViolationInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("checkedValue" Core..=) Core.<$> checkedValue,
              ("constraint" Core..=) Core.<$> constraint,
              ("errorMessage" Core..=) Core.<$> errorMessage,
              ("policyType" Core..=) Core.<$> policyType
            ]
        )
  