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.AppEngine.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.AppEngine.Internal.Product
    ( -- * ApiConfigHandler
      ApiConfigHandler (..),
      newApiConfigHandler,
  
      -- * ApiEndpointHandler
      ApiEndpointHandler (..),
      newApiEndpointHandler,
  
      -- * Application
      Application (..),
      newApplication,
  
      -- * Application_GeneratedCustomerMetadata
      Application_GeneratedCustomerMetadata (..),
      newApplication_GeneratedCustomerMetadata,
  
      -- * AuthorizedCertificate
      AuthorizedCertificate (..),
      newAuthorizedCertificate,
  
      -- * AuthorizedDomain
      AuthorizedDomain (..),
      newAuthorizedDomain,
  
      -- * AutomaticScaling
      AutomaticScaling (..),
      newAutomaticScaling,
  
      -- * BasicScaling
      BasicScaling (..),
      newBasicScaling,
  
      -- * BatchUpdateIngressRulesRequest
      BatchUpdateIngressRulesRequest (..),
      newBatchUpdateIngressRulesRequest,
  
      -- * BatchUpdateIngressRulesResponse
      BatchUpdateIngressRulesResponse (..),
      newBatchUpdateIngressRulesResponse,
  
      -- * CertificateRawData
      CertificateRawData (..),
      newCertificateRawData,
  
      -- * CloudBuildOptions
      CloudBuildOptions (..),
      newCloudBuildOptions,
  
      -- * ContainerInfo
      ContainerInfo (..),
      newContainerInfo,
  
      -- * ContainerState
      ContainerState (..),
      newContainerState,
  
      -- * CpuUtilization
      CpuUtilization (..),
      newCpuUtilization,
  
      -- * CreateVersionMetadataV1
      CreateVersionMetadataV1 (..),
      newCreateVersionMetadataV1,
  
      -- * CreateVersionMetadataV1Alpha
      CreateVersionMetadataV1Alpha (..),
      newCreateVersionMetadataV1Alpha,
  
      -- * CreateVersionMetadataV1Beta
      CreateVersionMetadataV1Beta (..),
      newCreateVersionMetadataV1Beta,
  
      -- * Date
      Date (..),
      newDate,
  
      -- * DebugInstanceRequest
      DebugInstanceRequest (..),
      newDebugInstanceRequest,
  
      -- * Deployment
      Deployment (..),
      newDeployment,
  
      -- * Deployment_Files
      Deployment_Files (..),
      newDeployment_Files,
  
      -- * DiskUtilization
      DiskUtilization (..),
      newDiskUtilization,
  
      -- * DomainMapping
      DomainMapping (..),
      newDomainMapping,
  
      -- * Empty
      Empty (..),
      newEmpty,
  
      -- * EndpointsApiService
      EndpointsApiService (..),
      newEndpointsApiService,
  
      -- * Entrypoint
      Entrypoint (..),
      newEntrypoint,
  
      -- * ErrorHandler
      ErrorHandler (..),
      newErrorHandler,
  
      -- * FeatureSettings
      FeatureSettings (..),
      newFeatureSettings,
  
      -- * FileInfo
      FileInfo (..),
      newFileInfo,
  
      -- * FirewallRule
      FirewallRule (..),
      newFirewallRule,
  
      -- * FlexibleRuntimeSettings
      FlexibleRuntimeSettings (..),
      newFlexibleRuntimeSettings,
  
      -- * GceTag
      GceTag (..),
      newGceTag,
  
      -- * GoogleAppengineV1betaLocationMetadata
      GoogleAppengineV1betaLocationMetadata (..),
      newGoogleAppengineV1betaLocationMetadata,
  
      -- * HealthCheck
      HealthCheck (..),
      newHealthCheck,
  
      -- * IdentityAwareProxy
      IdentityAwareProxy (..),
      newIdentityAwareProxy,
  
      -- * Instance
      Instance (..),
      newInstance,
  
      -- * Library
      Library (..),
      newLibrary,
  
      -- * ListAuthorizedCertificatesResponse
      ListAuthorizedCertificatesResponse (..),
      newListAuthorizedCertificatesResponse,
  
      -- * ListAuthorizedDomainsResponse
      ListAuthorizedDomainsResponse (..),
      newListAuthorizedDomainsResponse,
  
      -- * ListDomainMappingsResponse
      ListDomainMappingsResponse (..),
      newListDomainMappingsResponse,
  
      -- * ListIngressRulesResponse
      ListIngressRulesResponse (..),
      newListIngressRulesResponse,
  
      -- * ListInstancesResponse
      ListInstancesResponse (..),
      newListInstancesResponse,
  
      -- * ListLocationsResponse
      ListLocationsResponse (..),
      newListLocationsResponse,
  
      -- * ListOperationsResponse
      ListOperationsResponse (..),
      newListOperationsResponse,
  
      -- * ListRuntimesResponse
      ListRuntimesResponse (..),
      newListRuntimesResponse,
  
      -- * ListServicesResponse
      ListServicesResponse (..),
      newListServicesResponse,
  
      -- * ListVersionsResponse
      ListVersionsResponse (..),
      newListVersionsResponse,
  
      -- * LivenessCheck
      LivenessCheck (..),
      newLivenessCheck,
  
      -- * Location
      Location (..),
      newLocation,
  
      -- * Location_Labels
      Location_Labels (..),
      newLocation_Labels,
  
      -- * Location_Metadata
      Location_Metadata (..),
      newLocation_Metadata,
  
      -- * LocationMetadata
      LocationMetadata (..),
      newLocationMetadata,
  
      -- * ManagedCertificate
      ManagedCertificate (..),
      newManagedCertificate,
  
      -- * ManualScaling
      ManualScaling (..),
      newManualScaling,
  
      -- * Network
      Network (..),
      newNetwork,
  
      -- * NetworkSettings
      NetworkSettings (..),
      newNetworkSettings,
  
      -- * NetworkUtilization
      NetworkUtilization (..),
      newNetworkUtilization,
  
      -- * Operation
      Operation (..),
      newOperation,
  
      -- * Operation_Metadata
      Operation_Metadata (..),
      newOperation_Metadata,
  
      -- * Operation_Response
      Operation_Response (..),
      newOperation_Response,
  
      -- * OperationMetadataV1
      OperationMetadataV1 (..),
      newOperationMetadataV1,
  
      -- * OperationMetadataV1Alpha
      OperationMetadataV1Alpha (..),
      newOperationMetadataV1Alpha,
  
      -- * OperationMetadataV1Beta
      OperationMetadataV1Beta (..),
      newOperationMetadataV1Beta,
  
      -- * ProjectEvent
      ProjectEvent (..),
      newProjectEvent,
  
      -- * ProjectsMetadata
      ProjectsMetadata (..),
      newProjectsMetadata,
  
      -- * ReadinessCheck
      ReadinessCheck (..),
      newReadinessCheck,
  
      -- * Reasons
      Reasons (..),
      newReasons,
  
      -- * RepairApplicationRequest
      RepairApplicationRequest (..),
      newRepairApplicationRequest,
  
      -- * RequestUtilization
      RequestUtilization (..),
      newRequestUtilization,
  
      -- * ResourceEvent
      ResourceEvent (..),
      newResourceEvent,
  
      -- * ResourceRecord
      ResourceRecord (..),
      newResourceRecord,
  
      -- * Resources
      Resources (..),
      newResources,
  
      -- * Runtime
      Runtime (..),
      newRuntime,
  
      -- * ScriptHandler
      ScriptHandler (..),
      newScriptHandler,
  
      -- * Service
      Service (..),
      newService,
  
      -- * Service_GeneratedCustomerMetadata
      Service_GeneratedCustomerMetadata (..),
      newService_GeneratedCustomerMetadata,
  
      -- * Service_Labels
      Service_Labels (..),
      newService_Labels,
  
      -- * SslSettings
      SslSettings (..),
      newSslSettings,
  
      -- * StandardSchedulerSettings
      StandardSchedulerSettings (..),
      newStandardSchedulerSettings,
  
      -- * StaticFilesHandler
      StaticFilesHandler (..),
      newStaticFilesHandler,
  
      -- * StaticFilesHandler_HttpHeaders
      StaticFilesHandler_HttpHeaders (..),
      newStaticFilesHandler_HttpHeaders,
  
      -- * Status
      Status (..),
      newStatus,
  
      -- * Status_DetailsItem
      Status_DetailsItem (..),
      newStatus_DetailsItem,
  
      -- * TrafficSplit
      TrafficSplit (..),
      newTrafficSplit,
  
      -- * TrafficSplit_Allocations
      TrafficSplit_Allocations (..),
      newTrafficSplit_Allocations,
  
      -- * UrlDispatchRule
      UrlDispatchRule (..),
      newUrlDispatchRule,
  
      -- * UrlMap
      UrlMap (..),
      newUrlMap,
  
      -- * Version
      Version (..),
      newVersion,
  
      -- * Version_BetaSettings
      Version_BetaSettings (..),
      newVersion_BetaSettings,
  
      -- * Version_BuildEnvVariables
      Version_BuildEnvVariables (..),
      newVersion_BuildEnvVariables,
  
      -- * Version_EnvVariables
      Version_EnvVariables (..),
      newVersion_EnvVariables,
  
      -- * Version_GeneratedCustomerMetadata
      Version_GeneratedCustomerMetadata (..),
      newVersion_GeneratedCustomerMetadata,
  
      -- * Volume
      Volume (..),
      newVolume,
  
      -- * VpcAccessConnector
      VpcAccessConnector (..),
      newVpcAccessConnector,
  
      -- * ZipInfo
      ZipInfo (..),
      newZipInfo,
    )
  where
  
  import Gogol.AppEngine.Internal.Sum
  import Gogol.Prelude qualified as Core
  
  -- | Google Cloud Endpoints (https:\/\/cloud.google.com\/endpoints) configuration for API handlers.
  --
  -- /See:/ 'newApiConfigHandler' smart constructor.
  data ApiConfigHandler = ApiConfigHandler
    { -- | Action to take when users access resources that require authentication. Defaults to redirect.
      authFailAction :: (Core.Maybe ApiConfigHandler_AuthFailAction),
      -- | Level of login required to access this resource. Defaults to optional.
      login :: (Core.Maybe ApiConfigHandler_Login),
      -- | Path to the script from the application root directory.
      script :: (Core.Maybe Core.Text),
      -- | Security (HTTPS) enforcement for this URL.
      securityLevel :: (Core.Maybe ApiConfigHandler_SecurityLevel),
      -- | URL to serve the endpoint at.
      url :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApiConfigHandler' with the minimum fields required to make a request.
  newApiConfigHandler ::
    ApiConfigHandler
  newApiConfigHandler =
    ApiConfigHandler
      { authFailAction = Core.Nothing,
        login = Core.Nothing,
        script = Core.Nothing,
        securityLevel = Core.Nothing,
        url = Core.Nothing
      }
  
  instance Core.FromJSON ApiConfigHandler where
    parseJSON =
      Core.withObject
        "ApiConfigHandler"
        ( \o ->
            ApiConfigHandler
              Core.<$> (o Core..:? "authFailAction")
              Core.<*> (o Core..:? "login")
              Core.<*> (o Core..:? "script")
              Core.<*> (o Core..:? "securityLevel")
              Core.<*> (o Core..:? "url")
        )
  
  instance Core.ToJSON ApiConfigHandler where
    toJSON ApiConfigHandler {..} =
      Core.object
        ( Core.catMaybes
            [ ("authFailAction" Core..=) Core.<$> authFailAction,
              ("login" Core..=) Core.<$> login,
              ("script" Core..=) Core.<$> script,
              ("securityLevel" Core..=) Core.<$> securityLevel,
              ("url" Core..=) Core.<$> url
            ]
        )
  
  -- | Uses Google Cloud Endpoints to handle requests.
  --
  -- /See:/ 'newApiEndpointHandler' smart constructor.
  newtype ApiEndpointHandler = ApiEndpointHandler
    { -- | Path to the script from the application root directory.
      scriptPath :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApiEndpointHandler' with the minimum fields required to make a request.
  newApiEndpointHandler ::
    ApiEndpointHandler
  newApiEndpointHandler =
    ApiEndpointHandler {scriptPath = Core.Nothing}
  
  instance Core.FromJSON ApiEndpointHandler where
    parseJSON =
      Core.withObject
        "ApiEndpointHandler"
        (\o -> ApiEndpointHandler Core.<$> (o Core..:? "scriptPath"))
  
  instance Core.ToJSON ApiEndpointHandler where
    toJSON ApiEndpointHandler {..} =
      Core.object
        (Core.catMaybes [("scriptPath" Core..=) Core.<$> scriptPath])
  
  -- | An Application resource contains the top-level configuration of an App Engine application.
  --
  -- /See:/ 'newApplication' smart constructor.
  data Application = Application
    { -- | Google Apps authentication domain that controls which users can access this application.Defaults to open access for any Google Account.
      authDomain :: (Core.Maybe Core.Text),
      -- | Output only. Google Cloud Storage bucket that can be used for storing files associated with this application. This bucket is associated with the application and can be used by the gcloud deployment commands.\@OutputOnly
      codeBucket :: (Core.Maybe Core.Text),
      -- | The type of the Cloud Firestore or Cloud Datastore database associated with this application.
      databaseType :: (Core.Maybe Application_DatabaseType),
      -- | Output only. Google Cloud Storage bucket that can be used by this application to store content.\@OutputOnly
      defaultBucket :: (Core.Maybe Core.Text),
      -- | Cookie expiration policy for this application.
      defaultCookieExpiration :: (Core.Maybe Core.Duration),
      -- | Output only. Hostname used to reach this application, as resolved by App Engine.\@OutputOnly
      defaultHostname :: (Core.Maybe Core.Text),
      -- | HTTP path dispatch rules for requests to the application that do not explicitly target a service or version. Rules are order-dependent. Up to 20 dispatch rules can be supported.
      dispatchRules :: (Core.Maybe [UrlDispatchRule]),
      -- | The feature specific settings to be used in the application.
      featureSettings :: (Core.Maybe FeatureSettings),
      -- | Output only. The Google Container Registry domain used for storing managed build docker images for this application.
      gcrDomain :: (Core.Maybe Core.Text),
      -- | Additional Google Generated Customer Metadata, this field won\'t be provided by default and can be requested by setting the IncludeExtraData field in GetApplicationRequest
      generatedCustomerMetadata :: (Core.Maybe Application_GeneratedCustomerMetadata),
      iap :: (Core.Maybe IdentityAwareProxy),
      -- | Identifier of the Application resource. This identifier is equivalent to the project ID of the Google Cloud Platform project where you want to deploy your application. Example: myapp.
      id :: (Core.Maybe Core.Text),
      -- | Location from which this application runs. Application instances run out of the data centers in the specified location, which is also where all of the application\'s end user content is stored.Defaults to us-central.View the list of supported locations (https:\/\/cloud.google.com\/appengine\/docs\/locations).
      locationId :: (Core.Maybe Core.Text),
      -- | Output only. Full path to the Application resource in the API. Example: apps\/myapp.\@OutputOnly
      name :: (Core.Maybe Core.Text),
      -- | The service account associated with the application. This is the app-level default identity. If no identity provided during create version, Admin API will fallback to this one.
      serviceAccount :: (Core.Maybe Core.Text),
      -- | Serving status of this application.
      servingStatus :: (Core.Maybe Application_ServingStatus),
      -- | The SSL policy that will be applied to the application. If set to Modern it will restrict traffic with TLS \< 1.2 and allow only Modern Ciphers suite
      sslPolicy :: (Core.Maybe Application_SslPolicy)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Application' with the minimum fields required to make a request.
  newApplication ::
    Application
  newApplication =
    Application
      { authDomain = Core.Nothing,
        codeBucket = Core.Nothing,
        databaseType = Core.Nothing,
        defaultBucket = Core.Nothing,
        defaultCookieExpiration = Core.Nothing,
        defaultHostname = Core.Nothing,
        dispatchRules = Core.Nothing,
        featureSettings = Core.Nothing,
        gcrDomain = Core.Nothing,
        generatedCustomerMetadata = Core.Nothing,
        iap = Core.Nothing,
        id = Core.Nothing,
        locationId = Core.Nothing,
        name = Core.Nothing,
        serviceAccount = Core.Nothing,
        servingStatus = Core.Nothing,
        sslPolicy = Core.Nothing
      }
  
  instance Core.FromJSON Application where
    parseJSON =
      Core.withObject
        "Application"
        ( \o ->
            Application
              Core.<$> (o Core..:? "authDomain")
              Core.<*> (o Core..:? "codeBucket")
              Core.<*> (o Core..:? "databaseType")
              Core.<*> (o Core..:? "defaultBucket")
              Core.<*> (o Core..:? "defaultCookieExpiration")
              Core.<*> (o Core..:? "defaultHostname")
              Core.<*> (o Core..:? "dispatchRules")
              Core.<*> (o Core..:? "featureSettings")
              Core.<*> (o Core..:? "gcrDomain")
              Core.<*> (o Core..:? "generatedCustomerMetadata")
              Core.<*> (o Core..:? "iap")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "locationId")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "serviceAccount")
              Core.<*> (o Core..:? "servingStatus")
              Core.<*> (o Core..:? "sslPolicy")
        )
  
  instance Core.ToJSON Application where
    toJSON Application {..} =
      Core.object
        ( Core.catMaybes
            [ ("authDomain" Core..=) Core.<$> authDomain,
              ("codeBucket" Core..=) Core.<$> codeBucket,
              ("databaseType" Core..=) Core.<$> databaseType,
              ("defaultBucket" Core..=) Core.<$> defaultBucket,
              ("defaultCookieExpiration" Core..=)
                Core.<$> defaultCookieExpiration,
              ("defaultHostname" Core..=) Core.<$> defaultHostname,
              ("dispatchRules" Core..=) Core.<$> dispatchRules,
              ("featureSettings" Core..=) Core.<$> featureSettings,
              ("gcrDomain" Core..=) Core.<$> gcrDomain,
              ("generatedCustomerMetadata" Core..=)
                Core.<$> generatedCustomerMetadata,
              ("iap" Core..=) Core.<$> iap,
              ("id" Core..=) Core.<$> id,
              ("locationId" Core..=) Core.<$> locationId,
              ("name" Core..=) Core.<$> name,
              ("serviceAccount" Core..=) Core.<$> serviceAccount,
              ("servingStatus" Core..=) Core.<$> servingStatus,
              ("sslPolicy" Core..=) Core.<$> sslPolicy
            ]
        )
  
  -- | Additional Google Generated Customer Metadata, this field won\'t be provided by default and can be requested by setting the IncludeExtraData field in GetApplicationRequest
  --
  -- /See:/ 'newApplication_GeneratedCustomerMetadata' smart constructor.
  newtype Application_GeneratedCustomerMetadata = Application_GeneratedCustomerMetadata
    { -- | 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 'Application_GeneratedCustomerMetadata' with the minimum fields required to make a request.
  newApplication_GeneratedCustomerMetadata ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Application_GeneratedCustomerMetadata
  newApplication_GeneratedCustomerMetadata additional =
    Application_GeneratedCustomerMetadata {additional = additional}
  
  instance Core.FromJSON Application_GeneratedCustomerMetadata where
    parseJSON =
      Core.withObject
        "Application_GeneratedCustomerMetadata"
        ( \o ->
            Application_GeneratedCustomerMetadata
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON Application_GeneratedCustomerMetadata where
    toJSON Application_GeneratedCustomerMetadata {..} =
      Core.toJSON additional
  
  -- | An SSL certificate that a user has been authorized to administer. A user is authorized to administer any certificate that applies to one of their authorized domains.
  --
  -- /See:/ 'newAuthorizedCertificate' smart constructor.
  data AuthorizedCertificate = AuthorizedCertificate
    { -- | The SSL certificate serving the AuthorizedCertificate resource. This must be obtained independently from a certificate authority.
      certificateRawData :: (Core.Maybe CertificateRawData),
      -- | The user-specified display name of the certificate. This is not guaranteed to be unique. Example: My Certificate.
      displayName :: (Core.Maybe Core.Text),
      -- | Aggregate count of the domain mappings with this certificate mapped. This count includes domain mappings on applications for which the user does not have VIEWER permissions.Only returned by GET or LIST requests when specifically requested by the view=FULL_CERTIFICATE option.\@OutputOnly
      domainMappingsCount :: (Core.Maybe Core.Int32),
      -- | Topmost applicable domains of this certificate. This certificate applies to these domains and their subdomains. Example: example.com.\@OutputOnly
      domainNames :: (Core.Maybe [Core.Text]),
      -- | The time when this certificate expires. To update the renewal time on this certificate, upload an SSL certificate with a different expiration time using AuthorizedCertificates.UpdateAuthorizedCertificate.\@OutputOnly
      expireTime :: (Core.Maybe Core.DateTime),
      -- | Relative name of the certificate. This is a unique value autogenerated on AuthorizedCertificate resource creation. Example: 12345.\@OutputOnly
      id :: (Core.Maybe Core.Text),
      -- | Only applicable if this certificate is managed by App Engine. Managed certificates are tied to the lifecycle of a DomainMapping and cannot be updated or deleted via the AuthorizedCertificates API. If this certificate is manually administered by the user, this field will be empty.\@OutputOnly
      managedCertificate :: (Core.Maybe ManagedCertificate),
      -- | Full path to the AuthorizedCertificate resource in the API. Example: apps\/myapp\/authorizedCertificates\/12345.\@OutputOnly
      name :: (Core.Maybe Core.Text),
      -- | The full paths to user visible Domain Mapping resources that have this certificate mapped. Example: apps\/myapp\/domainMappings\/example.com.This may not represent the full list of mapped domain mappings if the user does not have VIEWER permissions on all of the applications that have this certificate mapped. See domain/mappings/count for a complete count.Only returned by GET or LIST requests when specifically requested by the view=FULL_CERTIFICATE option.\@OutputOnly
      visibleDomainMappings :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuthorizedCertificate' with the minimum fields required to make a request.
  newAuthorizedCertificate ::
    AuthorizedCertificate
  newAuthorizedCertificate =
    AuthorizedCertificate
      { certificateRawData = Core.Nothing,
        displayName = Core.Nothing,
        domainMappingsCount = Core.Nothing,
        domainNames = Core.Nothing,
        expireTime = Core.Nothing,
        id = Core.Nothing,
        managedCertificate = Core.Nothing,
        name = Core.Nothing,
        visibleDomainMappings = Core.Nothing
      }
  
  instance Core.FromJSON AuthorizedCertificate where
    parseJSON =
      Core.withObject
        "AuthorizedCertificate"
        ( \o ->
            AuthorizedCertificate
              Core.<$> (o Core..:? "certificateRawData")
              Core.<*> (o Core..:? "displayName")
              Core.<*> (o Core..:? "domainMappingsCount")
              Core.<*> (o Core..:? "domainNames")
              Core.<*> (o Core..:? "expireTime")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "managedCertificate")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "visibleDomainMappings")
        )
  
  instance Core.ToJSON AuthorizedCertificate where
    toJSON AuthorizedCertificate {..} =
      Core.object
        ( Core.catMaybes
            [ ("certificateRawData" Core..=) Core.<$> certificateRawData,
              ("displayName" Core..=) Core.<$> displayName,
              ("domainMappingsCount" Core..=) Core.<$> domainMappingsCount,
              ("domainNames" Core..=) Core.<$> domainNames,
              ("expireTime" Core..=) Core.<$> expireTime,
              ("id" Core..=) Core.<$> id,
              ("managedCertificate" Core..=) Core.<$> managedCertificate,
              ("name" Core..=) Core.<$> name,
              ("visibleDomainMappings" Core..=) Core.<$> visibleDomainMappings
            ]
        )
  
  -- | A domain that a user has been authorized to administer. To authorize use of a domain, verify ownership via Search Console (https:\/\/search.google.com\/search-console\/welcome).
  --
  -- /See:/ 'newAuthorizedDomain' smart constructor.
  data AuthorizedDomain = AuthorizedDomain
    { -- | Fully qualified domain name of the domain authorized for use. Example: example.com.
      id :: (Core.Maybe Core.Text),
      -- | Full path to the AuthorizedDomain resource in the API. Example: apps\/myapp\/authorizedDomains\/example.com.\@OutputOnly
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AuthorizedDomain' with the minimum fields required to make a request.
  newAuthorizedDomain ::
    AuthorizedDomain
  newAuthorizedDomain =
    AuthorizedDomain {id = Core.Nothing, name = Core.Nothing}
  
  instance Core.FromJSON AuthorizedDomain where
    parseJSON =
      Core.withObject
        "AuthorizedDomain"
        ( \o ->
            AuthorizedDomain
              Core.<$> (o Core..:? "id")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON AuthorizedDomain where
    toJSON AuthorizedDomain {..} =
      Core.object
        ( Core.catMaybes
            [("id" Core..=) Core.<$> id, ("name" Core..=) Core.<$> name]
        )
  
  -- | Automatic scaling is based on request rate, response latencies, and other application metrics.
  --
  -- /See:/ 'newAutomaticScaling' smart constructor.
  data AutomaticScaling = AutomaticScaling
    { -- | The time period that the Autoscaler (https:\/\/cloud.google.com\/compute\/docs\/autoscaler\/) should wait before it starts collecting information from a new instance. This prevents the autoscaler from collecting information when the instance is initializing, during which the collected usage would not be reliable. Only applicable in the App Engine flexible environment.
      coolDownPeriod :: (Core.Maybe Core.Duration),
      -- | Target scaling by CPU usage.
      cpuUtilization :: (Core.Maybe CpuUtilization),
      -- | Target scaling by disk usage.
      diskUtilization :: (Core.Maybe DiskUtilization),
      -- | Number of concurrent requests an automatic scaling instance can accept before the scheduler spawns a new instance.Defaults to a runtime-specific value.
      maxConcurrentRequests :: (Core.Maybe Core.Int32),
      -- | Maximum number of idle instances that should be maintained for this version.
      maxIdleInstances :: (Core.Maybe Core.Int32),
      -- | Maximum amount of time that a request should wait in the pending queue before starting a new instance to handle it.
      maxPendingLatency :: (Core.Maybe Core.Duration),
      -- | Maximum number of instances that should be started to handle requests for this version.
      maxTotalInstances :: (Core.Maybe Core.Int32),
      -- | Minimum number of idle instances that should be maintained for this version. Only applicable for the default version of a service.
      minIdleInstances :: (Core.Maybe Core.Int32),
      -- | Minimum amount of time a request should wait in the pending queue before starting a new instance to handle it.
      minPendingLatency :: (Core.Maybe Core.Duration),
      -- | Minimum number of running instances that should be maintained for this version.
      minTotalInstances :: (Core.Maybe Core.Int32),
      -- | Target scaling by network usage.
      networkUtilization :: (Core.Maybe NetworkUtilization),
      -- | Target scaling by request utilization.
      requestUtilization :: (Core.Maybe RequestUtilization),
      -- | Scheduler settings for standard environment.
      standardSchedulerSettings :: (Core.Maybe StandardSchedulerSettings)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AutomaticScaling' with the minimum fields required to make a request.
  newAutomaticScaling ::
    AutomaticScaling
  newAutomaticScaling =
    AutomaticScaling
      { coolDownPeriod = Core.Nothing,
        cpuUtilization = Core.Nothing,
        diskUtilization = Core.Nothing,
        maxConcurrentRequests = Core.Nothing,
        maxIdleInstances = Core.Nothing,
        maxPendingLatency = Core.Nothing,
        maxTotalInstances = Core.Nothing,
        minIdleInstances = Core.Nothing,
        minPendingLatency = Core.Nothing,
        minTotalInstances = Core.Nothing,
        networkUtilization = Core.Nothing,
        requestUtilization = Core.Nothing,
        standardSchedulerSettings = Core.Nothing
      }
  
  instance Core.FromJSON AutomaticScaling where
    parseJSON =
      Core.withObject
        "AutomaticScaling"
        ( \o ->
            AutomaticScaling
              Core.<$> (o Core..:? "coolDownPeriod")
              Core.<*> (o Core..:? "cpuUtilization")
              Core.<*> (o Core..:? "diskUtilization")
              Core.<*> (o Core..:? "maxConcurrentRequests")
              Core.<*> (o Core..:? "maxIdleInstances")
              Core.<*> (o Core..:? "maxPendingLatency")
              Core.<*> (o Core..:? "maxTotalInstances")
              Core.<*> (o Core..:? "minIdleInstances")
              Core.<*> (o Core..:? "minPendingLatency")
              Core.<*> (o Core..:? "minTotalInstances")
              Core.<*> (o Core..:? "networkUtilization")
              Core.<*> (o Core..:? "requestUtilization")
              Core.<*> (o Core..:? "standardSchedulerSettings")
        )
  
  instance Core.ToJSON AutomaticScaling where
    toJSON AutomaticScaling {..} =
      Core.object
        ( Core.catMaybes
            [ ("coolDownPeriod" Core..=) Core.<$> coolDownPeriod,
              ("cpuUtilization" Core..=) Core.<$> cpuUtilization,
              ("diskUtilization" Core..=) Core.<$> diskUtilization,
              ("maxConcurrentRequests" Core..=) Core.<$> maxConcurrentRequests,
              ("maxIdleInstances" Core..=) Core.<$> maxIdleInstances,
              ("maxPendingLatency" Core..=) Core.<$> maxPendingLatency,
              ("maxTotalInstances" Core..=) Core.<$> maxTotalInstances,
              ("minIdleInstances" Core..=) Core.<$> minIdleInstances,
              ("minPendingLatency" Core..=) Core.<$> minPendingLatency,
              ("minTotalInstances" Core..=) Core.<$> minTotalInstances,
              ("networkUtilization" Core..=) Core.<$> networkUtilization,
              ("requestUtilization" Core..=) Core.<$> requestUtilization,
              ("standardSchedulerSettings" Core..=)
                Core.<$> standardSchedulerSettings
            ]
        )
  
  -- | A service with basic scaling will create an instance when the application receives a request. The instance will be turned down when the app becomes idle. Basic scaling is ideal for work that is intermittent or driven by user activity.
  --
  -- /See:/ 'newBasicScaling' smart constructor.
  data BasicScaling = BasicScaling
    { -- | Duration of time after the last request that an instance must wait before the instance is shut down.
      idleTimeout :: (Core.Maybe Core.Duration),
      -- | Maximum number of instances to create for this version.
      maxInstances :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BasicScaling' with the minimum fields required to make a request.
  newBasicScaling ::
    BasicScaling
  newBasicScaling =
    BasicScaling
      { idleTimeout = Core.Nothing,
        maxInstances = Core.Nothing
      }
  
  instance Core.FromJSON BasicScaling where
    parseJSON =
      Core.withObject
        "BasicScaling"
        ( \o ->
            BasicScaling
              Core.<$> (o Core..:? "idleTimeout")
              Core.<*> (o Core..:? "maxInstances")
        )
  
  instance Core.ToJSON BasicScaling where
    toJSON BasicScaling {..} =
      Core.object
        ( Core.catMaybes
            [ ("idleTimeout" Core..=) Core.<$> idleTimeout,
              ("maxInstances" Core..=) Core.<$> maxInstances
            ]
        )
  
  -- | Request message for Firewall.BatchUpdateIngressRules.
  --
  -- /See:/ 'newBatchUpdateIngressRulesRequest' smart constructor.
  newtype BatchUpdateIngressRulesRequest = BatchUpdateIngressRulesRequest
    { -- | A list of FirewallRules to replace the existing set.
      ingressRules :: (Core.Maybe [FirewallRule])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BatchUpdateIngressRulesRequest' with the minimum fields required to make a request.
  newBatchUpdateIngressRulesRequest ::
    BatchUpdateIngressRulesRequest
  newBatchUpdateIngressRulesRequest =
    BatchUpdateIngressRulesRequest {ingressRules = Core.Nothing}
  
  instance Core.FromJSON BatchUpdateIngressRulesRequest where
    parseJSON =
      Core.withObject
        "BatchUpdateIngressRulesRequest"
        ( \o ->
            BatchUpdateIngressRulesRequest
              Core.<$> (o Core..:? "ingressRules")
        )
  
  instance Core.ToJSON BatchUpdateIngressRulesRequest where
    toJSON BatchUpdateIngressRulesRequest {..} =
      Core.object
        (Core.catMaybes [("ingressRules" Core..=) Core.<$> ingressRules])
  
  -- | Response message for Firewall.UpdateAllIngressRules.
  --
  -- /See:/ 'newBatchUpdateIngressRulesResponse' smart constructor.
  newtype BatchUpdateIngressRulesResponse = BatchUpdateIngressRulesResponse
    { -- | The full list of ingress FirewallRules for this application.
      ingressRules :: (Core.Maybe [FirewallRule])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BatchUpdateIngressRulesResponse' with the minimum fields required to make a request.
  newBatchUpdateIngressRulesResponse ::
    BatchUpdateIngressRulesResponse
  newBatchUpdateIngressRulesResponse =
    BatchUpdateIngressRulesResponse {ingressRules = Core.Nothing}
  
  instance Core.FromJSON BatchUpdateIngressRulesResponse where
    parseJSON =
      Core.withObject
        "BatchUpdateIngressRulesResponse"
        ( \o ->
            BatchUpdateIngressRulesResponse
              Core.<$> (o Core..:? "ingressRules")
        )
  
  instance Core.ToJSON BatchUpdateIngressRulesResponse where
    toJSON BatchUpdateIngressRulesResponse {..} =
      Core.object
        (Core.catMaybes [("ingressRules" Core..=) Core.<$> ingressRules])
  
  -- | An SSL certificate obtained from a certificate authority.
  --
  -- /See:/ 'newCertificateRawData' smart constructor.
  data CertificateRawData = CertificateRawData
    { -- | Unencrypted PEM encoded RSA private key. This field is set once on certificate creation and then encrypted. The key size must be 2048 bits or fewer. Must include the header and footer. Example: -----BEGIN RSA PRIVATE KEY----- -----END RSA PRIVATE KEY----- \@InputOnly
      privateKey :: (Core.Maybe Core.Text),
      -- | PEM encoded x.509 public key certificate. This field is set once on certificate creation. Must include the header and footer. Example: -----BEGIN CERTIFICATE----- -----END CERTIFICATE-----
      publicCertificate :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CertificateRawData' with the minimum fields required to make a request.
  newCertificateRawData ::
    CertificateRawData
  newCertificateRawData =
    CertificateRawData
      { privateKey = Core.Nothing,
        publicCertificate = Core.Nothing
      }
  
  instance Core.FromJSON CertificateRawData where
    parseJSON =
      Core.withObject
        "CertificateRawData"
        ( \o ->
            CertificateRawData
              Core.<$> (o Core..:? "privateKey")
              Core.<*> (o Core..:? "publicCertificate")
        )
  
  instance Core.ToJSON CertificateRawData where
    toJSON CertificateRawData {..} =
      Core.object
        ( Core.catMaybes
            [ ("privateKey" Core..=) Core.<$> privateKey,
              ("publicCertificate" Core..=) Core.<$> publicCertificate
            ]
        )
  
  -- | Options for the build operations performed as a part of the version deployment. Only applicable for App Engine flexible environment when creating a version using source code directly.
  --
  -- /See:/ 'newCloudBuildOptions' smart constructor.
  data CloudBuildOptions = CloudBuildOptions
    { -- | Path to the yaml file used in deployment, used to determine runtime configuration details.Required for flexible environment builds.See https:\/\/cloud.google.com\/appengine\/docs\/standard\/python\/config\/appref for more details.
      appYamlPath :: (Core.Maybe Core.Text),
      -- | The Cloud Build timeout used as part of any dependent builds performed by version creation. Defaults to 10 minutes.
      cloudBuildTimeout :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CloudBuildOptions' with the minimum fields required to make a request.
  newCloudBuildOptions ::
    CloudBuildOptions
  newCloudBuildOptions =
    CloudBuildOptions
      { appYamlPath = Core.Nothing,
        cloudBuildTimeout = Core.Nothing
      }
  
  instance Core.FromJSON CloudBuildOptions where
    parseJSON =
      Core.withObject
        "CloudBuildOptions"
        ( \o ->
            CloudBuildOptions
              Core.<$> (o Core..:? "appYamlPath")
              Core.<*> (o Core..:? "cloudBuildTimeout")
        )
  
  instance Core.ToJSON CloudBuildOptions where
    toJSON CloudBuildOptions {..} =
      Core.object
        ( Core.catMaybes
            [ ("appYamlPath" Core..=) Core.<$> appYamlPath,
              ("cloudBuildTimeout" Core..=) Core.<$> cloudBuildTimeout
            ]
        )
  
  -- | Docker image that is used to create a container and start a VM instance for the version that you deploy. Only applicable for instances running in the App Engine flexible environment.
  --
  -- /See:/ 'newContainerInfo' smart constructor.
  newtype ContainerInfo = ContainerInfo
    { -- | URI to the hosted container image in Google Container Registry. The URI must be fully qualified and include a tag or digest. Examples: \"gcr.io\/my-project\/image:tag\" or \"gcr.io\/my-project\/image\@digest\"
      image :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ContainerInfo' with the minimum fields required to make a request.
  newContainerInfo ::
    ContainerInfo
  newContainerInfo = ContainerInfo {image = Core.Nothing}
  
  instance Core.FromJSON ContainerInfo where
    parseJSON =
      Core.withObject
        "ContainerInfo"
        (\o -> ContainerInfo Core.<$> (o Core..:? "image"))
  
  instance Core.ToJSON ContainerInfo where
    toJSON ContainerInfo {..} =
      Core.object (Core.catMaybes [("image" Core..=) Core.<$> image])
  
  -- | ContainerState contains the externally-visible container state that is used to communicate the state and reasoning for that state to the CLH. This data is not persisted by CCFE, but is instead derived from CCFE\'s internal representation of the container state.
  --
  -- /See:/ 'newContainerState' smart constructor.
  data ContainerState = ContainerState
    { currentReasons :: (Core.Maybe Reasons),
      -- | The previous and current reasons for a container state will be sent for a container event. CLHs that need to know the signal that caused the container event to trigger (edges) as opposed to just knowing the state can act upon differences in the previous and current reasons.Reasons will be provided for every system: service management, data governance, abuse, and billing.If this is a CCFE-triggered event used for reconciliation then the current reasons will be set to their */CONTROL/PLANE/SYNC state. The previous reasons will contain the last known set of non-unknown non-control/plane_sync reasons for the state.
      previousReasons :: (Core.Maybe Reasons),
      -- | The current state of the container. This state is the culmination of all of the opinions from external systems that CCFE knows about of the container.
      state :: (Core.Maybe ContainerState_State)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ContainerState' with the minimum fields required to make a request.
  newContainerState ::
    ContainerState
  newContainerState =
    ContainerState
      { currentReasons = Core.Nothing,
        previousReasons = Core.Nothing,
        state = Core.Nothing
      }
  
  instance Core.FromJSON ContainerState where
    parseJSON =
      Core.withObject
        "ContainerState"
        ( \o ->
            ContainerState
              Core.<$> (o Core..:? "currentReasons")
              Core.<*> (o Core..:? "previousReasons")
              Core.<*> (o Core..:? "state")
        )
  
  instance Core.ToJSON ContainerState where
    toJSON ContainerState {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentReasons" Core..=) Core.<$> currentReasons,
              ("previousReasons" Core..=) Core.<$> previousReasons,
              ("state" Core..=) Core.<$> state
            ]
        )
  
  -- | Target scaling by CPU usage.
  --
  -- /See:/ 'newCpuUtilization' smart constructor.
  data CpuUtilization = CpuUtilization
    { -- | Period of time over which CPU utilization is calculated.
      aggregationWindowLength :: (Core.Maybe Core.Duration),
      -- | Target CPU utilization ratio to maintain when scaling. Must be between 0 and 1.
      targetUtilization :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CpuUtilization' with the minimum fields required to make a request.
  newCpuUtilization ::
    CpuUtilization
  newCpuUtilization =
    CpuUtilization
      { aggregationWindowLength = Core.Nothing,
        targetUtilization = Core.Nothing
      }
  
  instance Core.FromJSON CpuUtilization where
    parseJSON =
      Core.withObject
        "CpuUtilization"
        ( \o ->
            CpuUtilization
              Core.<$> (o Core..:? "aggregationWindowLength")
              Core.<*> (o Core..:? "targetUtilization")
        )
  
  instance Core.ToJSON CpuUtilization where
    toJSON CpuUtilization {..} =
      Core.object
        ( Core.catMaybes
            [ ("aggregationWindowLength" Core..=)
                Core.<$> aggregationWindowLength,
              ("targetUtilization" Core..=) Core.<$> targetUtilization
            ]
        )
  
  -- | Metadata for the given google.longrunning.Operation during a google.appengine.v1.CreateVersionRequest.
  --
  -- /See:/ 'newCreateVersionMetadataV1' smart constructor.
  newtype CreateVersionMetadataV1 = CreateVersionMetadataV1
    { -- | The Cloud Build ID if one was created as part of the version create. \@OutputOnly
      cloudBuildId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateVersionMetadataV1' with the minimum fields required to make a request.
  newCreateVersionMetadataV1 ::
    CreateVersionMetadataV1
  newCreateVersionMetadataV1 =
    CreateVersionMetadataV1 {cloudBuildId = Core.Nothing}
  
  instance Core.FromJSON CreateVersionMetadataV1 where
    parseJSON =
      Core.withObject
        "CreateVersionMetadataV1"
        ( \o ->
            CreateVersionMetadataV1 Core.<$> (o Core..:? "cloudBuildId")
        )
  
  instance Core.ToJSON CreateVersionMetadataV1 where
    toJSON CreateVersionMetadataV1 {..} =
      Core.object
        (Core.catMaybes [("cloudBuildId" Core..=) Core.<$> cloudBuildId])
  
  -- | Metadata for the given google.longrunning.Operation during a google.appengine.v1alpha.CreateVersionRequest.
  --
  -- /See:/ 'newCreateVersionMetadataV1Alpha' smart constructor.
  newtype CreateVersionMetadataV1Alpha = CreateVersionMetadataV1Alpha
    { -- | The Cloud Build ID if one was created as part of the version create. \@OutputOnly
      cloudBuildId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateVersionMetadataV1Alpha' with the minimum fields required to make a request.
  newCreateVersionMetadataV1Alpha ::
    CreateVersionMetadataV1Alpha
  newCreateVersionMetadataV1Alpha =
    CreateVersionMetadataV1Alpha {cloudBuildId = Core.Nothing}
  
  instance Core.FromJSON CreateVersionMetadataV1Alpha where
    parseJSON =
      Core.withObject
        "CreateVersionMetadataV1Alpha"
        ( \o ->
            CreateVersionMetadataV1Alpha Core.<$> (o Core..:? "cloudBuildId")
        )
  
  instance Core.ToJSON CreateVersionMetadataV1Alpha where
    toJSON CreateVersionMetadataV1Alpha {..} =
      Core.object
        (Core.catMaybes [("cloudBuildId" Core..=) Core.<$> cloudBuildId])
  
  -- | Metadata for the given google.longrunning.Operation during a google.appengine.v1beta.CreateVersionRequest.
  --
  -- /See:/ 'newCreateVersionMetadataV1Beta' smart constructor.
  newtype CreateVersionMetadataV1Beta = CreateVersionMetadataV1Beta
    { -- | The Cloud Build ID if one was created as part of the version create. \@OutputOnly
      cloudBuildId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateVersionMetadataV1Beta' with the minimum fields required to make a request.
  newCreateVersionMetadataV1Beta ::
    CreateVersionMetadataV1Beta
  newCreateVersionMetadataV1Beta =
    CreateVersionMetadataV1Beta {cloudBuildId = Core.Nothing}
  
  instance Core.FromJSON CreateVersionMetadataV1Beta where
    parseJSON =
      Core.withObject
        "CreateVersionMetadataV1Beta"
        ( \o ->
            CreateVersionMetadataV1Beta Core.<$> (o Core..:? "cloudBuildId")
        )
  
  instance Core.ToJSON CreateVersionMetadataV1Beta where
    toJSON CreateVersionMetadataV1Beta {..} =
      Core.object
        (Core.catMaybes [("cloudBuildId" Core..=) Core.<$> cloudBuildId])
  
  -- | Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: A full date, with non-zero year, month, and day values. A month and day, with a zero year (for example, an anniversary). A year on its own, with a zero month and a zero day. A year and month, with a zero day (for example, a credit card expiration date).Related types: google.type.TimeOfDay google.type.DateTime google.protobuf.Timestamp
  --
  -- /See:/ 'newDate' smart constructor.
  data Date = Date
    { -- | Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn\'t significant.
      day :: (Core.Maybe Core.Int32),
      -- | Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
      month :: (Core.Maybe Core.Int32),
      -- | Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.
      year :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Date' with the minimum fields required to make a request.
  newDate ::
    Date
  newDate =
    Date
      { day = Core.Nothing,
        month = Core.Nothing,
        year = Core.Nothing
      }
  
  instance Core.FromJSON Date where
    parseJSON =
      Core.withObject
        "Date"
        ( \o ->
            Date
              Core.<$> (o Core..:? "day")
              Core.<*> (o Core..:? "month")
              Core.<*> (o Core..:? "year")
        )
  
  instance Core.ToJSON Date where
    toJSON Date {..} =
      Core.object
        ( Core.catMaybes
            [ ("day" Core..=) Core.<$> day,
              ("month" Core..=) Core.<$> month,
              ("year" Core..=) Core.<$> year
            ]
        )
  
  -- | Request message for Instances.DebugInstance.
  --
  -- /See:/ 'newDebugInstanceRequest' smart constructor.
  newtype DebugInstanceRequest = DebugInstanceRequest
    { -- | Public SSH key to add to the instance. Examples: [USERNAME]:ssh-rsa [KEY/VALUE] [USERNAME] [USERNAME]:ssh-rsa [KEY/VALUE] google-ssh {\"userName\":\"[USERNAME]\",\"expireOn\":\"[EXPIRE_TIME]\"}For more information, see Adding and Removing SSH Keys (https:\/\/cloud.google.com\/compute\/docs\/instances\/adding-removing-ssh-keys).
      sshKey :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DebugInstanceRequest' with the minimum fields required to make a request.
  newDebugInstanceRequest ::
    DebugInstanceRequest
  newDebugInstanceRequest =
    DebugInstanceRequest {sshKey = Core.Nothing}
  
  instance Core.FromJSON DebugInstanceRequest where
    parseJSON =
      Core.withObject
        "DebugInstanceRequest"
        (\o -> DebugInstanceRequest Core.<$> (o Core..:? "sshKey"))
  
  instance Core.ToJSON DebugInstanceRequest where
    toJSON DebugInstanceRequest {..} =
      Core.object (Core.catMaybes [("sshKey" Core..=) Core.<$> sshKey])
  
  -- | Code and application artifacts used to deploy a version to App Engine.
  --
  -- /See:/ 'newDeployment' smart constructor.
  data Deployment = Deployment
    { -- | Options for any Google Cloud Build builds created as a part of this deployment.These options will only be used if a new build is created, such as when deploying to the App Engine flexible environment using files or zip.
      cloudBuildOptions :: (Core.Maybe CloudBuildOptions),
      -- | The Docker image for the container that runs the version. Only applicable for instances running in the App Engine flexible environment.
      container :: (Core.Maybe ContainerInfo),
      -- | Manifest of the files stored in Google Cloud Storage that are included as part of this version. All files must be readable using the credentials supplied with this call.
      files :: (Core.Maybe Deployment_Files),
      -- | The zip file for this deployment, if this is a zip deployment.
      zip :: (Core.Maybe ZipInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Deployment' with the minimum fields required to make a request.
  newDeployment ::
    Deployment
  newDeployment =
    Deployment
      { cloudBuildOptions = Core.Nothing,
        container = Core.Nothing,
        files = Core.Nothing,
        zip = Core.Nothing
      }
  
  instance Core.FromJSON Deployment where
    parseJSON =
      Core.withObject
        "Deployment"
        ( \o ->
            Deployment
              Core.<$> (o Core..:? "cloudBuildOptions")
              Core.<*> (o Core..:? "container")
              Core.<*> (o Core..:? "files")
              Core.<*> (o Core..:? "zip")
        )
  
  instance Core.ToJSON Deployment where
    toJSON Deployment {..} =
      Core.object
        ( Core.catMaybes
            [ ("cloudBuildOptions" Core..=) Core.<$> cloudBuildOptions,
              ("container" Core..=) Core.<$> container,
              ("files" Core..=) Core.<$> files,
              ("zip" Core..=) Core.<$> zip
            ]
        )
  
  -- | Manifest of the files stored in Google Cloud Storage that are included as part of this version. All files must be readable using the credentials supplied with this call.
  --
  -- /See:/ 'newDeployment_Files' smart constructor.
  newtype Deployment_Files = Deployment_Files
    { additional :: (Core.HashMap Core.Text FileInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Deployment_Files' with the minimum fields required to make a request.
  newDeployment_Files ::
    -- |  See 'additional'.
    Core.HashMap Core.Text FileInfo ->
    Deployment_Files
  newDeployment_Files additional =
    Deployment_Files {additional = additional}
  
  instance Core.FromJSON Deployment_Files where
    parseJSON =
      Core.withObject
        "Deployment_Files"
        (\o -> Deployment_Files Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Deployment_Files where
    toJSON Deployment_Files {..} = Core.toJSON additional
  
  -- | Target scaling by disk usage. Only applicable in the App Engine flexible environment.
  --
  -- /See:/ 'newDiskUtilization' smart constructor.
  data DiskUtilization = DiskUtilization
    { -- | Target bytes read per second.
      targetReadBytesPerSecond :: (Core.Maybe Core.Int32),
      -- | Target ops read per seconds.
      targetReadOpsPerSecond :: (Core.Maybe Core.Int32),
      -- | Target bytes written per second.
      targetWriteBytesPerSecond :: (Core.Maybe Core.Int32),
      -- | Target ops written per second.
      targetWriteOpsPerSecond :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DiskUtilization' with the minimum fields required to make a request.
  newDiskUtilization ::
    DiskUtilization
  newDiskUtilization =
    DiskUtilization
      { targetReadBytesPerSecond = Core.Nothing,
        targetReadOpsPerSecond = Core.Nothing,
        targetWriteBytesPerSecond = Core.Nothing,
        targetWriteOpsPerSecond = Core.Nothing
      }
  
  instance Core.FromJSON DiskUtilization where
    parseJSON =
      Core.withObject
        "DiskUtilization"
        ( \o ->
            DiskUtilization
              Core.<$> (o Core..:? "targetReadBytesPerSecond")
              Core.<*> (o Core..:? "targetReadOpsPerSecond")
              Core.<*> (o Core..:? "targetWriteBytesPerSecond")
              Core.<*> (o Core..:? "targetWriteOpsPerSecond")
        )
  
  instance Core.ToJSON DiskUtilization where
    toJSON DiskUtilization {..} =
      Core.object
        ( Core.catMaybes
            [ ("targetReadBytesPerSecond" Core..=)
                Core.<$> targetReadBytesPerSecond,
              ("targetReadOpsPerSecond" Core..=) Core.<$> targetReadOpsPerSecond,
              ("targetWriteBytesPerSecond" Core..=)
                Core.<$> targetWriteBytesPerSecond,
              ("targetWriteOpsPerSecond" Core..=)
                Core.<$> targetWriteOpsPerSecond
            ]
        )
  
  -- | A domain serving an App Engine application.
  --
  -- /See:/ 'newDomainMapping' smart constructor.
  data DomainMapping = DomainMapping
    { -- | Relative name of the domain serving the application. Example: example.com.
      id :: (Core.Maybe Core.Text),
      -- | Full path to the DomainMapping resource in the API. Example: apps\/myapp\/domainMapping\/example.com.\@OutputOnly
      name :: (Core.Maybe Core.Text),
      -- | The resource records required to configure this domain mapping. These records must be added to the domain\'s DNS configuration in order to serve the application via this domain mapping.\@OutputOnly
      resourceRecords :: (Core.Maybe [ResourceRecord]),
      -- | SSL configuration for this domain. If unconfigured, this domain will not serve with SSL.
      sslSettings :: (Core.Maybe SslSettings)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DomainMapping' with the minimum fields required to make a request.
  newDomainMapping ::
    DomainMapping
  newDomainMapping =
    DomainMapping
      { id = Core.Nothing,
        name = Core.Nothing,
        resourceRecords = Core.Nothing,
        sslSettings = Core.Nothing
      }
  
  instance Core.FromJSON DomainMapping where
    parseJSON =
      Core.withObject
        "DomainMapping"
        ( \o ->
            DomainMapping
              Core.<$> (o Core..:? "id")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "resourceRecords")
              Core.<*> (o Core..:? "sslSettings")
        )
  
  instance Core.ToJSON DomainMapping where
    toJSON DomainMapping {..} =
      Core.object
        ( Core.catMaybes
            [ ("id" Core..=) Core.<$> id,
              ("name" Core..=) Core.<$> name,
              ("resourceRecords" Core..=) Core.<$> resourceRecords,
              ("sslSettings" Core..=) Core.<$> sslSettings
            ]
        )
  
  -- | A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
  --
  -- /See:/ 'newEmpty' smart constructor.
  data Empty = Empty
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Empty' with the minimum fields required to make a request.
  newEmpty ::
    Empty
  newEmpty = Empty
  
  instance Core.FromJSON Empty where
    parseJSON = Core.withObject "Empty" (\o -> Core.pure Empty)
  
  instance Core.ToJSON Empty where
    toJSON = Core.const Core.emptyObject
  
  -- | Google Cloud Endpoints (https:\/\/cloud.google.com\/endpoints) configuration. The Endpoints API Service provides tooling for serving Open API and gRPC endpoints via an NGINX proxy. Only valid for App Engine Flexible environment deployments.The fields here refer to the name and configuration ID of a \"service\" resource in the Service Management API (https:\/\/cloud.google.com\/service-management\/overview).
  --
  -- /See:/ 'newEndpointsApiService' smart constructor.
  data EndpointsApiService = EndpointsApiService
    { -- | Endpoints service configuration ID as specified by the Service Management API. For example \"2016-09-19r1\".By default, the rollout strategy for Endpoints is RolloutStrategy.FIXED. This means that Endpoints starts up with a particular configuration ID. When a new configuration is rolled out, Endpoints must be given the new configuration ID. The config/id field is used to give the configuration ID and is required in this case.Endpoints also has a rollout strategy called RolloutStrategy.MANAGED. When using this, Endpoints fetches the latest configuration and does not need the configuration ID. In this case, config/id must be omitted.
      configId :: (Core.Maybe Core.Text),
      -- | Enable or disable trace sampling. By default, this is set to false for enabled.
      disableTraceSampling :: (Core.Maybe Core.Bool),
      -- | Endpoints service name which is the name of the \"service\" resource in the Service Management API. For example \"myapi.endpoints.myproject.cloud.goog\"
      name :: (Core.Maybe Core.Text),
      -- | Endpoints rollout strategy. If FIXED, config/id must be specified. If MANAGED, config/id must be omitted.
      rolloutStrategy :: (Core.Maybe EndpointsApiService_RolloutStrategy)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EndpointsApiService' with the minimum fields required to make a request.
  newEndpointsApiService ::
    EndpointsApiService
  newEndpointsApiService =
    EndpointsApiService
      { configId = Core.Nothing,
        disableTraceSampling = Core.Nothing,
        name = Core.Nothing,
        rolloutStrategy = Core.Nothing
      }
  
  instance Core.FromJSON EndpointsApiService where
    parseJSON =
      Core.withObject
        "EndpointsApiService"
        ( \o ->
            EndpointsApiService
              Core.<$> (o Core..:? "configId")
              Core.<*> (o Core..:? "disableTraceSampling")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "rolloutStrategy")
        )
  
  instance Core.ToJSON EndpointsApiService where
    toJSON EndpointsApiService {..} =
      Core.object
        ( Core.catMaybes
            [ ("configId" Core..=) Core.<$> configId,
              ("disableTraceSampling" Core..=) Core.<$> disableTraceSampling,
              ("name" Core..=) Core.<$> name,
              ("rolloutStrategy" Core..=) Core.<$> rolloutStrategy
            ]
        )
  
  -- | The entrypoint for the application.
  --
  -- /See:/ 'newEntrypoint' smart constructor.
  newtype Entrypoint = Entrypoint
    { -- | The format should be a shell command that can be fed to bash -c.
      shell :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Entrypoint' with the minimum fields required to make a request.
  newEntrypoint ::
    Entrypoint
  newEntrypoint = Entrypoint {shell = Core.Nothing}
  
  instance Core.FromJSON Entrypoint where
    parseJSON =
      Core.withObject
        "Entrypoint"
        (\o -> Entrypoint Core.<$> (o Core..:? "shell"))
  
  instance Core.ToJSON Entrypoint where
    toJSON Entrypoint {..} =
      Core.object (Core.catMaybes [("shell" Core..=) Core.<$> shell])
  
  -- | Custom static error page to be served when an error occurs.
  --
  -- /See:/ 'newErrorHandler' smart constructor.
  data ErrorHandler = ErrorHandler
    { -- | Error condition this handler applies to.
      errorCode :: (Core.Maybe ErrorHandler_ErrorCode),
      -- | MIME type of file. Defaults to text\/html.
      mimeType :: (Core.Maybe Core.Text),
      -- | Static file content to be served for this error.
      staticFile :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ErrorHandler' with the minimum fields required to make a request.
  newErrorHandler ::
    ErrorHandler
  newErrorHandler =
    ErrorHandler
      { errorCode = Core.Nothing,
        mimeType = Core.Nothing,
        staticFile = Core.Nothing
      }
  
  instance Core.FromJSON ErrorHandler where
    parseJSON =
      Core.withObject
        "ErrorHandler"
        ( \o ->
            ErrorHandler
              Core.<$> (o Core..:? "errorCode")
              Core.<*> (o Core..:? "mimeType")
              Core.<*> (o Core..:? "staticFile")
        )
  
  instance Core.ToJSON ErrorHandler where
    toJSON ErrorHandler {..} =
      Core.object
        ( Core.catMaybes
            [ ("errorCode" Core..=) Core.<$> errorCode,
              ("mimeType" Core..=) Core.<$> mimeType,
              ("staticFile" Core..=) Core.<$> staticFile
            ]
        )
  
  -- | The feature specific settings to be used in the application. These define behaviors that are user configurable.
  --
  -- /See:/ 'newFeatureSettings' smart constructor.
  data FeatureSettings = FeatureSettings
    { -- | Boolean value indicating if split health checks should be used instead of the legacy health checks. At an app.yaml level, this means defaulting to \'readiness/check\' and \'liveness/check\' values instead of \'health/check\' ones. Once the legacy \'health/check\' behavior is deprecated, and this value is always true, this setting can be removed.
      splitHealthChecks :: (Core.Maybe Core.Bool),
      -- | If true, use Container-Optimized OS (https:\/\/cloud.google.com\/container-optimized-os\/) base image for VMs, rather than a base Debian image.
      useContainerOptimizedOs :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FeatureSettings' with the minimum fields required to make a request.
  newFeatureSettings ::
    FeatureSettings
  newFeatureSettings =
    FeatureSettings
      { splitHealthChecks = Core.Nothing,
        useContainerOptimizedOs = Core.Nothing
      }
  
  instance Core.FromJSON FeatureSettings where
    parseJSON =
      Core.withObject
        "FeatureSettings"
        ( \o ->
            FeatureSettings
              Core.<$> (o Core..:? "splitHealthChecks")
              Core.<*> (o Core..:? "useContainerOptimizedOs")
        )
  
  instance Core.ToJSON FeatureSettings where
    toJSON FeatureSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("splitHealthChecks" Core..=) Core.<$> splitHealthChecks,
              ("useContainerOptimizedOs" Core..=)
                Core.<$> useContainerOptimizedOs
            ]
        )
  
  -- | Single source file that is part of the version to be deployed. Each source file that is deployed must be specified separately.
  --
  -- /See:/ 'newFileInfo' smart constructor.
  data FileInfo = FileInfo
    { -- | The MIME type of the file.Defaults to the value from Google Cloud Storage.
      mimeType :: (Core.Maybe Core.Text),
      -- | The SHA1 hash of the file, in hex.
      sha1Sum :: (Core.Maybe Core.Text),
      -- | URL source to use to fetch this file. Must be a URL to a resource in Google Cloud Storage in the form \'http(s):\/\/storage.googleapis.com\/\/\'.
      sourceUrl :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FileInfo' with the minimum fields required to make a request.
  newFileInfo ::
    FileInfo
  newFileInfo =
    FileInfo
      { mimeType = Core.Nothing,
        sha1Sum = Core.Nothing,
        sourceUrl = Core.Nothing
      }
  
  instance Core.FromJSON FileInfo where
    parseJSON =
      Core.withObject
        "FileInfo"
        ( \o ->
            FileInfo
              Core.<$> (o Core..:? "mimeType")
              Core.<*> (o Core..:? "sha1Sum")
              Core.<*> (o Core..:? "sourceUrl")
        )
  
  instance Core.ToJSON FileInfo where
    toJSON FileInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("mimeType" Core..=) Core.<$> mimeType,
              ("sha1Sum" Core..=) Core.<$> sha1Sum,
              ("sourceUrl" Core..=) Core.<$> sourceUrl
            ]
        )
  
  -- | A single firewall rule that is evaluated against incoming traffic and provides an action to take on matched requests.
  --
  -- /See:/ 'newFirewallRule' smart constructor.
  data FirewallRule = FirewallRule
    { -- | The action to take on matched requests.
      action :: (Core.Maybe FirewallRule_Action),
      -- | An optional string description of this rule. This field has a maximum length of 400 characters.
      description :: (Core.Maybe Core.Text),
      -- | A positive integer between 1, Int32.MaxValue-1 that defines the order of rule evaluation. Rules with the lowest priority are evaluated first.A default rule at priority Int32.MaxValue matches all IPv4 and IPv6 traffic when no previous rule matches. Only the action of this rule can be modified by the user.
      priority :: (Core.Maybe Core.Int32),
      -- | IP address or range, defined using CIDR notation, of requests that this rule applies to. You can use the wildcard character \"*\" to match all IPs equivalent to \"0\/0\" and \"::\/0\" together. Examples: 192.168.1.1 or 192.168.0.0\/16 or 2001:db8::\/32 or 2001:0db8:0000:0042:0000:8a2e:0370:7334. Truncation will be silently performed on addresses which are not properly truncated. For example, 1.2.3.4\/24 is accepted as the same address as 1.2.3.0\/24. Similarly, for IPv6, 2001:db8::1\/32 is accepted as the same address as 2001:db8::\/32.
      sourceRange :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FirewallRule' with the minimum fields required to make a request.
  newFirewallRule ::
    FirewallRule
  newFirewallRule =
    FirewallRule
      { action = Core.Nothing,
        description = Core.Nothing,
        priority = Core.Nothing,
        sourceRange = Core.Nothing
      }
  
  instance Core.FromJSON FirewallRule where
    parseJSON =
      Core.withObject
        "FirewallRule"
        ( \o ->
            FirewallRule
              Core.<$> (o Core..:? "action")
              Core.<*> (o Core..:? "description")
              Core.<*> (o Core..:? "priority")
              Core.<*> (o Core..:? "sourceRange")
        )
  
  instance Core.ToJSON FirewallRule where
    toJSON FirewallRule {..} =
      Core.object
        ( Core.catMaybes
            [ ("action" Core..=) Core.<$> action,
              ("description" Core..=) Core.<$> description,
              ("priority" Core..=) Core.<$> priority,
              ("sourceRange" Core..=) Core.<$> sourceRange
            ]
        )
  
  -- | Runtime settings for the App Engine flexible environment.
  --
  -- /See:/ 'newFlexibleRuntimeSettings' smart constructor.
  data FlexibleRuntimeSettings = FlexibleRuntimeSettings
    { -- | The operating system of the application runtime.
      operatingSystem :: (Core.Maybe Core.Text),
      -- | The runtime version of an App Engine flexible application.
      runtimeVersion :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FlexibleRuntimeSettings' with the minimum fields required to make a request.
  newFlexibleRuntimeSettings ::
    FlexibleRuntimeSettings
  newFlexibleRuntimeSettings =
    FlexibleRuntimeSettings
      { operatingSystem = Core.Nothing,
        runtimeVersion = Core.Nothing
      }
  
  instance Core.FromJSON FlexibleRuntimeSettings where
    parseJSON =
      Core.withObject
        "FlexibleRuntimeSettings"
        ( \o ->
            FlexibleRuntimeSettings
              Core.<$> (o Core..:? "operatingSystem")
              Core.<*> (o Core..:? "runtimeVersion")
        )
  
  instance Core.ToJSON FlexibleRuntimeSettings where
    toJSON FlexibleRuntimeSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("operatingSystem" Core..=) Core.<$> operatingSystem,
              ("runtimeVersion" Core..=) Core.<$> runtimeVersion
            ]
        )
  
  -- | For use only by GCE. GceTag is a wrapper around the GCE administrative tag with parent info.
  --
  -- /See:/ 'newGceTag' smart constructor.
  data GceTag = GceTag
    { -- | The parents(s) of the tag. Eg. projects\/123, folders\/456 It usually contains only one parent. But, in some corner cases, it can contain multiple parents. Currently, organizations are not supported.
      parent :: (Core.Maybe [Core.Text]),
      -- | The administrative_tag name.
      tag :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GceTag' with the minimum fields required to make a request.
  newGceTag ::
    GceTag
  newGceTag = GceTag {parent = Core.Nothing, tag = Core.Nothing}
  
  instance Core.FromJSON GceTag where
    parseJSON =
      Core.withObject
        "GceTag"
        ( \o ->
            GceTag Core.<$> (o Core..:? "parent") Core.<*> (o Core..:? "tag")
        )
  
  instance Core.ToJSON GceTag where
    toJSON GceTag {..} =
      Core.object
        ( Core.catMaybes
            [("parent" Core..=) Core.<$> parent, ("tag" Core..=) Core.<$> tag]
        )
  
  -- | Metadata for the given google.cloud.location.Location.
  --
  -- /See:/ 'newGoogleAppengineV1betaLocationMetadata' smart constructor.
  data GoogleAppengineV1betaLocationMetadata = GoogleAppengineV1betaLocationMetadata
    { -- | App Engine flexible environment is available in the given location.\@OutputOnly
      flexibleEnvironmentAvailable :: (Core.Maybe Core.Bool),
      -- | Output only. Search API (https:\/\/cloud.google.com\/appengine\/docs\/standard\/python\/search) is available in the given location.
      searchApiAvailable :: (Core.Maybe Core.Bool),
      -- | App Engine standard environment is available in the given location.\@OutputOnly
      standardEnvironmentAvailable :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GoogleAppengineV1betaLocationMetadata' with the minimum fields required to make a request.
  newGoogleAppengineV1betaLocationMetadata ::
    GoogleAppengineV1betaLocationMetadata
  newGoogleAppengineV1betaLocationMetadata =
    GoogleAppengineV1betaLocationMetadata
      { flexibleEnvironmentAvailable =
          Core.Nothing,
        searchApiAvailable = Core.Nothing,
        standardEnvironmentAvailable = Core.Nothing
      }
  
  instance Core.FromJSON GoogleAppengineV1betaLocationMetadata where
    parseJSON =
      Core.withObject
        "GoogleAppengineV1betaLocationMetadata"
        ( \o ->
            GoogleAppengineV1betaLocationMetadata
              Core.<$> (o Core..:? "flexibleEnvironmentAvailable")
              Core.<*> (o Core..:? "searchApiAvailable")
              Core.<*> (o Core..:? "standardEnvironmentAvailable")
        )
  
  instance Core.ToJSON GoogleAppengineV1betaLocationMetadata where
    toJSON GoogleAppengineV1betaLocationMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("flexibleEnvironmentAvailable" Core..=)
                Core.<$> flexibleEnvironmentAvailable,
              ("searchApiAvailable" Core..=) Core.<$> searchApiAvailable,
              ("standardEnvironmentAvailable" Core..=)
                Core.<$> standardEnvironmentAvailable
            ]
        )
  
  -- | Health checking configuration for VM instances. Unhealthy instances are killed and replaced with new instances. Only applicable for instances in App Engine flexible environment.
  --
  -- /See:/ 'newHealthCheck' smart constructor.
  data HealthCheck = HealthCheck
    { -- | Interval between health checks.
      checkInterval :: (Core.Maybe Core.Duration),
      -- | Whether to explicitly disable health checks for this instance.
      disableHealthCheck :: (Core.Maybe Core.Bool),
      -- | Number of consecutive successful health checks required before receiving traffic.
      healthyThreshold :: (Core.Maybe Core.Word32),
      -- | Host header to send when performing an HTTP health check. Example: \"myapp.appspot.com\"
      host :: (Core.Maybe Core.Text),
      -- | Number of consecutive failed health checks required before an instance is restarted.
      restartThreshold :: (Core.Maybe Core.Word32),
      -- | Time before the health check is considered failed.
      timeout :: (Core.Maybe Core.Duration),
      -- | Number of consecutive failed health checks required before removing traffic.
      unhealthyThreshold :: (Core.Maybe Core.Word32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HealthCheck' with the minimum fields required to make a request.
  newHealthCheck ::
    HealthCheck
  newHealthCheck =
    HealthCheck
      { checkInterval = Core.Nothing,
        disableHealthCheck = Core.Nothing,
        healthyThreshold = Core.Nothing,
        host = Core.Nothing,
        restartThreshold = Core.Nothing,
        timeout = Core.Nothing,
        unhealthyThreshold = Core.Nothing
      }
  
  instance Core.FromJSON HealthCheck where
    parseJSON =
      Core.withObject
        "HealthCheck"
        ( \o ->
            HealthCheck
              Core.<$> (o Core..:? "checkInterval")
              Core.<*> (o Core..:? "disableHealthCheck")
              Core.<*> (o Core..:? "healthyThreshold")
              Core.<*> (o Core..:? "host")
              Core.<*> (o Core..:? "restartThreshold")
              Core.<*> (o Core..:? "timeout")
              Core.<*> (o Core..:? "unhealthyThreshold")
        )
  
  instance Core.ToJSON HealthCheck where
    toJSON HealthCheck {..} =
      Core.object
        ( Core.catMaybes
            [ ("checkInterval" Core..=) Core.<$> checkInterval,
              ("disableHealthCheck" Core..=) Core.<$> disableHealthCheck,
              ("healthyThreshold" Core..=) Core.<$> healthyThreshold,
              ("host" Core..=) Core.<$> host,
              ("restartThreshold" Core..=) Core.<$> restartThreshold,
              ("timeout" Core..=) Core.<$> timeout,
              ("unhealthyThreshold" Core..=) Core.<$> unhealthyThreshold
            ]
        )
  
  -- | Identity-Aware Proxy
  --
  -- /See:/ 'newIdentityAwareProxy' smart constructor.
  data IdentityAwareProxy = IdentityAwareProxy
    { -- | Whether the serving infrastructure will authenticate and authorize all incoming requests.If true, the oauth2/client/id and oauth2/client/secret fields must be non-empty.
      enabled :: (Core.Maybe Core.Bool),
      -- | OAuth2 client ID to use for the authentication flow.
      oauth2ClientId :: (Core.Maybe Core.Text),
      -- | OAuth2 client secret to use for the authentication flow.For security reasons, this value cannot be retrieved via the API. Instead, the SHA-256 hash of the value is returned in the oauth2/client/secret_sha256 field.\@InputOnly
      oauth2ClientSecret :: (Core.Maybe Core.Text),
      -- | Output only. Hex-encoded SHA-256 hash of the client secret.\@OutputOnly
      oauth2ClientSecretSha256 :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IdentityAwareProxy' with the minimum fields required to make a request.
  newIdentityAwareProxy ::
    IdentityAwareProxy
  newIdentityAwareProxy =
    IdentityAwareProxy
      { enabled = Core.Nothing,
        oauth2ClientId = Core.Nothing,
        oauth2ClientSecret = Core.Nothing,
        oauth2ClientSecretSha256 = Core.Nothing
      }
  
  instance Core.FromJSON IdentityAwareProxy where
    parseJSON =
      Core.withObject
        "IdentityAwareProxy"
        ( \o ->
            IdentityAwareProxy
              Core.<$> (o Core..:? "enabled")
              Core.<*> (o Core..:? "oauth2ClientId")
              Core.<*> (o Core..:? "oauth2ClientSecret")
              Core.<*> (o Core..:? "oauth2ClientSecretSha256")
        )
  
  instance Core.ToJSON IdentityAwareProxy where
    toJSON IdentityAwareProxy {..} =
      Core.object
        ( Core.catMaybes
            [ ("enabled" Core..=) Core.<$> enabled,
              ("oauth2ClientId" Core..=) Core.<$> oauth2ClientId,
              ("oauth2ClientSecret" Core..=) Core.<$> oauth2ClientSecret,
              ("oauth2ClientSecretSha256" Core..=)
                Core.<$> oauth2ClientSecretSha256
            ]
        )
  
  -- | An Instance resource is the computing unit that App Engine uses to automatically scale an application.
  --
  -- /See:/ 'newInstance' smart constructor.
  data Instance = Instance
    { -- | Output only. App Engine release this instance is running on.
      appEngineRelease :: (Core.Maybe Core.Text),
      -- | Output only. Availability of the instance.
      availability :: (Core.Maybe Instance_Availability),
      -- | Output only. Average latency (ms) over the last minute.
      averageLatency :: (Core.Maybe Core.Int32),
      -- | Output only. Number of errors since this instance was started.
      errors :: (Core.Maybe Core.Int32),
      -- | Output only. Relative name of the instance within the version. Example: instance-1.
      id :: (Core.Maybe Core.Text),
      -- | Output only. Total memory in use (bytes).
      memoryUsage :: (Core.Maybe Core.Int64),
      -- | Output only. Full path to the Instance resource in the API. Example: apps\/myapp\/services\/default\/versions\/v1\/instances\/instance-1.
      name :: (Core.Maybe Core.Text),
      -- | Output only. Average queries per second (QPS) over the last minute.
      qps :: (Core.Maybe Core.Double),
      -- | Output only. Number of requests since this instance was started.
      requests :: (Core.Maybe Core.Int32),
      -- | Output only. Time that this instance was started.\@OutputOnly
      startTime :: (Core.Maybe Core.DateTime),
      -- | Output only. Whether this instance is in debug mode. Only applicable for instances in App Engine flexible environment.
      vmDebugEnabled :: (Core.Maybe Core.Bool),
      -- | Output only. Virtual machine ID of this instance. Only applicable for instances in App Engine flexible environment.
      vmId :: (Core.Maybe Core.Text),
      -- | Output only. The IP address of this instance. Only applicable for instances in App Engine flexible environment.
      vmIp :: (Core.Maybe Core.Text),
      -- | Output only. The liveness health check of this instance. Only applicable for instances in App Engine flexible environment.
      vmLiveness :: (Core.Maybe Instance_VmLiveness),
      -- | Output only. Name of the virtual machine where this instance lives. Only applicable for instances in App Engine flexible environment.
      vmName :: (Core.Maybe Core.Text),
      -- | Output only. Status of the virtual machine where this instance lives. Only applicable for instances in App Engine flexible environment.
      vmStatus :: (Core.Maybe Core.Text),
      -- | Output only. Zone where the virtual machine is located. Only applicable for instances in App Engine flexible environment.
      vmZoneName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Instance' with the minimum fields required to make a request.
  newInstance ::
    Instance
  newInstance =
    Instance
      { appEngineRelease = Core.Nothing,
        availability = Core.Nothing,
        averageLatency = Core.Nothing,
        errors = Core.Nothing,
        id = Core.Nothing,
        memoryUsage = Core.Nothing,
        name = Core.Nothing,
        qps = Core.Nothing,
        requests = Core.Nothing,
        startTime = Core.Nothing,
        vmDebugEnabled = Core.Nothing,
        vmId = Core.Nothing,
        vmIp = Core.Nothing,
        vmLiveness = Core.Nothing,
        vmName = Core.Nothing,
        vmStatus = Core.Nothing,
        vmZoneName = Core.Nothing
      }
  
  instance Core.FromJSON Instance where
    parseJSON =
      Core.withObject
        "Instance"
        ( \o ->
            Instance
              Core.<$> (o Core..:? "appEngineRelease")
              Core.<*> (o Core..:? "availability")
              Core.<*> (o Core..:? "averageLatency")
              Core.<*> (o Core..:? "errors")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "memoryUsage" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "qps")
              Core.<*> (o Core..:? "requests")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "vmDebugEnabled")
              Core.<*> (o Core..:? "vmId")
              Core.<*> (o Core..:? "vmIp")
              Core.<*> (o Core..:? "vmLiveness")
              Core.<*> (o Core..:? "vmName")
              Core.<*> (o Core..:? "vmStatus")
              Core.<*> (o Core..:? "vmZoneName")
        )
  
  instance Core.ToJSON Instance where
    toJSON Instance {..} =
      Core.object
        ( Core.catMaybes
            [ ("appEngineRelease" Core..=) Core.<$> appEngineRelease,
              ("availability" Core..=) Core.<$> availability,
              ("averageLatency" Core..=) Core.<$> averageLatency,
              ("errors" Core..=) Core.<$> errors,
              ("id" Core..=) Core.<$> id,
              ("memoryUsage" Core..=) Core.. Core.AsText Core.<$> memoryUsage,
              ("name" Core..=) Core.<$> name,
              ("qps" Core..=) Core.<$> qps,
              ("requests" Core..=) Core.<$> requests,
              ("startTime" Core..=) Core.<$> startTime,
              ("vmDebugEnabled" Core..=) Core.<$> vmDebugEnabled,
              ("vmId" Core..=) Core.<$> vmId,
              ("vmIp" Core..=) Core.<$> vmIp,
              ("vmLiveness" Core..=) Core.<$> vmLiveness,
              ("vmName" Core..=) Core.<$> vmName,
              ("vmStatus" Core..=) Core.<$> vmStatus,
              ("vmZoneName" Core..=) Core.<$> vmZoneName
            ]
        )
  
  -- | Third-party Python runtime library that is required by the application.
  --
  -- /See:/ 'newLibrary' smart constructor.
  data Library = Library
    { -- | Name of the library. Example: \"django\".
      name :: (Core.Maybe Core.Text),
      -- | Version of the library to select, or \"latest\".
      version :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Library' with the minimum fields required to make a request.
  newLibrary ::
    Library
  newLibrary = Library {name = Core.Nothing, version = Core.Nothing}
  
  instance Core.FromJSON Library where
    parseJSON =
      Core.withObject
        "Library"
        ( \o ->
            Library
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON Library where
    toJSON Library {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | Response message for AuthorizedCertificates.ListAuthorizedCertificates.
  --
  -- /See:/ 'newListAuthorizedCertificatesResponse' smart constructor.
  data ListAuthorizedCertificatesResponse = ListAuthorizedCertificatesResponse
    { -- | The SSL certificates the user is authorized to administer.
      certificates :: (Core.Maybe [AuthorizedCertificate]),
      -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListAuthorizedCertificatesResponse' with the minimum fields required to make a request.
  newListAuthorizedCertificatesResponse ::
    ListAuthorizedCertificatesResponse
  newListAuthorizedCertificatesResponse =
    ListAuthorizedCertificatesResponse
      { certificates = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListAuthorizedCertificatesResponse where
    parseJSON =
      Core.withObject
        "ListAuthorizedCertificatesResponse"
        ( \o ->
            ListAuthorizedCertificatesResponse
              Core.<$> (o Core..:? "certificates")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListAuthorizedCertificatesResponse where
    toJSON ListAuthorizedCertificatesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("certificates" Core..=) Core.<$> certificates,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for AuthorizedDomains.ListAuthorizedDomains.
  --
  -- /See:/ 'newListAuthorizedDomainsResponse' smart constructor.
  data ListAuthorizedDomainsResponse = ListAuthorizedDomainsResponse
    { -- | The authorized domains belonging to the user.
      domains :: (Core.Maybe [AuthorizedDomain]),
      -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListAuthorizedDomainsResponse' with the minimum fields required to make a request.
  newListAuthorizedDomainsResponse ::
    ListAuthorizedDomainsResponse
  newListAuthorizedDomainsResponse =
    ListAuthorizedDomainsResponse
      { domains = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListAuthorizedDomainsResponse where
    parseJSON =
      Core.withObject
        "ListAuthorizedDomainsResponse"
        ( \o ->
            ListAuthorizedDomainsResponse
              Core.<$> (o Core..:? "domains")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListAuthorizedDomainsResponse where
    toJSON ListAuthorizedDomainsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("domains" Core..=) Core.<$> domains,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for DomainMappings.ListDomainMappings.
  --
  -- /See:/ 'newListDomainMappingsResponse' smart constructor.
  data ListDomainMappingsResponse = ListDomainMappingsResponse
    { -- | The domain mappings for the application.
      domainMappings :: (Core.Maybe [DomainMapping]),
      -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListDomainMappingsResponse' with the minimum fields required to make a request.
  newListDomainMappingsResponse ::
    ListDomainMappingsResponse
  newListDomainMappingsResponse =
    ListDomainMappingsResponse
      { domainMappings = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListDomainMappingsResponse where
    parseJSON =
      Core.withObject
        "ListDomainMappingsResponse"
        ( \o ->
            ListDomainMappingsResponse
              Core.<$> (o Core..:? "domainMappings")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListDomainMappingsResponse where
    toJSON ListDomainMappingsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("domainMappings" Core..=) Core.<$> domainMappings,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for Firewall.ListIngressRules.
  --
  -- /See:/ 'newListIngressRulesResponse' smart constructor.
  data ListIngressRulesResponse = ListIngressRulesResponse
    { -- | The ingress FirewallRules for this application.
      ingressRules :: (Core.Maybe [FirewallRule]),
      -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListIngressRulesResponse' with the minimum fields required to make a request.
  newListIngressRulesResponse ::
    ListIngressRulesResponse
  newListIngressRulesResponse =
    ListIngressRulesResponse
      { ingressRules = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListIngressRulesResponse where
    parseJSON =
      Core.withObject
        "ListIngressRulesResponse"
        ( \o ->
            ListIngressRulesResponse
              Core.<$> (o Core..:? "ingressRules")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListIngressRulesResponse where
    toJSON ListIngressRulesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("ingressRules" Core..=) Core.<$> ingressRules,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response message for Instances.ListInstances.
  --
  -- /See:/ 'newListInstancesResponse' smart constructor.
  data ListInstancesResponse = ListInstancesResponse
    { -- | The instances belonging to the requested version.
      instances :: (Core.Maybe [Instance]),
      -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListInstancesResponse' with the minimum fields required to make a request.
  newListInstancesResponse ::
    ListInstancesResponse
  newListInstancesResponse =
    ListInstancesResponse
      { instances = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListInstancesResponse where
    parseJSON =
      Core.withObject
        "ListInstancesResponse"
        ( \o ->
            ListInstancesResponse
              Core.<$> (o Core..:? "instances")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListInstancesResponse where
    toJSON ListInstancesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("instances" Core..=) Core.<$> instances,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | The response message for Locations.ListLocations.
  --
  -- /See:/ 'newListLocationsResponse' smart constructor.
  data ListLocationsResponse = ListLocationsResponse
    { -- | A list of locations that matches the specified filter in the request.
      locations :: (Core.Maybe [Location]),
      -- | The standard List next-page token.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListLocationsResponse' with the minimum fields required to make a request.
  newListLocationsResponse ::
    ListLocationsResponse
  newListLocationsResponse =
    ListLocationsResponse
      { locations = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListLocationsResponse where
    parseJSON =
      Core.withObject
        "ListLocationsResponse"
        ( \o ->
            ListLocationsResponse
              Core.<$> (o Core..:? "locations")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListLocationsResponse where
    toJSON ListLocationsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("locations" Core..=) Core.<$> locations,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | The response message for Operations.ListOperations.
  --
  -- /See:/ 'newListOperationsResponse' smart constructor.
  data ListOperationsResponse = ListOperationsResponse
    { -- | The standard List next-page token.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | A list of operations that matches the specified filter in the request.
      operations :: (Core.Maybe [Operation])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListOperationsResponse' with the minimum fields required to make a request.
  newListOperationsResponse ::
    ListOperationsResponse
  newListOperationsResponse =
    ListOperationsResponse
      { nextPageToken = Core.Nothing,
        operations = Core.Nothing
      }
  
  instance Core.FromJSON ListOperationsResponse where
    parseJSON =
      Core.withObject
        "ListOperationsResponse"
        ( \o ->
            ListOperationsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "operations")
        )
  
  instance Core.ToJSON ListOperationsResponse where
    toJSON ListOperationsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("operations" Core..=) Core.<$> operations
            ]
        )
  
  -- | Response message for Applications.ListRuntimes.
  --
  -- /See:/ 'newListRuntimesResponse' smart constructor.
  data ListRuntimesResponse = ListRuntimesResponse
    { -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The runtimes available to the requested application.
      runtimes :: (Core.Maybe [Runtime])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListRuntimesResponse' with the minimum fields required to make a request.
  newListRuntimesResponse ::
    ListRuntimesResponse
  newListRuntimesResponse =
    ListRuntimesResponse
      { nextPageToken = Core.Nothing,
        runtimes = Core.Nothing
      }
  
  instance Core.FromJSON ListRuntimesResponse where
    parseJSON =
      Core.withObject
        "ListRuntimesResponse"
        ( \o ->
            ListRuntimesResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "runtimes")
        )
  
  instance Core.ToJSON ListRuntimesResponse where
    toJSON ListRuntimesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("runtimes" Core..=) Core.<$> runtimes
            ]
        )
  
  -- | Response message for Services.ListServices.
  --
  -- /See:/ 'newListServicesResponse' smart constructor.
  data ListServicesResponse = ListServicesResponse
    { -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The services belonging to the requested application.
      services :: (Core.Maybe [Service])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListServicesResponse' with the minimum fields required to make a request.
  newListServicesResponse ::
    ListServicesResponse
  newListServicesResponse =
    ListServicesResponse
      { nextPageToken = Core.Nothing,
        services = Core.Nothing
      }
  
  instance Core.FromJSON ListServicesResponse where
    parseJSON =
      Core.withObject
        "ListServicesResponse"
        ( \o ->
            ListServicesResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "services")
        )
  
  instance Core.ToJSON ListServicesResponse where
    toJSON ListServicesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("services" Core..=) Core.<$> services
            ]
        )
  
  -- | Response message for Versions.ListVersions.
  --
  -- /See:/ 'newListVersionsResponse' smart constructor.
  data ListVersionsResponse = ListVersionsResponse
    { -- | Continuation token for fetching the next page of results.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The versions belonging to the requested service.
      versions :: (Core.Maybe [Version])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListVersionsResponse' with the minimum fields required to make a request.
  newListVersionsResponse ::
    ListVersionsResponse
  newListVersionsResponse =
    ListVersionsResponse
      { nextPageToken = Core.Nothing,
        versions = Core.Nothing
      }
  
  instance Core.FromJSON ListVersionsResponse where
    parseJSON =
      Core.withObject
        "ListVersionsResponse"
        ( \o ->
            ListVersionsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "versions")
        )
  
  instance Core.ToJSON ListVersionsResponse where
    toJSON ListVersionsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("versions" Core..=) Core.<$> versions
            ]
        )
  
  -- | Health checking configuration for VM instances. Unhealthy instances are killed and replaced with new instances.
  --
  -- /See:/ 'newLivenessCheck' smart constructor.
  data LivenessCheck = LivenessCheck
    { -- | Interval between health checks.
      checkInterval :: (Core.Maybe Core.Duration),
      -- | Number of consecutive failed checks required before considering the VM unhealthy.
      failureThreshold :: (Core.Maybe Core.Word32),
      -- | Host header to send when performing a HTTP Liveness check. Example: \"myapp.appspot.com\"
      host :: (Core.Maybe Core.Text),
      -- | The initial delay before starting to execute the checks.
      initialDelay :: (Core.Maybe Core.Duration),
      -- | The request path.
      path :: (Core.Maybe Core.Text),
      -- | Number of consecutive successful checks required before considering the VM healthy.
      successThreshold :: (Core.Maybe Core.Word32),
      -- | Time before the check is considered failed.
      timeout :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LivenessCheck' with the minimum fields required to make a request.
  newLivenessCheck ::
    LivenessCheck
  newLivenessCheck =
    LivenessCheck
      { checkInterval = Core.Nothing,
        failureThreshold = Core.Nothing,
        host = Core.Nothing,
        initialDelay = Core.Nothing,
        path = Core.Nothing,
        successThreshold = Core.Nothing,
        timeout = Core.Nothing
      }
  
  instance Core.FromJSON LivenessCheck where
    parseJSON =
      Core.withObject
        "LivenessCheck"
        ( \o ->
            LivenessCheck
              Core.<$> (o Core..:? "checkInterval")
              Core.<*> (o Core..:? "failureThreshold")
              Core.<*> (o Core..:? "host")
              Core.<*> (o Core..:? "initialDelay")
              Core.<*> (o Core..:? "path")
              Core.<*> (o Core..:? "successThreshold")
              Core.<*> (o Core..:? "timeout")
        )
  
  instance Core.ToJSON LivenessCheck where
    toJSON LivenessCheck {..} =
      Core.object
        ( Core.catMaybes
            [ ("checkInterval" Core..=) Core.<$> checkInterval,
              ("failureThreshold" Core..=) Core.<$> failureThreshold,
              ("host" Core..=) Core.<$> host,
              ("initialDelay" Core..=) Core.<$> initialDelay,
              ("path" Core..=) Core.<$> path,
              ("successThreshold" Core..=) Core.<$> successThreshold,
              ("timeout" Core..=) Core.<$> timeout
            ]
        )
  
  -- | A resource that represents a Google Cloud location.
  --
  -- /See:/ 'newLocation' smart constructor.
  data Location = Location
    { -- | The friendly name for this location, typically a nearby city name. For example, \"Tokyo\".
      displayName :: (Core.Maybe Core.Text),
      -- | Cross-service attributes for the location. For example {\"cloud.googleapis.com\/region\": \"us-east1\"}
      labels :: (Core.Maybe Location_Labels),
      -- | The canonical id for this location. For example: \"us-east1\".
      locationId :: (Core.Maybe Core.Text),
      -- | Service-specific metadata. For example the available capacity at the given location.
      metadata :: (Core.Maybe Location_Metadata),
      -- | Resource name for the location, which may vary between implementations. For example: \"projects\/example-project\/locations\/us-east1\"
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Location' with the minimum fields required to make a request.
  newLocation ::
    Location
  newLocation =
    Location
      { displayName = Core.Nothing,
        labels = Core.Nothing,
        locationId = Core.Nothing,
        metadata = Core.Nothing,
        name = Core.Nothing
      }
  
  instance Core.FromJSON Location where
    parseJSON =
      Core.withObject
        "Location"
        ( \o ->
            Location
              Core.<$> (o Core..:? "displayName")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "locationId")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON Location where
    toJSON Location {..} =
      Core.object
        ( Core.catMaybes
            [ ("displayName" Core..=) Core.<$> displayName,
              ("labels" Core..=) Core.<$> labels,
              ("locationId" Core..=) Core.<$> locationId,
              ("metadata" Core..=) Core.<$> metadata,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | Cross-service attributes for the location. For example {\"cloud.googleapis.com\/region\": \"us-east1\"}
  --
  -- /See:/ 'newLocation_Labels' smart constructor.
  newtype Location_Labels = Location_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Location_Labels' with the minimum fields required to make a request.
  newLocation_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Location_Labels
  newLocation_Labels additional =
    Location_Labels {additional = additional}
  
  instance Core.FromJSON Location_Labels where
    parseJSON =
      Core.withObject
        "Location_Labels"
        (\o -> Location_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Location_Labels where
    toJSON Location_Labels {..} = Core.toJSON additional
  
  -- | Service-specific metadata. For example the available capacity at the given location.
  --
  -- /See:/ 'newLocation_Metadata' smart constructor.
  newtype Location_Metadata = Location_Metadata
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Location_Metadata' with the minimum fields required to make a request.
  newLocation_Metadata ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Location_Metadata
  newLocation_Metadata additional =
    Location_Metadata {additional = additional}
  
  instance Core.FromJSON Location_Metadata where
    parseJSON =
      Core.withObject
        "Location_Metadata"
        (\o -> Location_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Location_Metadata where
    toJSON Location_Metadata {..} = Core.toJSON additional
  
  -- | Metadata for the given google.cloud.location.Location.
  --
  -- /See:/ 'newLocationMetadata' smart constructor.
  data LocationMetadata = LocationMetadata
    { -- | App Engine flexible environment is available in the given location.\@OutputOnly
      flexibleEnvironmentAvailable :: (Core.Maybe Core.Bool),
      -- | Output only. Search API (https:\/\/cloud.google.com\/appengine\/docs\/standard\/python\/search) is available in the given location.
      searchApiAvailable :: (Core.Maybe Core.Bool),
      -- | App Engine standard environment is available in the given location.\@OutputOnly
      standardEnvironmentAvailable :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LocationMetadata' with the minimum fields required to make a request.
  newLocationMetadata ::
    LocationMetadata
  newLocationMetadata =
    LocationMetadata
      { flexibleEnvironmentAvailable = Core.Nothing,
        searchApiAvailable = Core.Nothing,
        standardEnvironmentAvailable = Core.Nothing
      }
  
  instance Core.FromJSON LocationMetadata where
    parseJSON =
      Core.withObject
        "LocationMetadata"
        ( \o ->
            LocationMetadata
              Core.<$> (o Core..:? "flexibleEnvironmentAvailable")
              Core.<*> (o Core..:? "searchApiAvailable")
              Core.<*> (o Core..:? "standardEnvironmentAvailable")
        )
  
  instance Core.ToJSON LocationMetadata where
    toJSON LocationMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("flexibleEnvironmentAvailable" Core..=)
                Core.<$> flexibleEnvironmentAvailable,
              ("searchApiAvailable" Core..=) Core.<$> searchApiAvailable,
              ("standardEnvironmentAvailable" Core..=)
                Core.<$> standardEnvironmentAvailable
            ]
        )
  
  -- | A certificate managed by App Engine.
  --
  -- /See:/ 'newManagedCertificate' smart constructor.
  data ManagedCertificate = ManagedCertificate
    { -- | Time at which the certificate was last renewed. The renewal process is fully managed. Certificate renewal will automatically occur before the certificate expires. Renewal errors can be tracked via ManagementStatus.\@OutputOnly
      lastRenewalTime :: (Core.Maybe Core.DateTime),
      -- | Status of certificate management. Refers to the most recent certificate acquisition or renewal attempt.\@OutputOnly
      status :: (Core.Maybe ManagedCertificate_Status)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ManagedCertificate' with the minimum fields required to make a request.
  newManagedCertificate ::
    ManagedCertificate
  newManagedCertificate =
    ManagedCertificate
      { lastRenewalTime = Core.Nothing,
        status = Core.Nothing
      }
  
  instance Core.FromJSON ManagedCertificate where
    parseJSON =
      Core.withObject
        "ManagedCertificate"
        ( \o ->
            ManagedCertificate
              Core.<$> (o Core..:? "lastRenewalTime")
              Core.<*> (o Core..:? "status")
        )
  
  instance Core.ToJSON ManagedCertificate where
    toJSON ManagedCertificate {..} =
      Core.object
        ( Core.catMaybes
            [ ("lastRenewalTime" Core..=) Core.<$> lastRenewalTime,
              ("status" Core..=) Core.<$> status
            ]
        )
  
  -- | A service with manual scaling runs continuously, allowing you to perform complex initialization and rely on the state of its memory over time.
  --
  -- /See:/ 'newManualScaling' smart constructor.
  newtype ManualScaling = ManualScaling
    { -- | Number of instances to assign to the service at the start. This number can later be altered by using the Modules API (https:\/\/cloud.google.com\/appengine\/docs\/python\/modules\/functions) set/num/instances() function.
      instances :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ManualScaling' with the minimum fields required to make a request.
  newManualScaling ::
    ManualScaling
  newManualScaling = ManualScaling {instances = Core.Nothing}
  
  instance Core.FromJSON ManualScaling where
    parseJSON =
      Core.withObject
        "ManualScaling"
        (\o -> ManualScaling Core.<$> (o Core..:? "instances"))
  
  instance Core.ToJSON ManualScaling where
    toJSON ManualScaling {..} =
      Core.object
        (Core.catMaybes [("instances" Core..=) Core.<$> instances])
  
  -- | Extra network settings. Only applicable in the App Engine flexible environment.
  --
  -- /See:/ 'newNetwork' smart constructor.
  data Network = Network
    { -- | List of ports, or port pairs, to forward from the virtual machine to the application container. Only applicable in the App Engine flexible environment.
      forwardedPorts :: (Core.Maybe [Core.Text]),
      -- | The IP mode for instances. Only applicable in the App Engine flexible environment.
      instanceIpMode :: (Core.Maybe Network_InstanceIpMode),
      -- | Tag to apply to the instance during creation. Only applicable in the App Engine flexible environment.
      instanceTag :: (Core.Maybe Core.Text),
      -- | Google Compute Engine network where the virtual machines are created. Specify the short name, not the resource path.Defaults to default.
      name :: (Core.Maybe Core.Text),
      -- | Enable session affinity. Only applicable in the App Engine flexible environment.
      sessionAffinity :: (Core.Maybe Core.Bool),
      -- | Google Cloud Platform sub-network where the virtual machines are created. Specify the short name, not the resource path.If a subnetwork name is specified, a network name will also be required unless it is for the default network. If the network that the instance is being created in is a Legacy network, then the IP address is allocated from the IPv4Range. If the network that the instance is being created in is an auto Subnet Mode Network, then only network name should be specified (not the subnetwork/name) and the IP address is created from the IPCidrRange of the subnetwork that exists in that zone for that network. If the network that the instance is being created in is a custom Subnet Mode Network, then the subnetwork/name must be specified and the IP address is created from the IPCidrRange of the subnetwork.If specified, the subnetwork must exist in the same region as the App Engine flexible environment application.
      subnetworkName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Network' with the minimum fields required to make a request.
  newNetwork ::
    Network
  newNetwork =
    Network
      { forwardedPorts = Core.Nothing,
        instanceIpMode = Core.Nothing,
        instanceTag = Core.Nothing,
        name = Core.Nothing,
        sessionAffinity = Core.Nothing,
        subnetworkName = Core.Nothing
      }
  
  instance Core.FromJSON Network where
    parseJSON =
      Core.withObject
        "Network"
        ( \o ->
            Network
              Core.<$> (o Core..:? "forwardedPorts")
              Core.<*> (o Core..:? "instanceIpMode")
              Core.<*> (o Core..:? "instanceTag")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "sessionAffinity")
              Core.<*> (o Core..:? "subnetworkName")
        )
  
  instance Core.ToJSON Network where
    toJSON Network {..} =
      Core.object
        ( Core.catMaybes
            [ ("forwardedPorts" Core..=) Core.<$> forwardedPorts,
              ("instanceIpMode" Core..=) Core.<$> instanceIpMode,
              ("instanceTag" Core..=) Core.<$> instanceTag,
              ("name" Core..=) Core.<$> name,
              ("sessionAffinity" Core..=) Core.<$> sessionAffinity,
              ("subnetworkName" Core..=) Core.<$> subnetworkName
            ]
        )
  
  -- | A NetworkSettings resource is a container for ingress settings for a version or service.
  --
  -- /See:/ 'newNetworkSettings' smart constructor.
  newtype NetworkSettings = NetworkSettings
    { -- | The ingress settings for version or service.
      ingressTrafficAllowed :: (Core.Maybe NetworkSettings_IngressTrafficAllowed)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'NetworkSettings' with the minimum fields required to make a request.
  newNetworkSettings ::
    NetworkSettings
  newNetworkSettings =
    NetworkSettings {ingressTrafficAllowed = Core.Nothing}
  
  instance Core.FromJSON NetworkSettings where
    parseJSON =
      Core.withObject
        "NetworkSettings"
        ( \o ->
            NetworkSettings Core.<$> (o Core..:? "ingressTrafficAllowed")
        )
  
  instance Core.ToJSON NetworkSettings where
    toJSON NetworkSettings {..} =
      Core.object
        ( Core.catMaybes
            [("ingressTrafficAllowed" Core..=) Core.<$> ingressTrafficAllowed]
        )
  
  -- | Target scaling by network usage. Only applicable in the App Engine flexible environment.
  --
  -- /See:/ 'newNetworkUtilization' smart constructor.
  data NetworkUtilization = NetworkUtilization
    { -- | Target bytes received per second.
      targetReceivedBytesPerSecond :: (Core.Maybe Core.Int32),
      -- | Target packets received per second.
      targetReceivedPacketsPerSecond :: (Core.Maybe Core.Int32),
      -- | Target bytes sent per second.
      targetSentBytesPerSecond :: (Core.Maybe Core.Int32),
      -- | Target packets sent per second.
      targetSentPacketsPerSecond :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'NetworkUtilization' with the minimum fields required to make a request.
  newNetworkUtilization ::
    NetworkUtilization
  newNetworkUtilization =
    NetworkUtilization
      { targetReceivedBytesPerSecond = Core.Nothing,
        targetReceivedPacketsPerSecond = Core.Nothing,
        targetSentBytesPerSecond = Core.Nothing,
        targetSentPacketsPerSecond = Core.Nothing
      }
  
  instance Core.FromJSON NetworkUtilization where
    parseJSON =
      Core.withObject
        "NetworkUtilization"
        ( \o ->
            NetworkUtilization
              Core.<$> (o Core..:? "targetReceivedBytesPerSecond")
              Core.<*> (o Core..:? "targetReceivedPacketsPerSecond")
              Core.<*> (o Core..:? "targetSentBytesPerSecond")
              Core.<*> (o Core..:? "targetSentPacketsPerSecond")
        )
  
  instance Core.ToJSON NetworkUtilization where
    toJSON NetworkUtilization {..} =
      Core.object
        ( Core.catMaybes
            [ ("targetReceivedBytesPerSecond" Core..=)
                Core.<$> targetReceivedBytesPerSecond,
              ("targetReceivedPacketsPerSecond" Core..=)
                Core.<$> targetReceivedPacketsPerSecond,
              ("targetSentBytesPerSecond" Core..=)
                Core.<$> targetSentBytesPerSecond,
              ("targetSentPacketsPerSecond" Core..=)
                Core.<$> targetSentPacketsPerSecond
            ]
        )
  
  -- | This resource represents a long-running operation that is the result of a network API call.
  --
  -- /See:/ 'newOperation' smart constructor.
  data Operation = Operation
    { -- | If the value is false, it means the operation is still in progress. If true, the operation is completed, and either error or response is available.
      done :: (Core.Maybe Core.Bool),
      -- | The error result of the operation in case of failure or cancellation.
      error :: (Core.Maybe Status),
      -- | Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
      metadata :: (Core.Maybe Operation_Metadata),
      -- | The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the name should be a resource name ending with operations\/{unique_id}.
      name :: (Core.Maybe Core.Text),
      -- | The normal, successful response of the operation. If the original method returns no data on success, such as Delete, the response is google.protobuf.Empty. If the original method is standard Get\/Create\/Update, the response should be the resource. For other methods, the response should have the type XxxResponse, where Xxx is the original method name. For example, if the original method name is TakeSnapshot(), the inferred response type is TakeSnapshotResponse.
      response :: (Core.Maybe Operation_Response)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Operation' with the minimum fields required to make a request.
  newOperation ::
    Operation
  newOperation =
    Operation
      { done = Core.Nothing,
        error = Core.Nothing,
        metadata = Core.Nothing,
        name = Core.Nothing,
        response = Core.Nothing
      }
  
  instance Core.FromJSON Operation where
    parseJSON =
      Core.withObject
        "Operation"
        ( \o ->
            Operation
              Core.<$> (o Core..:? "done")
              Core.<*> (o Core..:? "error")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "response")
        )
  
  instance Core.ToJSON Operation where
    toJSON Operation {..} =
      Core.object
        ( Core.catMaybes
            [ ("done" Core..=) Core.<$> done,
              ("error" Core..=) Core.<$> error,
              ("metadata" Core..=) Core.<$> metadata,
              ("name" Core..=) Core.<$> name,
              ("response" Core..=) Core.<$> response
            ]
        )
  
  -- | Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
  --
  -- /See:/ 'newOperation_Metadata' smart constructor.
  newtype Operation_Metadata = Operation_Metadata
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Operation_Metadata' with the minimum fields required to make a request.
  newOperation_Metadata ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Operation_Metadata
  newOperation_Metadata additional =
    Operation_Metadata {additional = additional}
  
  instance Core.FromJSON Operation_Metadata where
    parseJSON =
      Core.withObject
        "Operation_Metadata"
        (\o -> Operation_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Operation_Metadata where
    toJSON Operation_Metadata {..} = Core.toJSON additional
  
  -- | The normal, successful response of the operation. If the original method returns no data on success, such as Delete, the response is google.protobuf.Empty. If the original method is standard Get\/Create\/Update, the response should be the resource. For other methods, the response should have the type XxxResponse, where Xxx is the original method name. For example, if the original method name is TakeSnapshot(), the inferred response type is TakeSnapshotResponse.
  --
  -- /See:/ 'newOperation_Response' smart constructor.
  newtype Operation_Response = Operation_Response
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Operation_Response' with the minimum fields required to make a request.
  newOperation_Response ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Operation_Response
  newOperation_Response additional =
    Operation_Response {additional = additional}
  
  instance Core.FromJSON Operation_Response where
    parseJSON =
      Core.withObject
        "Operation_Response"
        (\o -> Operation_Response Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Operation_Response where
    toJSON Operation_Response {..} = Core.toJSON additional
  
  -- | Metadata for the given google.longrunning.Operation.
  --
  -- /See:/ 'newOperationMetadataV1' smart constructor.
  data OperationMetadataV1 = OperationMetadataV1
    { createVersionMetadata :: (Core.Maybe CreateVersionMetadataV1),
      -- | Time that this operation completed.\@OutputOnly
      endTime :: (Core.Maybe Core.DateTime),
      -- | Ephemeral message that may change every time the operation is polled. \@OutputOnly
      ephemeralMessage :: (Core.Maybe Core.Text),
      -- | Time that this operation was created.\@OutputOnly
      insertTime :: (Core.Maybe Core.DateTime),
      -- | API method that initiated this operation. Example: google.appengine.v1.Versions.CreateVersion.\@OutputOnly
      method :: (Core.Maybe Core.Text),
      -- | Name of the resource that this operation is acting on. Example: apps\/myapp\/services\/default.\@OutputOnly
      target :: (Core.Maybe Core.Text),
      -- | User who requested this operation.\@OutputOnly
      user :: (Core.Maybe Core.Text),
      -- | Durable messages that persist on every operation poll. \@OutputOnly
      warning :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OperationMetadataV1' with the minimum fields required to make a request.
  newOperationMetadataV1 ::
    OperationMetadataV1
  newOperationMetadataV1 =
    OperationMetadataV1
      { createVersionMetadata = Core.Nothing,
        endTime = Core.Nothing,
        ephemeralMessage = Core.Nothing,
        insertTime = Core.Nothing,
        method = Core.Nothing,
        target = Core.Nothing,
        user = Core.Nothing,
        warning = Core.Nothing
      }
  
  instance Core.FromJSON OperationMetadataV1 where
    parseJSON =
      Core.withObject
        "OperationMetadataV1"
        ( \o ->
            OperationMetadataV1
              Core.<$> (o Core..:? "createVersionMetadata")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "ephemeralMessage")
              Core.<*> (o Core..:? "insertTime")
              Core.<*> (o Core..:? "method")
              Core.<*> (o Core..:? "target")
              Core.<*> (o Core..:? "user")
              Core.<*> (o Core..:? "warning")
        )
  
  instance Core.ToJSON OperationMetadataV1 where
    toJSON OperationMetadataV1 {..} =
      Core.object
        ( Core.catMaybes
            [ ("createVersionMetadata" Core..=) Core.<$> createVersionMetadata,
              ("endTime" Core..=) Core.<$> endTime,
              ("ephemeralMessage" Core..=) Core.<$> ephemeralMessage,
              ("insertTime" Core..=) Core.<$> insertTime,
              ("method" Core..=) Core.<$> method,
              ("target" Core..=) Core.<$> target,
              ("user" Core..=) Core.<$> user,
              ("warning" Core..=) Core.<$> warning
            ]
        )
  
  -- | Metadata for the given google.longrunning.Operation.
  --
  -- /See:/ 'newOperationMetadataV1Alpha' smart constructor.
  data OperationMetadataV1Alpha = OperationMetadataV1Alpha
    { createVersionMetadata :: (Core.Maybe CreateVersionMetadataV1Alpha),
      -- | Time that this operation completed.\@OutputOnly
      endTime :: (Core.Maybe Core.DateTime),
      -- | Ephemeral message that may change every time the operation is polled. \@OutputOnly
      ephemeralMessage :: (Core.Maybe Core.Text),
      -- | Time that this operation was created.\@OutputOnly
      insertTime :: (Core.Maybe Core.DateTime),
      -- | API method that initiated this operation. Example: google.appengine.v1alpha.Versions.CreateVersion.\@OutputOnly
      method :: (Core.Maybe Core.Text),
      -- | Name of the resource that this operation is acting on. Example: apps\/myapp\/services\/default.\@OutputOnly
      target :: (Core.Maybe Core.Text),
      -- | User who requested this operation.\@OutputOnly
      user :: (Core.Maybe Core.Text),
      -- | Durable messages that persist on every operation poll. \@OutputOnly
      warning :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OperationMetadataV1Alpha' with the minimum fields required to make a request.
  newOperationMetadataV1Alpha ::
    OperationMetadataV1Alpha
  newOperationMetadataV1Alpha =
    OperationMetadataV1Alpha
      { createVersionMetadata = Core.Nothing,
        endTime = Core.Nothing,
        ephemeralMessage = Core.Nothing,
        insertTime = Core.Nothing,
        method = Core.Nothing,
        target = Core.Nothing,
        user = Core.Nothing,
        warning = Core.Nothing
      }
  
  instance Core.FromJSON OperationMetadataV1Alpha where
    parseJSON =
      Core.withObject
        "OperationMetadataV1Alpha"
        ( \o ->
            OperationMetadataV1Alpha
              Core.<$> (o Core..:? "createVersionMetadata")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "ephemeralMessage")
              Core.<*> (o Core..:? "insertTime")
              Core.<*> (o Core..:? "method")
              Core.<*> (o Core..:? "target")
              Core.<*> (o Core..:? "user")
              Core.<*> (o Core..:? "warning")
        )
  
  instance Core.ToJSON OperationMetadataV1Alpha where
    toJSON OperationMetadataV1Alpha {..} =
      Core.object
        ( Core.catMaybes
            [ ("createVersionMetadata" Core..=) Core.<$> createVersionMetadata,
              ("endTime" Core..=) Core.<$> endTime,
              ("ephemeralMessage" Core..=) Core.<$> ephemeralMessage,
              ("insertTime" Core..=) Core.<$> insertTime,
              ("method" Core..=) Core.<$> method,
              ("target" Core..=) Core.<$> target,
              ("user" Core..=) Core.<$> user,
              ("warning" Core..=) Core.<$> warning
            ]
        )
  
  -- | Metadata for the given google.longrunning.Operation.
  --
  -- /See:/ 'newOperationMetadataV1Beta' smart constructor.
  data OperationMetadataV1Beta = OperationMetadataV1Beta
    { createVersionMetadata :: (Core.Maybe CreateVersionMetadataV1Beta),
      -- | Time that this operation completed.\@OutputOnly
      endTime :: (Core.Maybe Core.DateTime),
      -- | Ephemeral message that may change every time the operation is polled. \@OutputOnly
      ephemeralMessage :: (Core.Maybe Core.Text),
      -- | Time that this operation was created.\@OutputOnly
      insertTime :: (Core.Maybe Core.DateTime),
      -- | API method that initiated this operation. Example: google.appengine.v1beta.Versions.CreateVersion.\@OutputOnly
      method :: (Core.Maybe Core.Text),
      -- | Name of the resource that this operation is acting on. Example: apps\/myapp\/services\/default.\@OutputOnly
      target :: (Core.Maybe Core.Text),
      -- | User who requested this operation.\@OutputOnly
      user :: (Core.Maybe Core.Text),
      -- | Durable messages that persist on every operation poll. \@OutputOnly
      warning :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OperationMetadataV1Beta' with the minimum fields required to make a request.
  newOperationMetadataV1Beta ::
    OperationMetadataV1Beta
  newOperationMetadataV1Beta =
    OperationMetadataV1Beta
      { createVersionMetadata = Core.Nothing,
        endTime = Core.Nothing,
        ephemeralMessage = Core.Nothing,
        insertTime = Core.Nothing,
        method = Core.Nothing,
        target = Core.Nothing,
        user = Core.Nothing,
        warning = Core.Nothing
      }
  
  instance Core.FromJSON OperationMetadataV1Beta where
    parseJSON =
      Core.withObject
        "OperationMetadataV1Beta"
        ( \o ->
            OperationMetadataV1Beta
              Core.<$> (o Core..:? "createVersionMetadata")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "ephemeralMessage")
              Core.<*> (o Core..:? "insertTime")
              Core.<*> (o Core..:? "method")
              Core.<*> (o Core..:? "target")
              Core.<*> (o Core..:? "user")
              Core.<*> (o Core..:? "warning")
        )
  
  instance Core.ToJSON OperationMetadataV1Beta where
    toJSON OperationMetadataV1Beta {..} =
      Core.object
        ( Core.catMaybes
            [ ("createVersionMetadata" Core..=) Core.<$> createVersionMetadata,
              ("endTime" Core..=) Core.<$> endTime,
              ("ephemeralMessage" Core..=) Core.<$> ephemeralMessage,
              ("insertTime" Core..=) Core.<$> insertTime,
              ("method" Core..=) Core.<$> method,
              ("target" Core..=) Core.<$> target,
              ("user" Core..=) Core.<$> user,
              ("warning" Core..=) Core.<$> warning
            ]
        )
  
  -- | The request sent to CLHs during project events.
  --
  -- /See:/ 'newProjectEvent' smart constructor.
  data ProjectEvent = ProjectEvent
    { -- | The unique ID for this project event. CLHs can use this value to dedup repeated calls. required
      eventId :: (Core.Maybe Core.Text),
      -- | Phase indicates when in the container event propagation this event is being communicated. Events are sent before and after the per-resource events are propagated. required
      phase :: (Core.Maybe ProjectEvent_Phase),
      -- | The projects metadata for this project. required
      projectMetadata :: (Core.Maybe ProjectsMetadata),
      -- | The state of the organization that led to this event.
      state :: (Core.Maybe ContainerState)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ProjectEvent' with the minimum fields required to make a request.
  newProjectEvent ::
    ProjectEvent
  newProjectEvent =
    ProjectEvent
      { eventId = Core.Nothing,
        phase = Core.Nothing,
        projectMetadata = Core.Nothing,
        state = Core.Nothing
      }
  
  instance Core.FromJSON ProjectEvent where
    parseJSON =
      Core.withObject
        "ProjectEvent"
        ( \o ->
            ProjectEvent
              Core.<$> (o Core..:? "eventId")
              Core.<*> (o Core..:? "phase")
              Core.<*> (o Core..:? "projectMetadata")
              Core.<*> (o Core..:? "state")
        )
  
  instance Core.ToJSON ProjectEvent where
    toJSON ProjectEvent {..} =
      Core.object
        ( Core.catMaybes
            [ ("eventId" Core..=) Core.<$> eventId,
              ("phase" Core..=) Core.<$> phase,
              ("projectMetadata" Core..=) Core.<$> projectMetadata,
              ("state" Core..=) Core.<$> state
            ]
        )
  
  -- | ProjectsMetadata is the metadata CCFE stores about the all the relevant projects (tenant, consumer, producer).
  --
  -- /See:/ 'newProjectsMetadata' smart constructor.
  data ProjectsMetadata = ProjectsMetadata
    { -- | The consumer project id.
      consumerProjectId :: (Core.Maybe Core.Text),
      -- | The consumer project number.
      consumerProjectNumber :: (Core.Maybe Core.Int64),
      -- | The CCFE state of the consumer project. It is the same state that is communicated to the CLH during project events. Notice that this field is not set in the DB, it is only set in this proto when communicated to CLH in the side channel.
      consumerProjectState :: (Core.Maybe ProjectsMetadata_ConsumerProjectState),
      -- | The GCE tags associated with the consumer project and those inherited due to their ancestry, if any. Not supported by CCFE.
      gceTag :: (Core.Maybe [GceTag]),
      -- | The service account authorized to operate on the consumer project. Note: CCFE only propagates P4SA with default tag to CLH.
      p4ServiceAccount :: (Core.Maybe Core.Text),
      -- | The producer project id.
      producerProjectId :: (Core.Maybe Core.Text),
      -- | The producer project number.
      producerProjectNumber :: (Core.Maybe Core.Int64),
      -- | The tenant project id.
      tenantProjectId :: (Core.Maybe Core.Text),
      -- | The tenant project number.
      tenantProjectNumber :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ProjectsMetadata' with the minimum fields required to make a request.
  newProjectsMetadata ::
    ProjectsMetadata
  newProjectsMetadata =
    ProjectsMetadata
      { consumerProjectId = Core.Nothing,
        consumerProjectNumber = Core.Nothing,
        consumerProjectState = Core.Nothing,
        gceTag = Core.Nothing,
        p4ServiceAccount = Core.Nothing,
        producerProjectId = Core.Nothing,
        producerProjectNumber = Core.Nothing,
        tenantProjectId = Core.Nothing,
        tenantProjectNumber = Core.Nothing
      }
  
  instance Core.FromJSON ProjectsMetadata where
    parseJSON =
      Core.withObject
        "ProjectsMetadata"
        ( \o ->
            ProjectsMetadata
              Core.<$> (o Core..:? "consumerProjectId")
              Core.<*> ( o
                           Core..:? "consumerProjectNumber"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "consumerProjectState")
              Core.<*> (o Core..:? "gceTag")
              Core.<*> (o Core..:? "p4ServiceAccount")
              Core.<*> (o Core..:? "producerProjectId")
              Core.<*> ( o
                           Core..:? "producerProjectNumber"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "tenantProjectId")
              Core.<*> ( o
                           Core..:? "tenantProjectNumber"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON ProjectsMetadata where
    toJSON ProjectsMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("consumerProjectId" Core..=) Core.<$> consumerProjectId,
              ("consumerProjectNumber" Core..=)
                Core.. Core.AsText
                Core.<$> consumerProjectNumber,
              ("consumerProjectState" Core..=) Core.<$> consumerProjectState,
              ("gceTag" Core..=) Core.<$> gceTag,
              ("p4ServiceAccount" Core..=) Core.<$> p4ServiceAccount,
              ("producerProjectId" Core..=) Core.<$> producerProjectId,
              ("producerProjectNumber" Core..=)
                Core.. Core.AsText
                Core.<$> producerProjectNumber,
              ("tenantProjectId" Core..=) Core.<$> tenantProjectId,
              ("tenantProjectNumber" Core..=)
                Core.. Core.AsText
                Core.<$> tenantProjectNumber
            ]
        )
  
  -- | Readiness checking configuration for VM instances. Unhealthy instances are removed from traffic rotation.
  --
  -- /See:/ 'newReadinessCheck' smart constructor.
  data ReadinessCheck = ReadinessCheck
    { -- | A maximum time limit on application initialization, measured from moment the application successfully replies to a healthcheck until it is ready to serve traffic.
      appStartTimeout :: (Core.Maybe Core.Duration),
      -- | Interval between health checks.
      checkInterval :: (Core.Maybe Core.Duration),
      -- | Number of consecutive failed checks required before removing traffic.
      failureThreshold :: (Core.Maybe Core.Word32),
      -- | Host header to send when performing a HTTP Readiness check. Example: \"myapp.appspot.com\"
      host :: (Core.Maybe Core.Text),
      -- | The request path.
      path :: (Core.Maybe Core.Text),
      -- | Number of consecutive successful checks required before receiving traffic.
      successThreshold :: (Core.Maybe Core.Word32),
      -- | Time before the check is considered failed.
      timeout :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReadinessCheck' with the minimum fields required to make a request.
  newReadinessCheck ::
    ReadinessCheck
  newReadinessCheck =
    ReadinessCheck
      { appStartTimeout = Core.Nothing,
        checkInterval = Core.Nothing,
        failureThreshold = Core.Nothing,
        host = Core.Nothing,
        path = Core.Nothing,
        successThreshold = Core.Nothing,
        timeout = Core.Nothing
      }
  
  instance Core.FromJSON ReadinessCheck where
    parseJSON =
      Core.withObject
        "ReadinessCheck"
        ( \o ->
            ReadinessCheck
              Core.<$> (o Core..:? "appStartTimeout")
              Core.<*> (o Core..:? "checkInterval")
              Core.<*> (o Core..:? "failureThreshold")
              Core.<*> (o Core..:? "host")
              Core.<*> (o Core..:? "path")
              Core.<*> (o Core..:? "successThreshold")
              Core.<*> (o Core..:? "timeout")
        )
  
  instance Core.ToJSON ReadinessCheck where
    toJSON ReadinessCheck {..} =
      Core.object
        ( Core.catMaybes
            [ ("appStartTimeout" Core..=) Core.<$> appStartTimeout,
              ("checkInterval" Core..=) Core.<$> checkInterval,
              ("failureThreshold" Core..=) Core.<$> failureThreshold,
              ("host" Core..=) Core.<$> host,
              ("path" Core..=) Core.<$> path,
              ("successThreshold" Core..=) Core.<$> successThreshold,
              ("timeout" Core..=) Core.<$> timeout
            ]
        )
  
  -- | Containers transition between and within states based on reasons sent from various systems. CCFE will provide the CLH with reasons for the current state per system.The current systems that CCFE supports are: Service Management (Inception) Data Governance (Wipeout) Abuse (Ares) Billing (Internal Cloud Billing API) Service Activation (Service Controller)
  --
  -- /See:/ 'newReasons' smart constructor.
  data Reasons = Reasons
    { abuse :: (Core.Maybe Reasons_Abuse),
      billing :: (Core.Maybe Reasons_Billing),
      dataGovernance :: (Core.Maybe Reasons_DataGovernance),
      -- | Consumer Container denotes if the service is active within a project or not. This information could be used to clean up resources in case service in DISABLED_FULL i.e. Service is inactive > 30 days.
      serviceActivation :: (Core.Maybe Reasons_ServiceActivation),
      serviceManagement :: (Core.Maybe Reasons_ServiceManagement)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Reasons' with the minimum fields required to make a request.
  newReasons ::
    Reasons
  newReasons =
    Reasons
      { abuse = Core.Nothing,
        billing = Core.Nothing,
        dataGovernance = Core.Nothing,
        serviceActivation = Core.Nothing,
        serviceManagement = Core.Nothing
      }
  
  instance Core.FromJSON Reasons where
    parseJSON =
      Core.withObject
        "Reasons"
        ( \o ->
            Reasons
              Core.<$> (o Core..:? "abuse")
              Core.<*> (o Core..:? "billing")
              Core.<*> (o Core..:? "dataGovernance")
              Core.<*> (o Core..:? "serviceActivation")
              Core.<*> (o Core..:? "serviceManagement")
        )
  
  instance Core.ToJSON Reasons where
    toJSON Reasons {..} =
      Core.object
        ( Core.catMaybes
            [ ("abuse" Core..=) Core.<$> abuse,
              ("billing" Core..=) Core.<$> billing,
              ("dataGovernance" Core..=) Core.<$> dataGovernance,
              ("serviceActivation" Core..=) Core.<$> serviceActivation,
              ("serviceManagement" Core..=) Core.<$> serviceManagement
            ]
        )
  
  -- | Request message for \'Applications.RepairApplication\'.
  --
  -- /See:/ 'newRepairApplicationRequest' smart constructor.
  data RepairApplicationRequest = RepairApplicationRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RepairApplicationRequest' with the minimum fields required to make a request.
  newRepairApplicationRequest ::
    RepairApplicationRequest
  newRepairApplicationRequest = RepairApplicationRequest
  
  instance Core.FromJSON RepairApplicationRequest where
    parseJSON =
      Core.withObject
        "RepairApplicationRequest"
        (\o -> Core.pure RepairApplicationRequest)
  
  instance Core.ToJSON RepairApplicationRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | Target scaling by request utilization. Only applicable in the App Engine flexible environment.
  --
  -- /See:/ 'newRequestUtilization' smart constructor.
  data RequestUtilization = RequestUtilization
    { -- | Target number of concurrent requests.
      targetConcurrentRequests :: (Core.Maybe Core.Int32),
      -- | Target requests per second.
      targetRequestCountPerSecond :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RequestUtilization' with the minimum fields required to make a request.
  newRequestUtilization ::
    RequestUtilization
  newRequestUtilization =
    RequestUtilization
      { targetConcurrentRequests = Core.Nothing,
        targetRequestCountPerSecond = Core.Nothing
      }
  
  instance Core.FromJSON RequestUtilization where
    parseJSON =
      Core.withObject
        "RequestUtilization"
        ( \o ->
            RequestUtilization
              Core.<$> (o Core..:? "targetConcurrentRequests")
              Core.<*> (o Core..:? "targetRequestCountPerSecond")
        )
  
  instance Core.ToJSON RequestUtilization where
    toJSON RequestUtilization {..} =
      Core.object
        ( Core.catMaybes
            [ ("targetConcurrentRequests" Core..=)
                Core.<$> targetConcurrentRequests,
              ("targetRequestCountPerSecond" Core..=)
                Core.<$> targetRequestCountPerSecond
            ]
        )
  
  -- | The request that is passed to CLH during per-resource events. The request will be sent with update semantics in all cases except for data governance purge events. These events will be sent with delete semantics and the CLH is expected to delete the resource receiving this event.
  --
  -- /See:/ 'newResourceEvent' smart constructor.
  data ResourceEvent = ResourceEvent
    { -- | The unique ID for this per-resource event. CLHs can use this value to dedup repeated calls. required
      eventId :: (Core.Maybe Core.Text),
      -- | The name of the resource for which this event is. required
      name :: (Core.Maybe Core.Text),
      -- | The state of the project that led to this event.
      state :: (Core.Maybe ContainerState)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceEvent' with the minimum fields required to make a request.
  newResourceEvent ::
    ResourceEvent
  newResourceEvent =
    ResourceEvent
      { eventId = Core.Nothing,
        name = Core.Nothing,
        state = Core.Nothing
      }
  
  instance Core.FromJSON ResourceEvent where
    parseJSON =
      Core.withObject
        "ResourceEvent"
        ( \o ->
            ResourceEvent
              Core.<$> (o Core..:? "eventId")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "state")
        )
  
  instance Core.ToJSON ResourceEvent where
    toJSON ResourceEvent {..} =
      Core.object
        ( Core.catMaybes
            [ ("eventId" Core..=) Core.<$> eventId,
              ("name" Core..=) Core.<$> name,
              ("state" Core..=) Core.<$> state
            ]
        )
  
  -- | A DNS resource record.
  --
  -- /See:/ 'newResourceRecord' smart constructor.
  data ResourceRecord = ResourceRecord
    { -- | Relative name of the object affected by this record. Only applicable for CNAME records. Example: \'www\'.
      name :: (Core.Maybe Core.Text),
      -- | Data for this record. Values vary by record type, as defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1).
      rrdata :: (Core.Maybe Core.Text),
      -- | Resource record type. Example: AAAA.
      type' :: (Core.Maybe ResourceRecord_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceRecord' with the minimum fields required to make a request.
  newResourceRecord ::
    ResourceRecord
  newResourceRecord =
    ResourceRecord
      { name = Core.Nothing,
        rrdata = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON ResourceRecord where
    parseJSON =
      Core.withObject
        "ResourceRecord"
        ( \o ->
            ResourceRecord
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "rrdata")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON ResourceRecord where
    toJSON ResourceRecord {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("rrdata" Core..=) Core.<$> rrdata,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | Machine resources for a version.
  --
  -- /See:/ 'newResources' smart constructor.
  data Resources = Resources
    { -- | Number of CPU cores needed.
      cpu :: (Core.Maybe Core.Double),
      -- | Disk size (GB) needed.
      diskGb :: (Core.Maybe Core.Double),
      -- | The name of the encryption key that is stored in Google Cloud KMS. Only should be used by Cloud Composer to encrypt the vm disk
      kmsKeyReference :: (Core.Maybe Core.Text),
      -- | Memory (GB) needed.
      memoryGb :: (Core.Maybe Core.Double),
      -- | User specified volumes.
      volumes :: (Core.Maybe [Volume])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Resources' with the minimum fields required to make a request.
  newResources ::
    Resources
  newResources =
    Resources
      { cpu = Core.Nothing,
        diskGb = Core.Nothing,
        kmsKeyReference = Core.Nothing,
        memoryGb = Core.Nothing,
        volumes = Core.Nothing
      }
  
  instance Core.FromJSON Resources where
    parseJSON =
      Core.withObject
        "Resources"
        ( \o ->
            Resources
              Core.<$> (o Core..:? "cpu")
              Core.<*> (o Core..:? "diskGb")
              Core.<*> (o Core..:? "kmsKeyReference")
              Core.<*> (o Core..:? "memoryGb")
              Core.<*> (o Core..:? "volumes")
        )
  
  instance Core.ToJSON Resources where
    toJSON Resources {..} =
      Core.object
        ( Core.catMaybes
            [ ("cpu" Core..=) Core.<$> cpu,
              ("diskGb" Core..=) Core.<$> diskGb,
              ("kmsKeyReference" Core..=) Core.<$> kmsKeyReference,
              ("memoryGb" Core..=) Core.<$> memoryGb,
              ("volumes" Core..=) Core.<$> volumes
            ]
        )
  
  -- | Runtime versions for App Engine.
  --
  -- /See:/ 'newRuntime' smart constructor.
  data Runtime = Runtime
    { -- | Date when Runtime is decommissioned.
      decommissionedDate :: (Core.Maybe Date),
      -- | Date when Runtime is deprecated.
      deprecationDate :: (Core.Maybe Date),
      -- | User-friendly display name, e.g. \'Node.js 12\', etc.
      displayName :: (Core.Maybe Core.Text),
      -- | Date when Runtime is end of support.
      endOfSupportDate :: (Core.Maybe Date),
      -- | The environment of the runtime.
      environment :: (Core.Maybe Runtime_Environment),
      -- | The name of the runtime, e.g., \'go113\', \'nodejs12\', etc.
      name :: (Core.Maybe Core.Text),
      -- | The stage of life this runtime is in, e.g., BETA, GA, etc.
      stage :: (Core.Maybe Runtime_Stage),
      -- | Supported operating systems for the runtime, e.g., \'ubuntu22\', etc.
      supportedOperatingSystems :: (Core.Maybe [Core.Text]),
      -- | Warning messages, e.g., a deprecation warning.
      warnings :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Runtime' with the minimum fields required to make a request.
  newRuntime ::
    Runtime
  newRuntime =
    Runtime
      { decommissionedDate = Core.Nothing,
        deprecationDate = Core.Nothing,
        displayName = Core.Nothing,
        endOfSupportDate = Core.Nothing,
        environment = Core.Nothing,
        name = Core.Nothing,
        stage = Core.Nothing,
        supportedOperatingSystems = Core.Nothing,
        warnings = Core.Nothing
      }
  
  instance Core.FromJSON Runtime where
    parseJSON =
      Core.withObject
        "Runtime"
        ( \o ->
            Runtime
              Core.<$> (o Core..:? "decommissionedDate")
              Core.<*> (o Core..:? "deprecationDate")
              Core.<*> (o Core..:? "displayName")
              Core.<*> (o Core..:? "endOfSupportDate")
              Core.<*> (o Core..:? "environment")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "stage")
              Core.<*> (o Core..:? "supportedOperatingSystems")
              Core.<*> (o Core..:? "warnings")
        )
  
  instance Core.ToJSON Runtime where
    toJSON Runtime {..} =
      Core.object
        ( Core.catMaybes
            [ ("decommissionedDate" Core..=) Core.<$> decommissionedDate,
              ("deprecationDate" Core..=) Core.<$> deprecationDate,
              ("displayName" Core..=) Core.<$> displayName,
              ("endOfSupportDate" Core..=) Core.<$> endOfSupportDate,
              ("environment" Core..=) Core.<$> environment,
              ("name" Core..=) Core.<$> name,
              ("stage" Core..=) Core.<$> stage,
              ("supportedOperatingSystems" Core..=)
                Core.<$> supportedOperatingSystems,
              ("warnings" Core..=) Core.<$> warnings
            ]
        )
  
  -- | Executes a script to handle the request that matches the URL pattern.
  --
  -- /See:/ 'newScriptHandler' smart constructor.
  newtype ScriptHandler = ScriptHandler
    { -- | Path to the script from the application root directory.
      scriptPath :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ScriptHandler' with the minimum fields required to make a request.
  newScriptHandler ::
    ScriptHandler
  newScriptHandler = ScriptHandler {scriptPath = Core.Nothing}
  
  instance Core.FromJSON ScriptHandler where
    parseJSON =
      Core.withObject
        "ScriptHandler"
        (\o -> ScriptHandler Core.<$> (o Core..:? "scriptPath"))
  
  instance Core.ToJSON ScriptHandler where
    toJSON ScriptHandler {..} =
      Core.object
        (Core.catMaybes [("scriptPath" Core..=) Core.<$> scriptPath])
  
  -- | A Service resource is a logical component of an application that can share state and communicate in a secure fashion with other services. For example, an application that handles customer requests might include separate services to handle tasks such as backend data analysis or API requests from mobile devices. Each service has a collection of versions that define a specific set of code used to implement the functionality of that service.
  --
  -- /See:/ 'newService' smart constructor.
  data Service = Service
    { -- | Additional Google Generated Customer Metadata, this field won\'t be provided by default and can be requested by setting the IncludeExtraData field in GetServiceRequest
      generatedCustomerMetadata :: (Core.Maybe Service_GeneratedCustomerMetadata),
      -- | Output only. Relative name of the service within the application. Example: default.\@OutputOnly
      id :: (Core.Maybe Core.Text),
      -- | A set of labels to apply to this service. Labels are key\/value pairs that describe the service and all resources that belong to it (e.g., versions). The labels can be used to search and group resources, and are propagated to the usage and billing reports, enabling fine-grain analysis of costs. An example of using labels is to tag resources belonging to different environments (e.g., \"env=prod\", \"env=qa\"). Label keys and values can be no longer than 63 characters and can only contain lowercase letters, numeric characters, underscores, dashes, and international characters. Label keys must start with a lowercase letter or an international character. Each service can have at most 32 labels.
      labels :: (Core.Maybe Service_Labels),
      -- | Output only. Full path to the Service resource in the API. Example: apps\/myapp\/services\/default.\@OutputOnly
      name :: (Core.Maybe Core.Text),
      -- | Ingress settings for this service. Will apply to all versions.
      networkSettings :: (Core.Maybe NetworkSettings),
      -- | Mapping that defines fractional HTTP traffic diversion to different versions within the service.
      split :: (Core.Maybe TrafficSplit)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Service' with the minimum fields required to make a request.
  newService ::
    Service
  newService =
    Service
      { generatedCustomerMetadata = Core.Nothing,
        id = Core.Nothing,
        labels = Core.Nothing,
        name = Core.Nothing,
        networkSettings = Core.Nothing,
        split = Core.Nothing
      }
  
  instance Core.FromJSON Service where
    parseJSON =
      Core.withObject
        "Service"
        ( \o ->
            Service
              Core.<$> (o Core..:? "generatedCustomerMetadata")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "networkSettings")
              Core.<*> (o Core..:? "split")
        )
  
  instance Core.ToJSON Service where
    toJSON Service {..} =
      Core.object
        ( Core.catMaybes
            [ ("generatedCustomerMetadata" Core..=)
                Core.<$> generatedCustomerMetadata,
              ("id" Core..=) Core.<$> id,
              ("labels" Core..=) Core.<$> labels,
              ("name" Core..=) Core.<$> name,
              ("networkSettings" Core..=) Core.<$> networkSettings,
              ("split" Core..=) Core.<$> split
            ]
        )
  
  -- | Additional Google Generated Customer Metadata, this field won\'t be provided by default and can be requested by setting the IncludeExtraData field in GetServiceRequest
  --
  -- /See:/ 'newService_GeneratedCustomerMetadata' smart constructor.
  newtype Service_GeneratedCustomerMetadata = Service_GeneratedCustomerMetadata
    { -- | 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 'Service_GeneratedCustomerMetadata' with the minimum fields required to make a request.
  newService_GeneratedCustomerMetadata ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Service_GeneratedCustomerMetadata
  newService_GeneratedCustomerMetadata additional =
    Service_GeneratedCustomerMetadata {additional = additional}
  
  instance Core.FromJSON Service_GeneratedCustomerMetadata where
    parseJSON =
      Core.withObject
        "Service_GeneratedCustomerMetadata"
        ( \o ->
            Service_GeneratedCustomerMetadata
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON Service_GeneratedCustomerMetadata where
    toJSON Service_GeneratedCustomerMetadata {..} =
      Core.toJSON additional
  
  -- | A set of labels to apply to this service. Labels are key\/value pairs that describe the service and all resources that belong to it (e.g., versions). The labels can be used to search and group resources, and are propagated to the usage and billing reports, enabling fine-grain analysis of costs. An example of using labels is to tag resources belonging to different environments (e.g., \"env=prod\", \"env=qa\"). Label keys and values can be no longer than 63 characters and can only contain lowercase letters, numeric characters, underscores, dashes, and international characters. Label keys must start with a lowercase letter or an international character. Each service can have at most 32 labels.
  --
  -- /See:/ 'newService_Labels' smart constructor.
  newtype Service_Labels = Service_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Service_Labels' with the minimum fields required to make a request.
  newService_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Service_Labels
  newService_Labels additional =
    Service_Labels {additional = additional}
  
  instance Core.FromJSON Service_Labels where
    parseJSON =
      Core.withObject
        "Service_Labels"
        (\o -> Service_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Service_Labels where
    toJSON Service_Labels {..} = Core.toJSON additional
  
  -- | SSL configuration for a DomainMapping resource.
  --
  -- /See:/ 'newSslSettings' smart constructor.
  data SslSettings = SslSettings
    { -- | ID of the AuthorizedCertificate resource configuring SSL for the application. Clearing this field will remove SSL support.By default, a managed certificate is automatically created for every domain mapping. To omit SSL support or to configure SSL manually, specify SslManagementType.MANUAL on a CREATE or UPDATE request. You must be authorized to administer the AuthorizedCertificate resource to manually map it to a DomainMapping resource. Example: 12345.
      certificateId :: (Core.Maybe Core.Text),
      -- | ID of the managed AuthorizedCertificate resource currently being provisioned, if applicable. Until the new managed certificate has been successfully provisioned, the previous SSL state will be preserved. Once the provisioning process completes, the certificate/id field will reflect the new managed certificate and this field will be left empty. To remove SSL support while there is still a pending managed certificate, clear the certificate/id field with an UpdateDomainMappingRequest.\@OutputOnly
      pendingManagedCertificateId :: (Core.Maybe Core.Text),
      -- | SSL management type for this domain. If AUTOMATIC, a managed certificate is automatically provisioned. If MANUAL, certificate_id must be manually specified in order to configure SSL for this domain.
      sslManagementType :: (Core.Maybe SslSettings_SslManagementType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SslSettings' with the minimum fields required to make a request.
  newSslSettings ::
    SslSettings
  newSslSettings =
    SslSettings
      { certificateId = Core.Nothing,
        pendingManagedCertificateId = Core.Nothing,
        sslManagementType = Core.Nothing
      }
  
  instance Core.FromJSON SslSettings where
    parseJSON =
      Core.withObject
        "SslSettings"
        ( \o ->
            SslSettings
              Core.<$> (o Core..:? "certificateId")
              Core.<*> (o Core..:? "pendingManagedCertificateId")
              Core.<*> (o Core..:? "sslManagementType")
        )
  
  instance Core.ToJSON SslSettings where
    toJSON SslSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("certificateId" Core..=) Core.<$> certificateId,
              ("pendingManagedCertificateId" Core..=)
                Core.<$> pendingManagedCertificateId,
              ("sslManagementType" Core..=) Core.<$> sslManagementType
            ]
        )
  
  -- | Scheduler settings for standard environment.
  --
  -- /See:/ 'newStandardSchedulerSettings' smart constructor.
  data StandardSchedulerSettings = StandardSchedulerSettings
    { -- | Maximum number of instances to run for this version. Set to 2147483647 to disable max_instances configuration.
      maxInstances :: (Core.Maybe Core.Int32),
      -- | Minimum number of instances to run for this version. Set to zero to disable min_instances configuration.
      minInstances :: (Core.Maybe Core.Int32),
      -- | Target CPU utilization ratio to maintain when scaling.
      targetCpuUtilization :: (Core.Maybe Core.Double),
      -- | Target throughput utilization ratio to maintain when scaling
      targetThroughputUtilization :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StandardSchedulerSettings' with the minimum fields required to make a request.
  newStandardSchedulerSettings ::
    StandardSchedulerSettings
  newStandardSchedulerSettings =
    StandardSchedulerSettings
      { maxInstances = Core.Nothing,
        minInstances = Core.Nothing,
        targetCpuUtilization = Core.Nothing,
        targetThroughputUtilization = Core.Nothing
      }
  
  instance Core.FromJSON StandardSchedulerSettings where
    parseJSON =
      Core.withObject
        "StandardSchedulerSettings"
        ( \o ->
            StandardSchedulerSettings
              Core.<$> (o Core..:? "maxInstances")
              Core.<*> (o Core..:? "minInstances")
              Core.<*> (o Core..:? "targetCpuUtilization")
              Core.<*> (o Core..:? "targetThroughputUtilization")
        )
  
  instance Core.ToJSON StandardSchedulerSettings where
    toJSON StandardSchedulerSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("maxInstances" Core..=) Core.<$> maxInstances,
              ("minInstances" Core..=) Core.<$> minInstances,
              ("targetCpuUtilization" Core..=) Core.<$> targetCpuUtilization,
              ("targetThroughputUtilization" Core..=)
                Core.<$> targetThroughputUtilization
            ]
        )
  
  -- | Files served directly to the user for a given URL, such as images, CSS stylesheets, or JavaScript source files. Static file handlers describe which files in the application directory are static files, and which URLs serve them.
  --
  -- /See:/ 'newStaticFilesHandler' smart constructor.
  data StaticFilesHandler = StaticFilesHandler
    { -- | Whether files should also be uploaded as code data. By default, files declared in static file handlers are uploaded as static data and are only served to end users; they cannot be read by the application. If enabled, uploads are charged against both your code and static data storage resource quotas.
      applicationReadable :: (Core.Maybe Core.Bool),
      -- | Time a static file served by this handler should be cached by web proxies and browsers.
      expiration :: (Core.Maybe Core.Duration),
      -- | HTTP headers to use for all responses from these URLs.
      httpHeaders :: (Core.Maybe StaticFilesHandler_HttpHeaders),
      -- | MIME type used to serve all files served by this handler.Defaults to file-specific MIME types, which are derived from each file\'s filename extension.
      mimeType :: (Core.Maybe Core.Text),
      -- | Path to the static files matched by the URL pattern, from the application root directory. The path can refer to text matched in groupings in the URL pattern.
      path :: (Core.Maybe Core.Text),
      -- | Whether this handler should match the request if the file referenced by the handler does not exist.
      requireMatchingFile :: (Core.Maybe Core.Bool),
      -- | Regular expression that matches the file paths for all files that should be referenced by this handler.
      uploadPathRegex :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StaticFilesHandler' with the minimum fields required to make a request.
  newStaticFilesHandler ::
    StaticFilesHandler
  newStaticFilesHandler =
    StaticFilesHandler
      { applicationReadable = Core.Nothing,
        expiration = Core.Nothing,
        httpHeaders = Core.Nothing,
        mimeType = Core.Nothing,
        path = Core.Nothing,
        requireMatchingFile = Core.Nothing,
        uploadPathRegex = Core.Nothing
      }
  
  instance Core.FromJSON StaticFilesHandler where
    parseJSON =
      Core.withObject
        "StaticFilesHandler"
        ( \o ->
            StaticFilesHandler
              Core.<$> (o Core..:? "applicationReadable")
              Core.<*> (o Core..:? "expiration")
              Core.<*> (o Core..:? "httpHeaders")
              Core.<*> (o Core..:? "mimeType")
              Core.<*> (o Core..:? "path")
              Core.<*> (o Core..:? "requireMatchingFile")
              Core.<*> (o Core..:? "uploadPathRegex")
        )
  
  instance Core.ToJSON StaticFilesHandler where
    toJSON StaticFilesHandler {..} =
      Core.object
        ( Core.catMaybes
            [ ("applicationReadable" Core..=) Core.<$> applicationReadable,
              ("expiration" Core..=) Core.<$> expiration,
              ("httpHeaders" Core..=) Core.<$> httpHeaders,
              ("mimeType" Core..=) Core.<$> mimeType,
              ("path" Core..=) Core.<$> path,
              ("requireMatchingFile" Core..=) Core.<$> requireMatchingFile,
              ("uploadPathRegex" Core..=) Core.<$> uploadPathRegex
            ]
        )
  
  -- | HTTP headers to use for all responses from these URLs.
  --
  -- /See:/ 'newStaticFilesHandler_HttpHeaders' smart constructor.
  newtype StaticFilesHandler_HttpHeaders = StaticFilesHandler_HttpHeaders
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StaticFilesHandler_HttpHeaders' with the minimum fields required to make a request.
  newStaticFilesHandler_HttpHeaders ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    StaticFilesHandler_HttpHeaders
  newStaticFilesHandler_HttpHeaders additional =
    StaticFilesHandler_HttpHeaders {additional = additional}
  
  instance Core.FromJSON StaticFilesHandler_HttpHeaders where
    parseJSON =
      Core.withObject
        "StaticFilesHandler_HttpHeaders"
        ( \o ->
            StaticFilesHandler_HttpHeaders Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON StaticFilesHandler_HttpHeaders where
    toJSON StaticFilesHandler_HttpHeaders {..} = Core.toJSON additional
  
  -- | The Status type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by gRPC (https:\/\/github.com\/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 API Design Guide (https:\/\/cloud.google.com\/apis\/design\/errors).
  --
  -- /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
  
  -- | Traffic routing configuration for versions within a single service. Traffic splits define how traffic directed to the service is assigned to versions.
  --
  -- /See:/ 'newTrafficSplit' smart constructor.
  data TrafficSplit = TrafficSplit
    { -- | Mapping from version IDs within the service to fractional (0.000, 1] allocations of traffic for that version. Each version can be specified only once, but some versions in the service may not have any traffic allocation. Services that have traffic allocated cannot be deleted until either the service is deleted or their traffic allocation is removed. Allocations must sum to 1. Up to two decimal place precision is supported for IP-based splits and up to three decimal places is supported for cookie-based splits.
      allocations :: (Core.Maybe TrafficSplit_Allocations),
      -- | Mechanism used to determine which version a request is sent to. The traffic selection algorithm will be stable for either type until allocations are changed.
      shardBy :: (Core.Maybe TrafficSplit_ShardBy)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TrafficSplit' with the minimum fields required to make a request.
  newTrafficSplit ::
    TrafficSplit
  newTrafficSplit =
    TrafficSplit {allocations = Core.Nothing, shardBy = Core.Nothing}
  
  instance Core.FromJSON TrafficSplit where
    parseJSON =
      Core.withObject
        "TrafficSplit"
        ( \o ->
            TrafficSplit
              Core.<$> (o Core..:? "allocations")
              Core.<*> (o Core..:? "shardBy")
        )
  
  instance Core.ToJSON TrafficSplit where
    toJSON TrafficSplit {..} =
      Core.object
        ( Core.catMaybes
            [ ("allocations" Core..=) Core.<$> allocations,
              ("shardBy" Core..=) Core.<$> shardBy
            ]
        )
  
  -- | Mapping from version IDs within the service to fractional (0.000, 1] allocations of traffic for that version. Each version can be specified only once, but some versions in the service may not have any traffic allocation. Services that have traffic allocated cannot be deleted until either the service is deleted or their traffic allocation is removed. Allocations must sum to 1. Up to two decimal place precision is supported for IP-based splits and up to three decimal places is supported for cookie-based splits.
  --
  -- /See:/ 'newTrafficSplit_Allocations' smart constructor.
  newtype TrafficSplit_Allocations = TrafficSplit_Allocations
    { additional :: (Core.HashMap Core.Text Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TrafficSplit_Allocations' with the minimum fields required to make a request.
  newTrafficSplit_Allocations ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Double ->
    TrafficSplit_Allocations
  newTrafficSplit_Allocations additional =
    TrafficSplit_Allocations {additional = additional}
  
  instance Core.FromJSON TrafficSplit_Allocations where
    parseJSON =
      Core.withObject
        "TrafficSplit_Allocations"
        (\o -> TrafficSplit_Allocations Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON TrafficSplit_Allocations where
    toJSON TrafficSplit_Allocations {..} = Core.toJSON additional
  
  -- | Rules to match an HTTP request and dispatch that request to a service.
  --
  -- /See:/ 'newUrlDispatchRule' smart constructor.
  data UrlDispatchRule = UrlDispatchRule
    { -- | Domain name to match against. The wildcard \"/\" is supported if specified before a period: \"/.\".Defaults to matching all domains: \"*\".
      domain :: (Core.Maybe Core.Text),
      -- | Pathname within the host. Must start with a \"\/\". A single \"*\" can be included at the end of the path.The sum of the lengths of the domain and path may not exceed 100 characters.
      path :: (Core.Maybe Core.Text),
      -- | Resource ID of a service in this application that should serve the matched request. The service must already exist. Example: default.
      service :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UrlDispatchRule' with the minimum fields required to make a request.
  newUrlDispatchRule ::
    UrlDispatchRule
  newUrlDispatchRule =
    UrlDispatchRule
      { domain = Core.Nothing,
        path = Core.Nothing,
        service = Core.Nothing
      }
  
  instance Core.FromJSON UrlDispatchRule where
    parseJSON =
      Core.withObject
        "UrlDispatchRule"
        ( \o ->
            UrlDispatchRule
              Core.<$> (o Core..:? "domain")
              Core.<*> (o Core..:? "path")
              Core.<*> (o Core..:? "service")
        )
  
  instance Core.ToJSON UrlDispatchRule where
    toJSON UrlDispatchRule {..} =
      Core.object
        ( Core.catMaybes
            [ ("domain" Core..=) Core.<$> domain,
              ("path" Core..=) Core.<$> path,
              ("service" Core..=) Core.<$> service
            ]
        )
  
  -- | URL pattern and description of how the URL should be handled. App Engine can handle URLs by executing application code or by serving static files uploaded with the version, such as images, CSS, or JavaScript.
  --
  -- /See:/ 'newUrlMap' smart constructor.
  data UrlMap = UrlMap
    { -- | Uses API Endpoints to handle requests.
      apiEndpoint :: (Core.Maybe ApiEndpointHandler),
      -- | Action to take when users access resources that require authentication. Defaults to redirect.
      authFailAction :: (Core.Maybe UrlMap_AuthFailAction),
      -- | Level of login required to access this resource. Not supported for Node.js in the App Engine standard environment.
      login :: (Core.Maybe UrlMap_Login),
      -- | 30x code to use when performing redirects for the secure field. Defaults to 302.
      redirectHttpResponseCode :: (Core.Maybe UrlMap_RedirectHttpResponseCode),
      -- | Executes a script to handle the requests that match this URL pattern. Only the auto value is supported for Node.js in the App Engine standard environment, for example \"script\": \"auto\".
      script :: (Core.Maybe ScriptHandler),
      -- | Security (HTTPS) enforcement for this URL.
      securityLevel :: (Core.Maybe UrlMap_SecurityLevel),
      -- | Returns the contents of a file, such as an image, as the response.
      staticFiles :: (Core.Maybe StaticFilesHandler),
      -- | URL prefix. Uses regular expression syntax, which means regexp special characters must be escaped, but should not contain groupings. All URLs that begin with this prefix are handled by this handler, using the portion of the URL after the prefix as part of the file path.
      urlRegex :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'UrlMap' with the minimum fields required to make a request.
  newUrlMap ::
    UrlMap
  newUrlMap =
    UrlMap
      { apiEndpoint = Core.Nothing,
        authFailAction = Core.Nothing,
        login = Core.Nothing,
        redirectHttpResponseCode = Core.Nothing,
        script = Core.Nothing,
        securityLevel = Core.Nothing,
        staticFiles = Core.Nothing,
        urlRegex = Core.Nothing
      }
  
  instance Core.FromJSON UrlMap where
    parseJSON =
      Core.withObject
        "UrlMap"
        ( \o ->
            UrlMap
              Core.<$> (o Core..:? "apiEndpoint")
              Core.<*> (o Core..:? "authFailAction")
              Core.<*> (o Core..:? "login")
              Core.<*> (o Core..:? "redirectHttpResponseCode")
              Core.<*> (o Core..:? "script")
              Core.<*> (o Core..:? "securityLevel")
              Core.<*> (o Core..:? "staticFiles")
              Core.<*> (o Core..:? "urlRegex")
        )
  
  instance Core.ToJSON UrlMap where
    toJSON UrlMap {..} =
      Core.object
        ( Core.catMaybes
            [ ("apiEndpoint" Core..=) Core.<$> apiEndpoint,
              ("authFailAction" Core..=) Core.<$> authFailAction,
              ("login" Core..=) Core.<$> login,
              ("redirectHttpResponseCode" Core..=)
                Core.<$> redirectHttpResponseCode,
              ("script" Core..=) Core.<$> script,
              ("securityLevel" Core..=) Core.<$> securityLevel,
              ("staticFiles" Core..=) Core.<$> staticFiles,
              ("urlRegex" Core..=) Core.<$> urlRegex
            ]
        )
  
  -- | A Version resource is a specific set of source code and configuration files that are deployed into a service.
  --
  -- /See:/ 'newVersion' smart constructor.
  data Version = Version
    { -- | Serving configuration for Google Cloud Endpoints (https:\/\/cloud.google.com\/endpoints).Only returned in GET requests if view=FULL is set.
      apiConfig :: (Core.Maybe ApiConfigHandler),
      -- | Allows App Engine second generation runtimes to access the legacy bundled services.
      appEngineApis :: (Core.Maybe Core.Bool),
      -- | Automatic scaling is based on request rate, response latencies, and other application metrics. Instances are dynamically created and destroyed as needed in order to handle traffic.
      automaticScaling :: (Core.Maybe AutomaticScaling),
      -- | A service with basic scaling will create an instance when the application receives a request. The instance will be turned down when the app becomes idle. Basic scaling is ideal for work that is intermittent or driven by user activity.
      basicScaling :: (Core.Maybe BasicScaling),
      -- | Metadata settings that are supplied to this version to enable beta runtime features.
      betaSettings :: (Core.Maybe Version_BetaSettings),
      -- | Environment variables available to the build environment.Only returned in GET requests if view=FULL is set.
      buildEnvVariables :: (Core.Maybe Version_BuildEnvVariables),
      -- | Time that this version was created.\@OutputOnly
      createTime :: (Core.Maybe Core.DateTime),
      -- | Output only. Email address of the user who created this version.\@OutputOnly
      createdBy :: (Core.Maybe Core.Text),
      -- | Duration that static files should be cached by web proxies and browsers. Only applicable if the corresponding StaticFilesHandler (https:\/\/cloud.google.com\/appengine\/docs\/admin-api\/reference\/rest\/v1\/apps.services.versions#StaticFilesHandler) does not specify its own expiration time.Only returned in GET requests if view=FULL is set.
      defaultExpiration :: (Core.Maybe Core.Duration),
      -- | Code and application artifacts that make up this version.Only returned in GET requests if view=FULL is set.
      deployment :: (Core.Maybe Deployment),
      -- | Output only. Total size in bytes of all the files that are included in this version and currently hosted on the App Engine disk.\@OutputOnly
      diskUsageBytes :: (Core.Maybe Core.Int64),
      -- | Cloud Endpoints configuration.If endpoints/api/service is set, the Cloud Endpoints Extensible Service Proxy will be provided to serve the API implemented by the app.
      endpointsApiService :: (Core.Maybe EndpointsApiService),
      -- | The entrypoint for the application.
      entrypoint :: (Core.Maybe Entrypoint),
      -- | App Engine execution environment for this version.Defaults to standard.
      env :: (Core.Maybe Core.Text),
      -- | Environment variables available to the application.Only returned in GET requests if view=FULL is set.
      envVariables :: (Core.Maybe Version_EnvVariables),
      -- | Custom static error pages. Limited to 10KB per page.Only returned in GET requests if view=FULL is set.
      errorHandlers :: (Core.Maybe [ErrorHandler]),
      -- | Settings for App Engine flexible runtimes.
      flexibleRuntimeSettings :: (Core.Maybe FlexibleRuntimeSettings),
      -- | Additional Google Generated Customer Metadata, this field won\'t be provided by default and can be requested by setting the IncludeExtraData field in GetVersionRequest
      generatedCustomerMetadata :: (Core.Maybe Version_GeneratedCustomerMetadata),
      -- | An ordered list of URL-matching patterns that should be applied to incoming requests. The first matching URL handles the request and other request handlers are not attempted.Only returned in GET requests if view=FULL is set.
      handlers :: (Core.Maybe [UrlMap]),
      -- | Configures health checking for instances. Unhealthy instances are stopped and replaced with new instances. Only applicable in the App Engine flexible environment.
      healthCheck :: (Core.Maybe HealthCheck),
      -- | Relative name of the version within the service. Example: v1. Version names can contain only lowercase letters, numbers, or hyphens. Reserved names: \"default\", \"latest\", and any name with the prefix \"ah-\".
      id :: (Core.Maybe Core.Text),
      -- | Before an application can receive email or XMPP messages, the application must be configured to enable the service.
      inboundServices :: (Core.Maybe [Version_InboundServicesItem]),
      -- | Instance class that is used to run this version. Valid values are: AutomaticScaling: F1, F2, F4, F4/1G ManualScaling or BasicScaling: B1, B2, B4, B8, B4/1GDefaults to F1 for AutomaticScaling and B1 for ManualScaling or BasicScaling.
      instanceClass :: (Core.Maybe Core.Text),
      -- | Configuration for third-party Python runtime libraries that are required by the application.Only returned in GET requests if view=FULL is set.
      libraries :: (Core.Maybe [Library]),
      -- | Configures liveness health checking for instances. Unhealthy instances are stopped and replaced with new instances
      livenessCheck :: (Core.Maybe LivenessCheck),
      -- | A service with manual scaling runs continuously, allowing you to perform complex initialization and rely on the state of its memory over time. Manually scaled versions are sometimes referred to as \"backends\".
      manualScaling :: (Core.Maybe ManualScaling),
      -- | Output only. Full path to the Version resource in the API. Example: apps\/myapp\/services\/default\/versions\/v1.\@OutputOnly
      name :: (Core.Maybe Core.Text),
      -- | Extra network settings. Only applicable in the App Engine flexible environment.
      network :: (Core.Maybe Network),
      -- | Files that match this pattern will not be built into this version. Only applicable for Go runtimes.Only returned in GET requests if view=FULL is set.
      nobuildFilesRegex :: (Core.Maybe Core.Text),
      -- | Configures readiness health checking for instances. Unhealthy instances are not put into the backend traffic rotation.
      readinessCheck :: (Core.Maybe ReadinessCheck),
      -- | Machine resources for this version. Only applicable in the App Engine flexible environment.
      resources :: (Core.Maybe Resources),
      -- | Desired runtime. Example: python27.
      runtime :: (Core.Maybe Core.Text),
      -- | The version of the API in the given runtime environment. Please see the app.yaml reference for valid values at https:\/\/cloud.google.com\/appengine\/docs\/standard\/\/config\/appref
      runtimeApiVersion :: (Core.Maybe Core.Text),
      -- | The channel of the runtime to use. Only available for some runtimes. Defaults to the default channel.
      runtimeChannel :: (Core.Maybe Core.Text),
      -- | The path or name of the app\'s main executable.
      runtimeMainExecutablePath :: (Core.Maybe Core.Text),
      -- | The identity that the deployed version will run as. Admin API will use the App Engine Appspot service account as default if this field is neither provided in app.yaml file nor through CLI flag.
      serviceAccount :: (Core.Maybe Core.Text),
      -- | Current serving status of this version. Only the versions with a SERVING status create instances and can be billed.SERVING/STATUS/UNSPECIFIED is an invalid value. Defaults to SERVING.
      servingStatus :: (Core.Maybe Version_ServingStatus),
      -- | Whether multiple requests can be dispatched to this version at once.
      threadsafe :: (Core.Maybe Core.Bool),
      -- | Output only. Serving URL for this version. Example: \"https:\/\/myversion-dot-myservice-dot-myapp.appspot.com\"\@OutputOnly
      versionUrl :: (Core.Maybe Core.Text),
      -- | Whether to deploy this version in a container on a virtual machine.
      vm :: (Core.Maybe Core.Bool),
      -- | Enables VPC connectivity for standard apps.
      vpcAccessConnector :: (Core.Maybe VpcAccessConnector),
      -- | The Google Compute Engine zones that are supported by this version in the App Engine flexible environment. Deprecated.
      zones :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Version' with the minimum fields required to make a request.
  newVersion ::
    Version
  newVersion =
    Version
      { apiConfig = Core.Nothing,
        appEngineApis = Core.Nothing,
        automaticScaling = Core.Nothing,
        basicScaling = Core.Nothing,
        betaSettings = Core.Nothing,
        buildEnvVariables = Core.Nothing,
        createTime = Core.Nothing,
        createdBy = Core.Nothing,
        defaultExpiration = Core.Nothing,
        deployment = Core.Nothing,
        diskUsageBytes = Core.Nothing,
        endpointsApiService = Core.Nothing,
        entrypoint = Core.Nothing,
        env = Core.Nothing,
        envVariables = Core.Nothing,
        errorHandlers = Core.Nothing,
        flexibleRuntimeSettings = Core.Nothing,
        generatedCustomerMetadata = Core.Nothing,
        handlers = Core.Nothing,
        healthCheck = Core.Nothing,
        id = Core.Nothing,
        inboundServices = Core.Nothing,
        instanceClass = Core.Nothing,
        libraries = Core.Nothing,
        livenessCheck = Core.Nothing,
        manualScaling = Core.Nothing,
        name = Core.Nothing,
        network = Core.Nothing,
        nobuildFilesRegex = Core.Nothing,
        readinessCheck = Core.Nothing,
        resources = Core.Nothing,
        runtime = Core.Nothing,
        runtimeApiVersion = Core.Nothing,
        runtimeChannel = Core.Nothing,
        runtimeMainExecutablePath = Core.Nothing,
        serviceAccount = Core.Nothing,
        servingStatus = Core.Nothing,
        threadsafe = Core.Nothing,
        versionUrl = Core.Nothing,
        vm = Core.Nothing,
        vpcAccessConnector = Core.Nothing,
        zones = Core.Nothing
      }
  
  instance Core.FromJSON Version where
    parseJSON =
      Core.withObject
        "Version"
        ( \o ->
            Version
              Core.<$> (o Core..:? "apiConfig")
              Core.<*> (o Core..:? "appEngineApis")
              Core.<*> (o Core..:? "automaticScaling")
              Core.<*> (o Core..:? "basicScaling")
              Core.<*> (o Core..:? "betaSettings")
              Core.<*> (o Core..:? "buildEnvVariables")
              Core.<*> (o Core..:? "createTime")
              Core.<*> (o Core..:? "createdBy")
              Core.<*> (o Core..:? "defaultExpiration")
              Core.<*> (o Core..:? "deployment")
              Core.<*> (o Core..:? "diskUsageBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "endpointsApiService")
              Core.<*> (o Core..:? "entrypoint")
              Core.<*> (o Core..:? "env")
              Core.<*> (o Core..:? "envVariables")
              Core.<*> (o Core..:? "errorHandlers")
              Core.<*> (o Core..:? "flexibleRuntimeSettings")
              Core.<*> (o Core..:? "generatedCustomerMetadata")
              Core.<*> (o Core..:? "handlers")
              Core.<*> (o Core..:? "healthCheck")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "inboundServices")
              Core.<*> (o Core..:? "instanceClass")
              Core.<*> (o Core..:? "libraries")
              Core.<*> (o Core..:? "livenessCheck")
              Core.<*> (o Core..:? "manualScaling")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "network")
              Core.<*> (o Core..:? "nobuildFilesRegex")
              Core.<*> (o Core..:? "readinessCheck")
              Core.<*> (o Core..:? "resources")
              Core.<*> (o Core..:? "runtime")
              Core.<*> (o Core..:? "runtimeApiVersion")
              Core.<*> (o Core..:? "runtimeChannel")
              Core.<*> (o Core..:? "runtimeMainExecutablePath")
              Core.<*> (o Core..:? "serviceAccount")
              Core.<*> (o Core..:? "servingStatus")
              Core.<*> (o Core..:? "threadsafe")
              Core.<*> (o Core..:? "versionUrl")
              Core.<*> (o Core..:? "vm")
              Core.<*> (o Core..:? "vpcAccessConnector")
              Core.<*> (o Core..:? "zones")
        )
  
  instance Core.ToJSON Version where
    toJSON Version {..} =
      Core.object
        ( Core.catMaybes
            [ ("apiConfig" Core..=) Core.<$> apiConfig,
              ("appEngineApis" Core..=) Core.<$> appEngineApis,
              ("automaticScaling" Core..=) Core.<$> automaticScaling,
              ("basicScaling" Core..=) Core.<$> basicScaling,
              ("betaSettings" Core..=) Core.<$> betaSettings,
              ("buildEnvVariables" Core..=) Core.<$> buildEnvVariables,
              ("createTime" Core..=) Core.<$> createTime,
              ("createdBy" Core..=) Core.<$> createdBy,
              ("defaultExpiration" Core..=) Core.<$> defaultExpiration,
              ("deployment" Core..=) Core.<$> deployment,
              ("diskUsageBytes" Core..=)
                Core.. Core.AsText
                Core.<$> diskUsageBytes,
              ("endpointsApiService" Core..=) Core.<$> endpointsApiService,
              ("entrypoint" Core..=) Core.<$> entrypoint,
              ("env" Core..=) Core.<$> env,
              ("envVariables" Core..=) Core.<$> envVariables,
              ("errorHandlers" Core..=) Core.<$> errorHandlers,
              ("flexibleRuntimeSettings" Core..=)
                Core.<$> flexibleRuntimeSettings,
              ("generatedCustomerMetadata" Core..=)
                Core.<$> generatedCustomerMetadata,
              ("handlers" Core..=) Core.<$> handlers,
              ("healthCheck" Core..=) Core.<$> healthCheck,
              ("id" Core..=) Core.<$> id,
              ("inboundServices" Core..=) Core.<$> inboundServices,
              ("instanceClass" Core..=) Core.<$> instanceClass,
              ("libraries" Core..=) Core.<$> libraries,
              ("livenessCheck" Core..=) Core.<$> livenessCheck,
              ("manualScaling" Core..=) Core.<$> manualScaling,
              ("name" Core..=) Core.<$> name,
              ("network" Core..=) Core.<$> network,
              ("nobuildFilesRegex" Core..=) Core.<$> nobuildFilesRegex,
              ("readinessCheck" Core..=) Core.<$> readinessCheck,
              ("resources" Core..=) Core.<$> resources,
              ("runtime" Core..=) Core.<$> runtime,
              ("runtimeApiVersion" Core..=) Core.<$> runtimeApiVersion,
              ("runtimeChannel" Core..=) Core.<$> runtimeChannel,
              ("runtimeMainExecutablePath" Core..=)
                Core.<$> runtimeMainExecutablePath,
              ("serviceAccount" Core..=) Core.<$> serviceAccount,
              ("servingStatus" Core..=) Core.<$> servingStatus,
              ("threadsafe" Core..=) Core.<$> threadsafe,
              ("versionUrl" Core..=) Core.<$> versionUrl,
              ("vm" Core..=) Core.<$> vm,
              ("vpcAccessConnector" Core..=) Core.<$> vpcAccessConnector,
              ("zones" Core..=) Core.<$> zones
            ]
        )
  
  -- | Metadata settings that are supplied to this version to enable beta runtime features.
  --
  -- /See:/ 'newVersion_BetaSettings' smart constructor.
  newtype Version_BetaSettings = Version_BetaSettings
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Version_BetaSettings' with the minimum fields required to make a request.
  newVersion_BetaSettings ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Version_BetaSettings
  newVersion_BetaSettings additional =
    Version_BetaSettings {additional = additional}
  
  instance Core.FromJSON Version_BetaSettings where
    parseJSON =
      Core.withObject
        "Version_BetaSettings"
        (\o -> Version_BetaSettings Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Version_BetaSettings where
    toJSON Version_BetaSettings {..} = Core.toJSON additional
  
  -- | Environment variables available to the build environment.Only returned in GET requests if view=FULL is set.
  --
  -- /See:/ 'newVersion_BuildEnvVariables' smart constructor.
  newtype Version_BuildEnvVariables = Version_BuildEnvVariables
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Version_BuildEnvVariables' with the minimum fields required to make a request.
  newVersion_BuildEnvVariables ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Version_BuildEnvVariables
  newVersion_BuildEnvVariables additional =
    Version_BuildEnvVariables {additional = additional}
  
  instance Core.FromJSON Version_BuildEnvVariables where
    parseJSON =
      Core.withObject
        "Version_BuildEnvVariables"
        ( \o ->
            Version_BuildEnvVariables Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON Version_BuildEnvVariables where
    toJSON Version_BuildEnvVariables {..} = Core.toJSON additional
  
  -- | Environment variables available to the application.Only returned in GET requests if view=FULL is set.
  --
  -- /See:/ 'newVersion_EnvVariables' smart constructor.
  newtype Version_EnvVariables = Version_EnvVariables
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Version_EnvVariables' with the minimum fields required to make a request.
  newVersion_EnvVariables ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Version_EnvVariables
  newVersion_EnvVariables additional =
    Version_EnvVariables {additional = additional}
  
  instance Core.FromJSON Version_EnvVariables where
    parseJSON =
      Core.withObject
        "Version_EnvVariables"
        (\o -> Version_EnvVariables Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Version_EnvVariables where
    toJSON Version_EnvVariables {..} = Core.toJSON additional
  
  -- | Additional Google Generated Customer Metadata, this field won\'t be provided by default and can be requested by setting the IncludeExtraData field in GetVersionRequest
  --
  -- /See:/ 'newVersion_GeneratedCustomerMetadata' smart constructor.
  newtype Version_GeneratedCustomerMetadata = Version_GeneratedCustomerMetadata
    { -- | 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 'Version_GeneratedCustomerMetadata' with the minimum fields required to make a request.
  newVersion_GeneratedCustomerMetadata ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Version_GeneratedCustomerMetadata
  newVersion_GeneratedCustomerMetadata additional =
    Version_GeneratedCustomerMetadata {additional = additional}
  
  instance Core.FromJSON Version_GeneratedCustomerMetadata where
    parseJSON =
      Core.withObject
        "Version_GeneratedCustomerMetadata"
        ( \o ->
            Version_GeneratedCustomerMetadata
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON Version_GeneratedCustomerMetadata where
    toJSON Version_GeneratedCustomerMetadata {..} =
      Core.toJSON additional
  
  -- | Volumes mounted within the app container. Only applicable in the App Engine flexible environment.
  --
  -- /See:/ 'newVolume' smart constructor.
  data Volume = Volume
    { -- | Unique name for the volume.
      name :: (Core.Maybe Core.Text),
      -- | Volume size in gigabytes.
      sizeGb :: (Core.Maybe Core.Double),
      -- | Underlying volume type, e.g. \'tmpfs\'.
      volumeType :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Volume' with the minimum fields required to make a request.
  newVolume ::
    Volume
  newVolume =
    Volume
      { name = Core.Nothing,
        sizeGb = Core.Nothing,
        volumeType = Core.Nothing
      }
  
  instance Core.FromJSON Volume where
    parseJSON =
      Core.withObject
        "Volume"
        ( \o ->
            Volume
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "sizeGb")
              Core.<*> (o Core..:? "volumeType")
        )
  
  instance Core.ToJSON Volume where
    toJSON Volume {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("sizeGb" Core..=) Core.<$> sizeGb,
              ("volumeType" Core..=) Core.<$> volumeType
            ]
        )
  
  -- | VPC access connector specification.
  --
  -- /See:/ 'newVpcAccessConnector' smart constructor.
  data VpcAccessConnector = VpcAccessConnector
    { -- | The egress setting for the connector, controlling what traffic is diverted through it.
      egressSetting :: (Core.Maybe VpcAccessConnector_EgressSetting),
      -- | Full Serverless VPC Access Connector name e.g. projects\/my-project\/locations\/us-central1\/connectors\/c1.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'VpcAccessConnector' with the minimum fields required to make a request.
  newVpcAccessConnector ::
    VpcAccessConnector
  newVpcAccessConnector =
    VpcAccessConnector
      { egressSetting = Core.Nothing,
        name = Core.Nothing
      }
  
  instance Core.FromJSON VpcAccessConnector where
    parseJSON =
      Core.withObject
        "VpcAccessConnector"
        ( \o ->
            VpcAccessConnector
              Core.<$> (o Core..:? "egressSetting")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON VpcAccessConnector where
    toJSON VpcAccessConnector {..} =
      Core.object
        ( Core.catMaybes
            [ ("egressSetting" Core..=) Core.<$> egressSetting,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | The zip file information for a zip deployment.
  --
  -- /See:/ 'newZipInfo' smart constructor.
  data ZipInfo = ZipInfo
    { -- | An estimate of the number of files in a zip for a zip deployment. If set, must be greater than or equal to the actual number of files. Used for optimizing performance; if not provided, deployment may be slow.
      filesCount :: (Core.Maybe Core.Int32),
      -- | URL of the zip file to deploy from. Must be a URL to a resource in Google Cloud Storage in the form \'http(s):\/\/storage.googleapis.com\/\/\'.
      sourceUrl :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ZipInfo' with the minimum fields required to make a request.
  newZipInfo ::
    ZipInfo
  newZipInfo =
    ZipInfo {filesCount = Core.Nothing, sourceUrl = Core.Nothing}
  
  instance Core.FromJSON ZipInfo where
    parseJSON =
      Core.withObject
        "ZipInfo"
        ( \o ->
            ZipInfo
              Core.<$> (o Core..:? "filesCount")
              Core.<*> (o Core..:? "sourceUrl")
        )
  
  instance Core.ToJSON ZipInfo where
    toJSON ZipInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("filesCount" Core..=) Core.<$> filesCount,
              ("sourceUrl" Core..=) Core.<$> sourceUrl
            ]
        )
  