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.Dataflow.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.Dataflow.Internal.Product
    ( -- * ApproximateProgress
      ApproximateProgress (..),
      newApproximateProgress,
  
      -- * ApproximateReportedProgress
      ApproximateReportedProgress (..),
      newApproximateReportedProgress,
  
      -- * ApproximateSplitRequest
      ApproximateSplitRequest (..),
      newApproximateSplitRequest,
  
      -- * AutoscalingEvent
      AutoscalingEvent (..),
      newAutoscalingEvent,
  
      -- * AutoscalingSettings
      AutoscalingSettings (..),
      newAutoscalingSettings,
  
      -- * Base2Exponent
      Base2Exponent (..),
      newBase2Exponent,
  
      -- * BigQueryIODetails
      BigQueryIODetails (..),
      newBigQueryIODetails,
  
      -- * BigTableIODetails
      BigTableIODetails (..),
      newBigTableIODetails,
  
      -- * BoundedTrie
      BoundedTrie (..),
      newBoundedTrie,
  
      -- * BoundedTrieNode
      BoundedTrieNode (..),
      newBoundedTrieNode,
  
      -- * BoundedTrieNode_Children
      BoundedTrieNode_Children (..),
      newBoundedTrieNode_Children,
  
      -- * BucketOptions
      BucketOptions (..),
      newBucketOptions,
  
      -- * CPUTime
      CPUTime (..),
      newCPUTime,
  
      -- * ComponentSource
      ComponentSource (..),
      newComponentSource,
  
      -- * ComponentTransform
      ComponentTransform (..),
      newComponentTransform,
  
      -- * ComputationTopology
      ComputationTopology (..),
      newComputationTopology,
  
      -- * ConcatPosition
      ConcatPosition (..),
      newConcatPosition,
  
      -- * ContainerSpec
      ContainerSpec (..),
      newContainerSpec,
  
      -- * CounterMetadata
      CounterMetadata (..),
      newCounterMetadata,
  
      -- * CounterStructuredName
      CounterStructuredName (..),
      newCounterStructuredName,
  
      -- * CounterStructuredNameAndMetadata
      CounterStructuredNameAndMetadata (..),
      newCounterStructuredNameAndMetadata,
  
      -- * CounterUpdate
      CounterUpdate (..),
      newCounterUpdate,
  
      -- * CreateJobFromTemplateRequest
      CreateJobFromTemplateRequest (..),
      newCreateJobFromTemplateRequest,
  
      -- * CreateJobFromTemplateRequest_Parameters
      CreateJobFromTemplateRequest_Parameters (..),
      newCreateJobFromTemplateRequest_Parameters,
  
      -- * CustomSourceLocation
      CustomSourceLocation (..),
      newCustomSourceLocation,
  
      -- * DataDiskAssignment
      DataDiskAssignment (..),
      newDataDiskAssignment,
  
      -- * DataSamplingConfig
      DataSamplingConfig (..),
      newDataSamplingConfig,
  
      -- * DataSamplingReport
      DataSamplingReport (..),
      newDataSamplingReport,
  
      -- * DataflowGaugeValue
      DataflowGaugeValue (..),
      newDataflowGaugeValue,
  
      -- * DataflowHistogramValue
      DataflowHistogramValue (..),
      newDataflowHistogramValue,
  
      -- * DatastoreIODetails
      DatastoreIODetails (..),
      newDatastoreIODetails,
  
      -- * DebugOptions
      DebugOptions (..),
      newDebugOptions,
  
      -- * DeleteSnapshotResponse
      DeleteSnapshotResponse (..),
      newDeleteSnapshotResponse,
  
      -- * DerivedSource
      DerivedSource (..),
      newDerivedSource,
  
      -- * Disk
      Disk (..),
      newDisk,
  
      -- * DisplayData
      DisplayData (..),
      newDisplayData,
  
      -- * DistributionUpdate
      DistributionUpdate (..),
      newDistributionUpdate,
  
      -- * DynamicSourceSplit
      DynamicSourceSplit (..),
      newDynamicSourceSplit,
  
      -- * Environment
      Environment (..),
      newEnvironment,
  
      -- * Environment_InternalExperiments
      Environment_InternalExperiments (..),
      newEnvironment_InternalExperiments,
  
      -- * Environment_SdkPipelineOptions
      Environment_SdkPipelineOptions (..),
      newEnvironment_SdkPipelineOptions,
  
      -- * Environment_UserAgent
      Environment_UserAgent (..),
      newEnvironment_UserAgent,
  
      -- * Environment_Version
      Environment_Version (..),
      newEnvironment_Version,
  
      -- * ExecutionStageState
      ExecutionStageState (..),
      newExecutionStageState,
  
      -- * ExecutionStageSummary
      ExecutionStageSummary (..),
      newExecutionStageSummary,
  
      -- * FailedLocation
      FailedLocation (..),
      newFailedLocation,
  
      -- * FileIODetails
      FileIODetails (..),
      newFileIODetails,
  
      -- * FlattenInstruction
      FlattenInstruction (..),
      newFlattenInstruction,
  
      -- * FlexTemplateRuntimeEnvironment
      FlexTemplateRuntimeEnvironment (..),
      newFlexTemplateRuntimeEnvironment,
  
      -- * FlexTemplateRuntimeEnvironment_AdditionalUserLabels
      FlexTemplateRuntimeEnvironment_AdditionalUserLabels (..),
      newFlexTemplateRuntimeEnvironment_AdditionalUserLabels,
  
      -- * FloatingPointList
      FloatingPointList (..),
      newFloatingPointList,
  
      -- * FloatingPointMean
      FloatingPointMean (..),
      newFloatingPointMean,
  
      -- * GPUUsage
      GPUUsage (..),
      newGPUUsage,
  
      -- * GPUUtilization
      GPUUtilization (..),
      newGPUUtilization,
  
      -- * GetDebugConfigRequest
      GetDebugConfigRequest (..),
      newGetDebugConfigRequest,
  
      -- * GetDebugConfigResponse
      GetDebugConfigResponse (..),
      newGetDebugConfigResponse,
  
      -- * GetTemplateResponse
      GetTemplateResponse (..),
      newGetTemplateResponse,
  
      -- * Histogram
      Histogram (..),
      newHistogram,
  
      -- * HotKeyDebuggingInfo
      HotKeyDebuggingInfo (..),
      newHotKeyDebuggingInfo,
  
      -- * HotKeyDebuggingInfo_DetectedHotKeys
      HotKeyDebuggingInfo_DetectedHotKeys (..),
      newHotKeyDebuggingInfo_DetectedHotKeys,
  
      -- * HotKeyDetection
      HotKeyDetection (..),
      newHotKeyDetection,
  
      -- * HotKeyInfo
      HotKeyInfo (..),
      newHotKeyInfo,
  
      -- * InstructionInput
      InstructionInput (..),
      newInstructionInput,
  
      -- * InstructionOutput
      InstructionOutput (..),
      newInstructionOutput,
  
      -- * InstructionOutput_Codec
      InstructionOutput_Codec (..),
      newInstructionOutput_Codec,
  
      -- * IntegerGauge
      IntegerGauge (..),
      newIntegerGauge,
  
      -- * IntegerList
      IntegerList (..),
      newIntegerList,
  
      -- * IntegerMean
      IntegerMean (..),
      newIntegerMean,
  
      -- * Job
      Job (..),
      newJob,
  
      -- * Job_Labels
      Job_Labels (..),
      newJob_Labels,
  
      -- * Job_TransformNameMapping
      Job_TransformNameMapping (..),
      newJob_TransformNameMapping,
  
      -- * JobExecutionDetails
      JobExecutionDetails (..),
      newJobExecutionDetails,
  
      -- * JobExecutionInfo
      JobExecutionInfo (..),
      newJobExecutionInfo,
  
      -- * JobExecutionInfo_Stages
      JobExecutionInfo_Stages (..),
      newJobExecutionInfo_Stages,
  
      -- * JobExecutionStageInfo
      JobExecutionStageInfo (..),
      newJobExecutionStageInfo,
  
      -- * JobMessage
      JobMessage (..),
      newJobMessage,
  
      -- * JobMetadata
      JobMetadata (..),
      newJobMetadata,
  
      -- * JobMetadata_UserDisplayProperties
      JobMetadata_UserDisplayProperties (..),
      newJobMetadata_UserDisplayProperties,
  
      -- * JobMetrics
      JobMetrics (..),
      newJobMetrics,
  
      -- * KeyRangeDataDiskAssignment
      KeyRangeDataDiskAssignment (..),
      newKeyRangeDataDiskAssignment,
  
      -- * KeyRangeLocation
      KeyRangeLocation (..),
      newKeyRangeLocation,
  
      -- * LaunchFlexTemplateParameter
      LaunchFlexTemplateParameter (..),
      newLaunchFlexTemplateParameter,
  
      -- * LaunchFlexTemplateParameter_LaunchOptions
      LaunchFlexTemplateParameter_LaunchOptions (..),
      newLaunchFlexTemplateParameter_LaunchOptions,
  
      -- * LaunchFlexTemplateParameter_Parameters
      LaunchFlexTemplateParameter_Parameters (..),
      newLaunchFlexTemplateParameter_Parameters,
  
      -- * LaunchFlexTemplateParameter_TransformNameMappings
      LaunchFlexTemplateParameter_TransformNameMappings (..),
      newLaunchFlexTemplateParameter_TransformNameMappings,
  
      -- * LaunchFlexTemplateRequest
      LaunchFlexTemplateRequest (..),
      newLaunchFlexTemplateRequest,
  
      -- * LaunchFlexTemplateResponse
      LaunchFlexTemplateResponse (..),
      newLaunchFlexTemplateResponse,
  
      -- * LaunchTemplateParameters
      LaunchTemplateParameters (..),
      newLaunchTemplateParameters,
  
      -- * LaunchTemplateParameters_Parameters
      LaunchTemplateParameters_Parameters (..),
      newLaunchTemplateParameters_Parameters,
  
      -- * LaunchTemplateParameters_TransformNameMapping
      LaunchTemplateParameters_TransformNameMapping (..),
      newLaunchTemplateParameters_TransformNameMapping,
  
      -- * LaunchTemplateResponse
      LaunchTemplateResponse (..),
      newLaunchTemplateResponse,
  
      -- * LeaseWorkItemRequest
      LeaseWorkItemRequest (..),
      newLeaseWorkItemRequest,
  
      -- * LeaseWorkItemRequest_UnifiedWorkerRequest
      LeaseWorkItemRequest_UnifiedWorkerRequest (..),
      newLeaseWorkItemRequest_UnifiedWorkerRequest,
  
      -- * LeaseWorkItemResponse
      LeaseWorkItemResponse (..),
      newLeaseWorkItemResponse,
  
      -- * LeaseWorkItemResponse_UnifiedWorkerResponse
      LeaseWorkItemResponse_UnifiedWorkerResponse (..),
      newLeaseWorkItemResponse_UnifiedWorkerResponse,
  
      -- * Linear
      Linear (..),
      newLinear,
  
      -- * ListJobMessagesResponse
      ListJobMessagesResponse (..),
      newListJobMessagesResponse,
  
      -- * ListJobsResponse
      ListJobsResponse (..),
      newListJobsResponse,
  
      -- * ListSnapshotsResponse
      ListSnapshotsResponse (..),
      newListSnapshotsResponse,
  
      -- * MapTask
      MapTask (..),
      newMapTask,
  
      -- * MemInfo
      MemInfo (..),
      newMemInfo,
  
      -- * MetricShortId
      MetricShortId (..),
      newMetricShortId,
  
      -- * MetricStructuredName
      MetricStructuredName (..),
      newMetricStructuredName,
  
      -- * MetricStructuredName_Context
      MetricStructuredName_Context (..),
      newMetricStructuredName_Context,
  
      -- * MetricUpdate
      MetricUpdate (..),
      newMetricUpdate,
  
      -- * MetricValue
      MetricValue (..),
      newMetricValue,
  
      -- * MetricValue_MetricLabels
      MetricValue_MetricLabels (..),
      newMetricValue_MetricLabels,
  
      -- * MountedDataDisk
      MountedDataDisk (..),
      newMountedDataDisk,
  
      -- * MultiOutputInfo
      MultiOutputInfo (..),
      newMultiOutputInfo,
  
      -- * NameAndKind
      NameAndKind (..),
      newNameAndKind,
  
      -- * OutlierStats
      OutlierStats (..),
      newOutlierStats,
  
      -- * Package
      Package (..),
      newPackage,
  
      -- * ParDoInstruction
      ParDoInstruction (..),
      newParDoInstruction,
  
      -- * ParDoInstruction_UserFn
      ParDoInstruction_UserFn (..),
      newParDoInstruction_UserFn,
  
      -- * ParallelInstruction
      ParallelInstruction (..),
      newParallelInstruction,
  
      -- * Parameter
      Parameter (..),
      newParameter,
  
      -- * ParameterMetadata
      ParameterMetadata (..),
      newParameterMetadata,
  
      -- * ParameterMetadata_CustomMetadata
      ParameterMetadata_CustomMetadata (..),
      newParameterMetadata_CustomMetadata,
  
      -- * ParameterMetadataEnumOption
      ParameterMetadataEnumOption (..),
      newParameterMetadataEnumOption,
  
      -- * PartialGroupByKeyInstruction
      PartialGroupByKeyInstruction (..),
      newPartialGroupByKeyInstruction,
  
      -- * PartialGroupByKeyInstruction_InputElementCodec
      PartialGroupByKeyInstruction_InputElementCodec (..),
      newPartialGroupByKeyInstruction_InputElementCodec,
  
      -- * PartialGroupByKeyInstruction_ValueCombiningFn
      PartialGroupByKeyInstruction_ValueCombiningFn (..),
      newPartialGroupByKeyInstruction_ValueCombiningFn,
  
      -- * PerStepNamespaceMetrics
      PerStepNamespaceMetrics (..),
      newPerStepNamespaceMetrics,
  
      -- * PerWorkerMetrics
      PerWorkerMetrics (..),
      newPerWorkerMetrics,
  
      -- * PipelineDescription
      PipelineDescription (..),
      newPipelineDescription,
  
      -- * Point
      Point (..),
      newPoint,
  
      -- * Position
      Position (..),
      newPosition,
  
      -- * ProgressTimeseries
      ProgressTimeseries (..),
      newProgressTimeseries,
  
      -- * PubSubIODetails
      PubSubIODetails (..),
      newPubSubIODetails,
  
      -- * PubsubLocation
      PubsubLocation (..),
      newPubsubLocation,
  
      -- * PubsubSnapshotMetadata
      PubsubSnapshotMetadata (..),
      newPubsubSnapshotMetadata,
  
      -- * ReadInstruction
      ReadInstruction (..),
      newReadInstruction,
  
      -- * ReportWorkItemStatusRequest
      ReportWorkItemStatusRequest (..),
      newReportWorkItemStatusRequest,
  
      -- * ReportWorkItemStatusRequest_UnifiedWorkerRequest
      ReportWorkItemStatusRequest_UnifiedWorkerRequest (..),
      newReportWorkItemStatusRequest_UnifiedWorkerRequest,
  
      -- * ReportWorkItemStatusResponse
      ReportWorkItemStatusResponse (..),
      newReportWorkItemStatusResponse,
  
      -- * ReportWorkItemStatusResponse_UnifiedWorkerResponse
      ReportWorkItemStatusResponse_UnifiedWorkerResponse (..),
      newReportWorkItemStatusResponse_UnifiedWorkerResponse,
  
      -- * ReportedParallelism
      ReportedParallelism (..),
      newReportedParallelism,
  
      -- * ResourceUtilizationReport
      ResourceUtilizationReport (..),
      newResourceUtilizationReport,
  
      -- * ResourceUtilizationReport_Containers
      ResourceUtilizationReport_Containers (..),
      newResourceUtilizationReport_Containers,
  
      -- * ResourceUtilizationReportResponse
      ResourceUtilizationReportResponse (..),
      newResourceUtilizationReportResponse,
  
      -- * RuntimeEnvironment
      RuntimeEnvironment (..),
      newRuntimeEnvironment,
  
      -- * RuntimeEnvironment_AdditionalUserLabels
      RuntimeEnvironment_AdditionalUserLabels (..),
      newRuntimeEnvironment_AdditionalUserLabels,
  
      -- * RuntimeMetadata
      RuntimeMetadata (..),
      newRuntimeMetadata,
  
      -- * RuntimeUpdatableParams
      RuntimeUpdatableParams (..),
      newRuntimeUpdatableParams,
  
      -- * SDKInfo
      SDKInfo (..),
      newSDKInfo,
  
      -- * SdkBug
      SdkBug (..),
      newSdkBug,
  
      -- * SdkHarnessContainerImage
      SdkHarnessContainerImage (..),
      newSdkHarnessContainerImage,
  
      -- * SdkVersion
      SdkVersion (..),
      newSdkVersion,
  
      -- * SendDebugCaptureRequest
      SendDebugCaptureRequest (..),
      newSendDebugCaptureRequest,
  
      -- * SendDebugCaptureResponse
      SendDebugCaptureResponse (..),
      newSendDebugCaptureResponse,
  
      -- * SendWorkerMessagesRequest
      SendWorkerMessagesRequest (..),
      newSendWorkerMessagesRequest,
  
      -- * SendWorkerMessagesResponse
      SendWorkerMessagesResponse (..),
      newSendWorkerMessagesResponse,
  
      -- * SeqMapTask
      SeqMapTask (..),
      newSeqMapTask,
  
      -- * SeqMapTask_UserFn
      SeqMapTask_UserFn (..),
      newSeqMapTask_UserFn,
  
      -- * SeqMapTaskOutputInfo
      SeqMapTaskOutputInfo (..),
      newSeqMapTaskOutputInfo,
  
      -- * ServiceResources
      ServiceResources (..),
      newServiceResources,
  
      -- * ShellTask
      ShellTask (..),
      newShellTask,
  
      -- * SideInputInfo
      SideInputInfo (..),
      newSideInputInfo,
  
      -- * SideInputInfo_Kind
      SideInputInfo_Kind (..),
      newSideInputInfo_Kind,
  
      -- * Sink
      Sink (..),
      newSink,
  
      -- * Sink_Codec
      Sink_Codec (..),
      newSink_Codec,
  
      -- * Sink_Spec
      Sink_Spec (..),
      newSink_Spec,
  
      -- * Snapshot
      Snapshot (..),
      newSnapshot,
  
      -- * SnapshotJobRequest
      SnapshotJobRequest (..),
      newSnapshotJobRequest,
  
      -- * Source
      Source (..),
      newSource,
  
      -- * Source_BaseSpecsItem
      Source_BaseSpecsItem (..),
      newSource_BaseSpecsItem,
  
      -- * Source_Codec
      Source_Codec (..),
      newSource_Codec,
  
      -- * Source_Spec
      Source_Spec (..),
      newSource_Spec,
  
      -- * SourceFork
      SourceFork (..),
      newSourceFork,
  
      -- * SourceGetMetadataRequest
      SourceGetMetadataRequest (..),
      newSourceGetMetadataRequest,
  
      -- * SourceGetMetadataResponse
      SourceGetMetadataResponse (..),
      newSourceGetMetadataResponse,
  
      -- * SourceMetadata
      SourceMetadata (..),
      newSourceMetadata,
  
      -- * SourceOperationRequest
      SourceOperationRequest (..),
      newSourceOperationRequest,
  
      -- * SourceOperationResponse
      SourceOperationResponse (..),
      newSourceOperationResponse,
  
      -- * SourceSplitOptions
      SourceSplitOptions (..),
      newSourceSplitOptions,
  
      -- * SourceSplitRequest
      SourceSplitRequest (..),
      newSourceSplitRequest,
  
      -- * SourceSplitResponse
      SourceSplitResponse (..),
      newSourceSplitResponse,
  
      -- * SourceSplitShard
      SourceSplitShard (..),
      newSourceSplitShard,
  
      -- * SpannerIODetails
      SpannerIODetails (..),
      newSpannerIODetails,
  
      -- * SplitInt64
      SplitInt64 (..),
      newSplitInt64,
  
      -- * StageExecutionDetails
      StageExecutionDetails (..),
      newStageExecutionDetails,
  
      -- * StageSource
      StageSource (..),
      newStageSource,
  
      -- * StageSummary
      StageSummary (..),
      newStageSummary,
  
      -- * StateFamilyConfig
      StateFamilyConfig (..),
      newStateFamilyConfig,
  
      -- * Status
      Status (..),
      newStatus,
  
      -- * Status_DetailsItem
      Status_DetailsItem (..),
      newStatus_DetailsItem,
  
      -- * Step
      Step (..),
      newStep,
  
      -- * Step_Properties
      Step_Properties (..),
      newStep_Properties,
  
      -- * Straggler
      Straggler (..),
      newStraggler,
  
      -- * StragglerDebuggingInfo
      StragglerDebuggingInfo (..),
      newStragglerDebuggingInfo,
  
      -- * StragglerInfo
      StragglerInfo (..),
      newStragglerInfo,
  
      -- * StragglerInfo_Causes
      StragglerInfo_Causes (..),
      newStragglerInfo_Causes,
  
      -- * StragglerSummary
      StragglerSummary (..),
      newStragglerSummary,
  
      -- * StragglerSummary_StragglerCauseCount
      StragglerSummary_StragglerCauseCount (..),
      newStragglerSummary_StragglerCauseCount,
  
      -- * StreamLocation
      StreamLocation (..),
      newStreamLocation,
  
      -- * StreamingApplianceSnapshotConfig
      StreamingApplianceSnapshotConfig (..),
      newStreamingApplianceSnapshotConfig,
  
      -- * StreamingComputationConfig
      StreamingComputationConfig (..),
      newStreamingComputationConfig,
  
      -- * StreamingComputationConfig_TransformUserNameToStateFamily
      StreamingComputationConfig_TransformUserNameToStateFamily (..),
      newStreamingComputationConfig_TransformUserNameToStateFamily,
  
      -- * StreamingComputationRanges
      StreamingComputationRanges (..),
      newStreamingComputationRanges,
  
      -- * StreamingComputationTask
      StreamingComputationTask (..),
      newStreamingComputationTask,
  
      -- * StreamingConfigTask
      StreamingConfigTask (..),
      newStreamingConfigTask,
  
      -- * StreamingConfigTask_UserStepToStateFamilyNameMap
      StreamingConfigTask_UserStepToStateFamilyNameMap (..),
      newStreamingConfigTask_UserStepToStateFamilyNameMap,
  
      -- * StreamingOperationalLimits
      StreamingOperationalLimits (..),
      newStreamingOperationalLimits,
  
      -- * StreamingScalingReport
      StreamingScalingReport (..),
      newStreamingScalingReport,
  
      -- * StreamingScalingReportResponse
      StreamingScalingReportResponse (..),
      newStreamingScalingReportResponse,
  
      -- * StreamingSetupTask
      StreamingSetupTask (..),
      newStreamingSetupTask,
  
      -- * StreamingSideInputLocation
      StreamingSideInputLocation (..),
      newStreamingSideInputLocation,
  
      -- * StreamingStageLocation
      StreamingStageLocation (..),
      newStreamingStageLocation,
  
      -- * StreamingStragglerInfo
      StreamingStragglerInfo (..),
      newStreamingStragglerInfo,
  
      -- * StringList
      StringList (..),
      newStringList,
  
      -- * StructuredMessage
      StructuredMessage (..),
      newStructuredMessage,
  
      -- * TaskRunnerSettings
      TaskRunnerSettings (..),
      newTaskRunnerSettings,
  
      -- * TemplateMetadata
      TemplateMetadata (..),
      newTemplateMetadata,
  
      -- * TopologyConfig
      TopologyConfig (..),
      newTopologyConfig,
  
      -- * TopologyConfig_UserStageToComputationNameMap
      TopologyConfig_UserStageToComputationNameMap (..),
      newTopologyConfig_UserStageToComputationNameMap,
  
      -- * TransformSummary
      TransformSummary (..),
      newTransformSummary,
  
      -- * WorkItem
      WorkItem (..),
      newWorkItem,
  
      -- * WorkItemDetails
      WorkItemDetails (..),
      newWorkItemDetails,
  
      -- * WorkItemServiceState
      WorkItemServiceState (..),
      newWorkItemServiceState,
  
      -- * WorkItemServiceState_HarnessData
      WorkItemServiceState_HarnessData (..),
      newWorkItemServiceState_HarnessData,
  
      -- * WorkItemStatus
      WorkItemStatus (..),
      newWorkItemStatus,
  
      -- * WorkerDetails
      WorkerDetails (..),
      newWorkerDetails,
  
      -- * WorkerHealthReport
      WorkerHealthReport (..),
      newWorkerHealthReport,
  
      -- * WorkerHealthReport_PodsItem
      WorkerHealthReport_PodsItem (..),
      newWorkerHealthReport_PodsItem,
  
      -- * WorkerHealthReportResponse
      WorkerHealthReportResponse (..),
      newWorkerHealthReportResponse,
  
      -- * WorkerLifecycleEvent
      WorkerLifecycleEvent (..),
      newWorkerLifecycleEvent,
  
      -- * WorkerLifecycleEvent_Metadata
      WorkerLifecycleEvent_Metadata (..),
      newWorkerLifecycleEvent_Metadata,
  
      -- * WorkerMessage
      WorkerMessage (..),
      newWorkerMessage,
  
      -- * WorkerMessage_Labels
      WorkerMessage_Labels (..),
      newWorkerMessage_Labels,
  
      -- * WorkerMessageCode
      WorkerMessageCode (..),
      newWorkerMessageCode,
  
      -- * WorkerMessageCode_Parameters
      WorkerMessageCode_Parameters (..),
      newWorkerMessageCode_Parameters,
  
      -- * WorkerMessageResponse
      WorkerMessageResponse (..),
      newWorkerMessageResponse,
  
      -- * WorkerPool
      WorkerPool (..),
      newWorkerPool,
  
      -- * WorkerPool_Metadata
      WorkerPool_Metadata (..),
      newWorkerPool_Metadata,
  
      -- * WorkerPool_PoolArgs
      WorkerPool_PoolArgs (..),
      newWorkerPool_PoolArgs,
  
      -- * WorkerSettings
      WorkerSettings (..),
      newWorkerSettings,
  
      -- * WorkerShutdownNotice
      WorkerShutdownNotice (..),
      newWorkerShutdownNotice,
  
      -- * WorkerShutdownNoticeResponse
      WorkerShutdownNoticeResponse (..),
      newWorkerShutdownNoticeResponse,
  
      -- * WorkerThreadScalingReport
      WorkerThreadScalingReport (..),
      newWorkerThreadScalingReport,
  
      -- * WorkerThreadScalingReportResponse
      WorkerThreadScalingReportResponse (..),
      newWorkerThreadScalingReportResponse,
  
      -- * WriteInstruction
      WriteInstruction (..),
      newWriteInstruction,
    )
  where
  
  import Gogol.Dataflow.Internal.Sum
  import Gogol.Prelude qualified as Core
  
  -- | Obsolete in favor of ApproximateReportedProgress and ApproximateSplitRequest.
  --
  -- /See:/ 'newApproximateProgress' smart constructor.
  data ApproximateProgress = ApproximateProgress
    { -- | Obsolete.
      percentComplete :: (Core.Maybe Core.Double),
      -- | Obsolete.
      position :: (Core.Maybe Position),
      -- | Obsolete.
      remainingTime :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApproximateProgress' with the minimum fields required to make a request.
  newApproximateProgress ::
    ApproximateProgress
  newApproximateProgress =
    ApproximateProgress
      { percentComplete = Core.Nothing,
        position = Core.Nothing,
        remainingTime = Core.Nothing
      }
  
  instance Core.FromJSON ApproximateProgress where
    parseJSON =
      Core.withObject
        "ApproximateProgress"
        ( \o ->
            ApproximateProgress
              Core.<$> (o Core..:? "percentComplete")
              Core.<*> (o Core..:? "position")
              Core.<*> (o Core..:? "remainingTime")
        )
  
  instance Core.ToJSON ApproximateProgress where
    toJSON ApproximateProgress {..} =
      Core.object
        ( Core.catMaybes
            [ ("percentComplete" Core..=) Core.<$> percentComplete,
              ("position" Core..=) Core.<$> position,
              ("remainingTime" Core..=) Core.<$> remainingTime
            ]
        )
  
  -- | A progress measurement of a WorkItem by a worker.
  --
  -- /See:/ 'newApproximateReportedProgress' smart constructor.
  data ApproximateReportedProgress = ApproximateReportedProgress
    { -- | Total amount of parallelism in the portion of input of this task that has already been consumed and is no longer active. In the first two examples above (see remaining/parallelism), the value should be 29 or 2 respectively. The sum of remaining/parallelism and consumed_parallelism should equal the total amount of parallelism in this work item. If specified, must be finite.
      consumedParallelism :: (Core.Maybe ReportedParallelism),
      -- | Completion as fraction of the input consumed, from 0.0 (beginning, nothing consumed), to 1.0 (end of the input, entire input consumed).
      fractionConsumed :: (Core.Maybe Core.Double),
      -- | A Position within the work to represent a progress.
      position :: (Core.Maybe Position),
      -- | Total amount of parallelism in the input of this task that remains, (i.e. can be delegated to this task and any new tasks via dynamic splitting). Always at least 1 for non-finished work items and 0 for finished. \"Amount of parallelism\" refers to how many non-empty parts of the input can be read in parallel. This does not necessarily equal number of records. An input that can be read in parallel down to the individual records is called \"perfectly splittable\". An example of non-perfectly parallelizable input is a block-compressed file format where a block of records has to be read as a whole, but different blocks can be read in parallel. Examples: * If we are processing record #30 (starting at 1) out of 50 in a perfectly splittable 50-record input, this value should be 21 (20 remaining + 1 current). * If we are reading through block 3 in a block-compressed file consisting of 5 blocks, this value should be 3 (since blocks 4 and 5 can be processed in parallel by new tasks via dynamic splitting and the current
      -- task remains processing block 3). * If we are reading through the last block in a block-compressed file, or reading or processing the last record in a perfectly splittable input, this value should be 1, because apart from the current task, no additional remainder can be split off.
      remainingParallelism :: (Core.Maybe ReportedParallelism)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApproximateReportedProgress' with the minimum fields required to make a request.
  newApproximateReportedProgress ::
    ApproximateReportedProgress
  newApproximateReportedProgress =
    ApproximateReportedProgress
      { consumedParallelism = Core.Nothing,
        fractionConsumed = Core.Nothing,
        position = Core.Nothing,
        remainingParallelism = Core.Nothing
      }
  
  instance Core.FromJSON ApproximateReportedProgress where
    parseJSON =
      Core.withObject
        "ApproximateReportedProgress"
        ( \o ->
            ApproximateReportedProgress
              Core.<$> (o Core..:? "consumedParallelism")
              Core.<*> (o Core..:? "fractionConsumed")
              Core.<*> (o Core..:? "position")
              Core.<*> (o Core..:? "remainingParallelism")
        )
  
  instance Core.ToJSON ApproximateReportedProgress where
    toJSON ApproximateReportedProgress {..} =
      Core.object
        ( Core.catMaybes
            [ ("consumedParallelism" Core..=) Core.<$> consumedParallelism,
              ("fractionConsumed" Core..=) Core.<$> fractionConsumed,
              ("position" Core..=) Core.<$> position,
              ("remainingParallelism" Core..=) Core.<$> remainingParallelism
            ]
        )
  
  -- | A suggestion by the service to the worker to dynamically split the WorkItem.
  --
  -- /See:/ 'newApproximateSplitRequest' smart constructor.
  data ApproximateSplitRequest = ApproximateSplitRequest
    { -- | A fraction at which to split the work item, from 0.0 (beginning of the input) to 1.0 (end of the input).
      fractionConsumed :: (Core.Maybe Core.Double),
      -- | The fraction of the remainder of work to split the work item at, from 0.0 (split at the current position) to 1.0 (end of the input).
      fractionOfRemainder :: (Core.Maybe Core.Double),
      -- | A Position at which to split the work item.
      position :: (Core.Maybe Position)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ApproximateSplitRequest' with the minimum fields required to make a request.
  newApproximateSplitRequest ::
    ApproximateSplitRequest
  newApproximateSplitRequest =
    ApproximateSplitRequest
      { fractionConsumed = Core.Nothing,
        fractionOfRemainder = Core.Nothing,
        position = Core.Nothing
      }
  
  instance Core.FromJSON ApproximateSplitRequest where
    parseJSON =
      Core.withObject
        "ApproximateSplitRequest"
        ( \o ->
            ApproximateSplitRequest
              Core.<$> (o Core..:? "fractionConsumed")
              Core.<*> (o Core..:? "fractionOfRemainder")
              Core.<*> (o Core..:? "position")
        )
  
  instance Core.ToJSON ApproximateSplitRequest where
    toJSON ApproximateSplitRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("fractionConsumed" Core..=) Core.<$> fractionConsumed,
              ("fractionOfRemainder" Core..=) Core.<$> fractionOfRemainder,
              ("position" Core..=) Core.<$> position
            ]
        )
  
  -- | A structured message reporting an autoscaling decision made by the Dataflow service.
  --
  -- /See:/ 'newAutoscalingEvent' smart constructor.
  data AutoscalingEvent = AutoscalingEvent
    { -- | The current number of workers the job has.
      currentNumWorkers :: (Core.Maybe Core.Int64),
      -- | A message describing why the system decided to adjust the current number of workers, why it failed, or why the system decided to not make any changes to the number of workers.
      description :: (Core.Maybe StructuredMessage),
      -- | The type of autoscaling event to report.
      eventType :: (Core.Maybe AutoscalingEvent_EventType),
      -- | The target number of workers the worker pool wants to resize to use.
      targetNumWorkers :: (Core.Maybe Core.Int64),
      -- | The time this event was emitted to indicate a new target or current num_workers value.
      time :: (Core.Maybe Core.DateTime),
      -- | A short and friendly name for the worker pool this event refers to.
      workerPool :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AutoscalingEvent' with the minimum fields required to make a request.
  newAutoscalingEvent ::
    AutoscalingEvent
  newAutoscalingEvent =
    AutoscalingEvent
      { currentNumWorkers = Core.Nothing,
        description = Core.Nothing,
        eventType = Core.Nothing,
        targetNumWorkers = Core.Nothing,
        time = Core.Nothing,
        workerPool = Core.Nothing
      }
  
  instance Core.FromJSON AutoscalingEvent where
    parseJSON =
      Core.withObject
        "AutoscalingEvent"
        ( \o ->
            AutoscalingEvent
              Core.<$> (o Core..:? "currentNumWorkers" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "description")
              Core.<*> (o Core..:? "eventType")
              Core.<*> (o Core..:? "targetNumWorkers" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "time")
              Core.<*> (o Core..:? "workerPool")
        )
  
  instance Core.ToJSON AutoscalingEvent where
    toJSON AutoscalingEvent {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentNumWorkers" Core..=)
                Core.. Core.AsText
                Core.<$> currentNumWorkers,
              ("description" Core..=) Core.<$> description,
              ("eventType" Core..=) Core.<$> eventType,
              ("targetNumWorkers" Core..=)
                Core.. Core.AsText
                Core.<$> targetNumWorkers,
              ("time" Core..=) Core.<$> time,
              ("workerPool" Core..=) Core.<$> workerPool
            ]
        )
  
  -- | Settings for WorkerPool autoscaling.
  --
  -- /See:/ 'newAutoscalingSettings' smart constructor.
  data AutoscalingSettings = AutoscalingSettings
    { -- | The algorithm to use for autoscaling.
      algorithm :: (Core.Maybe AutoscalingSettings_Algorithm),
      -- | The maximum number of workers to cap scaling at.
      maxNumWorkers :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AutoscalingSettings' with the minimum fields required to make a request.
  newAutoscalingSettings ::
    AutoscalingSettings
  newAutoscalingSettings =
    AutoscalingSettings
      { algorithm = Core.Nothing,
        maxNumWorkers = Core.Nothing
      }
  
  instance Core.FromJSON AutoscalingSettings where
    parseJSON =
      Core.withObject
        "AutoscalingSettings"
        ( \o ->
            AutoscalingSettings
              Core.<$> (o Core..:? "algorithm")
              Core.<*> (o Core..:? "maxNumWorkers")
        )
  
  instance Core.ToJSON AutoscalingSettings where
    toJSON AutoscalingSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("algorithm" Core..=) Core.<$> algorithm,
              ("maxNumWorkers" Core..=) Core.<$> maxNumWorkers
            ]
        )
  
  -- | Exponential buckets where the growth factor between buckets is @2**(2**-scale)@. e.g. for @scale=1@ growth factor is @2**(2**(-1))=sqrt(2)@. @n@ buckets will have the following boundaries. - 0th: [0, gf) - i in [1, n-1]: [gf^(i), gf^(i+1))
  --
  -- /See:/ 'newBase2Exponent' smart constructor.
  data Base2Exponent = Base2Exponent
    { -- | Must be greater than 0.
      numberOfBuckets :: (Core.Maybe Core.Int32),
      -- | Must be between -3 and 3. This forces the growth factor of the bucket boundaries to be between @2^(1\/8)@ and @256@.
      scale :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Base2Exponent' with the minimum fields required to make a request.
  newBase2Exponent ::
    Base2Exponent
  newBase2Exponent =
    Base2Exponent
      { numberOfBuckets = Core.Nothing,
        scale = Core.Nothing
      }
  
  instance Core.FromJSON Base2Exponent where
    parseJSON =
      Core.withObject
        "Base2Exponent"
        ( \o ->
            Base2Exponent
              Core.<$> (o Core..:? "numberOfBuckets")
              Core.<*> (o Core..:? "scale")
        )
  
  instance Core.ToJSON Base2Exponent where
    toJSON Base2Exponent {..} =
      Core.object
        ( Core.catMaybes
            [ ("numberOfBuckets" Core..=) Core.<$> numberOfBuckets,
              ("scale" Core..=) Core.<$> scale
            ]
        )
  
  -- | Metadata for a BigQuery connector used by the job.
  --
  -- /See:/ 'newBigQueryIODetails' smart constructor.
  data BigQueryIODetails = BigQueryIODetails
    { -- | Dataset accessed in the connection.
      dataset :: (Core.Maybe Core.Text),
      -- | Project accessed in the connection.
      projectId :: (Core.Maybe Core.Text),
      -- | Query used to access data in the connection.
      query :: (Core.Maybe Core.Text),
      -- | Table accessed in the connection.
      table :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BigQueryIODetails' with the minimum fields required to make a request.
  newBigQueryIODetails ::
    BigQueryIODetails
  newBigQueryIODetails =
    BigQueryIODetails
      { dataset = Core.Nothing,
        projectId = Core.Nothing,
        query = Core.Nothing,
        table = Core.Nothing
      }
  
  instance Core.FromJSON BigQueryIODetails where
    parseJSON =
      Core.withObject
        "BigQueryIODetails"
        ( \o ->
            BigQueryIODetails
              Core.<$> (o Core..:? "dataset")
              Core.<*> (o Core..:? "projectId")
              Core.<*> (o Core..:? "query")
              Core.<*> (o Core..:? "table")
        )
  
  instance Core.ToJSON BigQueryIODetails where
    toJSON BigQueryIODetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataset" Core..=) Core.<$> dataset,
              ("projectId" Core..=) Core.<$> projectId,
              ("query" Core..=) Core.<$> query,
              ("table" Core..=) Core.<$> table
            ]
        )
  
  -- | Metadata for a Cloud Bigtable connector used by the job.
  --
  -- /See:/ 'newBigTableIODetails' smart constructor.
  data BigTableIODetails = BigTableIODetails
    { -- | InstanceId accessed in the connection.
      instanceId :: (Core.Maybe Core.Text),
      -- | ProjectId accessed in the connection.
      projectId :: (Core.Maybe Core.Text),
      -- | TableId accessed in the connection.
      tableId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BigTableIODetails' with the minimum fields required to make a request.
  newBigTableIODetails ::
    BigTableIODetails
  newBigTableIODetails =
    BigTableIODetails
      { instanceId = Core.Nothing,
        projectId = Core.Nothing,
        tableId = Core.Nothing
      }
  
  instance Core.FromJSON BigTableIODetails where
    parseJSON =
      Core.withObject
        "BigTableIODetails"
        ( \o ->
            BigTableIODetails
              Core.<$> (o Core..:? "instanceId")
              Core.<*> (o Core..:? "projectId")
              Core.<*> (o Core..:? "tableId")
        )
  
  instance Core.ToJSON BigTableIODetails where
    toJSON BigTableIODetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("instanceId" Core..=) Core.<$> instanceId,
              ("projectId" Core..=) Core.<$> projectId,
              ("tableId" Core..=) Core.<$> tableId
            ]
        )
  
  -- | The message type used for encoding metrics of type bounded trie.
  --
  -- /See:/ 'newBoundedTrie' smart constructor.
  data BoundedTrie = BoundedTrie
    { -- | The maximum number of elements to store before truncation.
      bound :: (Core.Maybe Core.Int32),
      -- | A compact representation of all the elements in this trie.
      root :: (Core.Maybe BoundedTrieNode),
      -- | A more efficient representation for metrics consisting of a single value.
      singleton :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BoundedTrie' with the minimum fields required to make a request.
  newBoundedTrie ::
    BoundedTrie
  newBoundedTrie =
    BoundedTrie
      { bound = Core.Nothing,
        root = Core.Nothing,
        singleton = Core.Nothing
      }
  
  instance Core.FromJSON BoundedTrie where
    parseJSON =
      Core.withObject
        "BoundedTrie"
        ( \o ->
            BoundedTrie
              Core.<$> (o Core..:? "bound")
              Core.<*> (o Core..:? "root")
              Core.<*> (o Core..:? "singleton")
        )
  
  instance Core.ToJSON BoundedTrie where
    toJSON BoundedTrie {..} =
      Core.object
        ( Core.catMaybes
            [ ("bound" Core..=) Core.<$> bound,
              ("root" Core..=) Core.<$> root,
              ("singleton" Core..=) Core.<$> singleton
            ]
        )
  
  -- | A single node in a BoundedTrie.
  --
  -- /See:/ 'newBoundedTrieNode' smart constructor.
  data BoundedTrieNode = BoundedTrieNode
    { -- | Children of this node. Must be empty if truncated is true.
      children :: (Core.Maybe BoundedTrieNode_Children),
      -- | Whether this node has been truncated. A truncated leaf represents possibly many children with the same prefix.
      truncated :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BoundedTrieNode' with the minimum fields required to make a request.
  newBoundedTrieNode ::
    BoundedTrieNode
  newBoundedTrieNode =
    BoundedTrieNode
      { children = Core.Nothing,
        truncated = Core.Nothing
      }
  
  instance Core.FromJSON BoundedTrieNode where
    parseJSON =
      Core.withObject
        "BoundedTrieNode"
        ( \o ->
            BoundedTrieNode
              Core.<$> (o Core..:? "children")
              Core.<*> (o Core..:? "truncated")
        )
  
  instance Core.ToJSON BoundedTrieNode where
    toJSON BoundedTrieNode {..} =
      Core.object
        ( Core.catMaybes
            [ ("children" Core..=) Core.<$> children,
              ("truncated" Core..=) Core.<$> truncated
            ]
        )
  
  -- | Children of this node. Must be empty if truncated is true.
  --
  -- /See:/ 'newBoundedTrieNode_Children' smart constructor.
  newtype BoundedTrieNode_Children = BoundedTrieNode_Children
    { additional :: (Core.HashMap Core.Text BoundedTrieNode)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BoundedTrieNode_Children' with the minimum fields required to make a request.
  newBoundedTrieNode_Children ::
    -- |  See 'additional'.
    Core.HashMap Core.Text BoundedTrieNode ->
    BoundedTrieNode_Children
  newBoundedTrieNode_Children additional =
    BoundedTrieNode_Children {additional = additional}
  
  instance Core.FromJSON BoundedTrieNode_Children where
    parseJSON =
      Core.withObject
        "BoundedTrieNode_Children"
        (\o -> BoundedTrieNode_Children Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON BoundedTrieNode_Children where
    toJSON BoundedTrieNode_Children {..} = Core.toJSON additional
  
  -- | @BucketOptions@ describes the bucket boundaries used in the histogram.
  --
  -- /See:/ 'newBucketOptions' smart constructor.
  data BucketOptions = BucketOptions
    { -- | Bucket boundaries grow exponentially.
      exponential :: (Core.Maybe Base2Exponent),
      -- | Bucket boundaries grow linearly.
      linear :: (Core.Maybe Linear)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BucketOptions' with the minimum fields required to make a request.
  newBucketOptions ::
    BucketOptions
  newBucketOptions =
    BucketOptions {exponential = Core.Nothing, linear = Core.Nothing}
  
  instance Core.FromJSON BucketOptions where
    parseJSON =
      Core.withObject
        "BucketOptions"
        ( \o ->
            BucketOptions
              Core.<$> (o Core..:? "exponential")
              Core.<*> (o Core..:? "linear")
        )
  
  instance Core.ToJSON BucketOptions where
    toJSON BucketOptions {..} =
      Core.object
        ( Core.catMaybes
            [ ("exponential" Core..=) Core.<$> exponential,
              ("linear" Core..=) Core.<$> linear
            ]
        )
  
  -- | Modeled after information exposed by \/proc\/stat.
  --
  -- /See:/ 'newCPUTime' smart constructor.
  data CPUTime = CPUTime
    { -- | Average CPU utilization rate (% non-idle cpu \/ second) since previous sample.
      rate :: (Core.Maybe Core.Double),
      -- | Timestamp of the measurement.
      timestamp :: (Core.Maybe Core.DateTime),
      -- | Total active CPU time across all cores (ie., non-idle) in milliseconds since start-up.
      totalMs :: (Core.Maybe Core.Word64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CPUTime' with the minimum fields required to make a request.
  newCPUTime ::
    CPUTime
  newCPUTime =
    CPUTime
      { rate = Core.Nothing,
        timestamp = Core.Nothing,
        totalMs = Core.Nothing
      }
  
  instance Core.FromJSON CPUTime where
    parseJSON =
      Core.withObject
        "CPUTime"
        ( \o ->
            CPUTime
              Core.<$> (o Core..:? "rate")
              Core.<*> (o Core..:? "timestamp")
              Core.<*> (o Core..:? "totalMs" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON CPUTime where
    toJSON CPUTime {..} =
      Core.object
        ( Core.catMaybes
            [ ("rate" Core..=) Core.<$> rate,
              ("timestamp" Core..=) Core.<$> timestamp,
              ("totalMs" Core..=) Core.. Core.AsText Core.<$> totalMs
            ]
        )
  
  -- | Description of an interstitial value between transforms in an execution stage.
  --
  -- /See:/ 'newComponentSource' smart constructor.
  data ComponentSource = ComponentSource
    { -- | Dataflow service generated name for this source.
      name :: (Core.Maybe Core.Text),
      -- | User name for the original user transform or collection with which this source is most closely associated.
      originalTransformOrCollection :: (Core.Maybe Core.Text),
      -- | Human-readable name for this transform; may be user or system generated.
      userName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ComponentSource' with the minimum fields required to make a request.
  newComponentSource ::
    ComponentSource
  newComponentSource =
    ComponentSource
      { name = Core.Nothing,
        originalTransformOrCollection = Core.Nothing,
        userName = Core.Nothing
      }
  
  instance Core.FromJSON ComponentSource where
    parseJSON =
      Core.withObject
        "ComponentSource"
        ( \o ->
            ComponentSource
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "originalTransformOrCollection")
              Core.<*> (o Core..:? "userName")
        )
  
  instance Core.ToJSON ComponentSource where
    toJSON ComponentSource {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("originalTransformOrCollection" Core..=)
                Core.<$> originalTransformOrCollection,
              ("userName" Core..=) Core.<$> userName
            ]
        )
  
  -- | Description of a transform executed as part of an execution stage.
  --
  -- /See:/ 'newComponentTransform' smart constructor.
  data ComponentTransform = ComponentTransform
    { -- | Dataflow service generated name for this source.
      name :: (Core.Maybe Core.Text),
      -- | User name for the original user transform with which this transform is most closely associated.
      originalTransform :: (Core.Maybe Core.Text),
      -- | Human-readable name for this transform; may be user or system generated.
      userName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ComponentTransform' with the minimum fields required to make a request.
  newComponentTransform ::
    ComponentTransform
  newComponentTransform =
    ComponentTransform
      { name = Core.Nothing,
        originalTransform = Core.Nothing,
        userName = Core.Nothing
      }
  
  instance Core.FromJSON ComponentTransform where
    parseJSON =
      Core.withObject
        "ComponentTransform"
        ( \o ->
            ComponentTransform
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "originalTransform")
              Core.<*> (o Core..:? "userName")
        )
  
  instance Core.ToJSON ComponentTransform where
    toJSON ComponentTransform {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("originalTransform" Core..=) Core.<$> originalTransform,
              ("userName" Core..=) Core.<$> userName
            ]
        )
  
  -- | All configuration data for a particular Computation.
  --
  -- /See:/ 'newComputationTopology' smart constructor.
  data ComputationTopology = ComputationTopology
    { -- | The ID of the computation.
      computationId :: (Core.Maybe Core.Text),
      -- | The inputs to the computation.
      inputs :: (Core.Maybe [StreamLocation]),
      -- | The key ranges processed by the computation.
      keyRanges :: (Core.Maybe [KeyRangeLocation]),
      -- | The outputs from the computation.
      outputs :: (Core.Maybe [StreamLocation]),
      -- | The state family values.
      stateFamilies :: (Core.Maybe [StateFamilyConfig]),
      -- | The system stage name.
      systemStageName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ComputationTopology' with the minimum fields required to make a request.
  newComputationTopology ::
    ComputationTopology
  newComputationTopology =
    ComputationTopology
      { computationId = Core.Nothing,
        inputs = Core.Nothing,
        keyRanges = Core.Nothing,
        outputs = Core.Nothing,
        stateFamilies = Core.Nothing,
        systemStageName = Core.Nothing
      }
  
  instance Core.FromJSON ComputationTopology where
    parseJSON =
      Core.withObject
        "ComputationTopology"
        ( \o ->
            ComputationTopology
              Core.<$> (o Core..:? "computationId")
              Core.<*> (o Core..:? "inputs")
              Core.<*> (o Core..:? "keyRanges")
              Core.<*> (o Core..:? "outputs")
              Core.<*> (o Core..:? "stateFamilies")
              Core.<*> (o Core..:? "systemStageName")
        )
  
  instance Core.ToJSON ComputationTopology where
    toJSON ComputationTopology {..} =
      Core.object
        ( Core.catMaybes
            [ ("computationId" Core..=) Core.<$> computationId,
              ("inputs" Core..=) Core.<$> inputs,
              ("keyRanges" Core..=) Core.<$> keyRanges,
              ("outputs" Core..=) Core.<$> outputs,
              ("stateFamilies" Core..=) Core.<$> stateFamilies,
              ("systemStageName" Core..=) Core.<$> systemStageName
            ]
        )
  
  -- | A position that encapsulates an inner position and an index for the inner position. A ConcatPosition can be used by a reader of a source that encapsulates a set of other sources.
  --
  -- /See:/ 'newConcatPosition' smart constructor.
  data ConcatPosition = ConcatPosition
    { -- | Index of the inner source.
      index :: (Core.Maybe Core.Int32),
      -- | Position within the inner source.
      position :: (Core.Maybe Position)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ConcatPosition' with the minimum fields required to make a request.
  newConcatPosition ::
    ConcatPosition
  newConcatPosition =
    ConcatPosition {index = Core.Nothing, position = Core.Nothing}
  
  instance Core.FromJSON ConcatPosition where
    parseJSON =
      Core.withObject
        "ConcatPosition"
        ( \o ->
            ConcatPosition
              Core.<$> (o Core..:? "index")
              Core.<*> (o Core..:? "position")
        )
  
  instance Core.ToJSON ConcatPosition where
    toJSON ConcatPosition {..} =
      Core.object
        ( Core.catMaybes
            [ ("index" Core..=) Core.<$> index,
              ("position" Core..=) Core.<$> position
            ]
        )
  
  -- | Container Spec.
  --
  -- /See:/ 'newContainerSpec' smart constructor.
  data ContainerSpec = ContainerSpec
    { -- | Default runtime environment for the job.
      defaultEnvironment :: (Core.Maybe FlexTemplateRuntimeEnvironment),
      -- | Name of the docker container image. E.g., gcr.io\/project\/some-image
      image :: (Core.Maybe Core.Text),
      -- | Cloud Storage path to self-signed certificate of private registry.
      imageRepositoryCertPath :: (Core.Maybe Core.Text),
      -- | Secret Manager secret id for password to authenticate to private registry.
      imageRepositoryPasswordSecretId :: (Core.Maybe Core.Text),
      -- | Secret Manager secret id for username to authenticate to private registry.
      imageRepositoryUsernameSecretId :: (Core.Maybe Core.Text),
      -- | Metadata describing a template including description and validation rules.
      metadata :: (Core.Maybe TemplateMetadata),
      -- | Required. SDK info of the Flex Template.
      sdkInfo :: (Core.Maybe SDKInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ContainerSpec' with the minimum fields required to make a request.
  newContainerSpec ::
    ContainerSpec
  newContainerSpec =
    ContainerSpec
      { defaultEnvironment = Core.Nothing,
        image = Core.Nothing,
        imageRepositoryCertPath = Core.Nothing,
        imageRepositoryPasswordSecretId = Core.Nothing,
        imageRepositoryUsernameSecretId = Core.Nothing,
        metadata = Core.Nothing,
        sdkInfo = Core.Nothing
      }
  
  instance Core.FromJSON ContainerSpec where
    parseJSON =
      Core.withObject
        "ContainerSpec"
        ( \o ->
            ContainerSpec
              Core.<$> (o Core..:? "defaultEnvironment")
              Core.<*> (o Core..:? "image")
              Core.<*> (o Core..:? "imageRepositoryCertPath")
              Core.<*> (o Core..:? "imageRepositoryPasswordSecretId")
              Core.<*> (o Core..:? "imageRepositoryUsernameSecretId")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "sdkInfo")
        )
  
  instance Core.ToJSON ContainerSpec where
    toJSON ContainerSpec {..} =
      Core.object
        ( Core.catMaybes
            [ ("defaultEnvironment" Core..=) Core.<$> defaultEnvironment,
              ("image" Core..=) Core.<$> image,
              ("imageRepositoryCertPath" Core..=)
                Core.<$> imageRepositoryCertPath,
              ("imageRepositoryPasswordSecretId" Core..=)
                Core.<$> imageRepositoryPasswordSecretId,
              ("imageRepositoryUsernameSecretId" Core..=)
                Core.<$> imageRepositoryUsernameSecretId,
              ("metadata" Core..=) Core.<$> metadata,
              ("sdkInfo" Core..=) Core.<$> sdkInfo
            ]
        )
  
  -- | CounterMetadata includes all static non-name non-value counter attributes.
  --
  -- /See:/ 'newCounterMetadata' smart constructor.
  data CounterMetadata = CounterMetadata
    { -- | Human-readable description of the counter semantics.
      description :: (Core.Maybe Core.Text),
      -- | Counter aggregation kind.
      kind :: (Core.Maybe CounterMetadata_Kind),
      -- | A string referring to the unit type.
      otherUnits :: (Core.Maybe Core.Text),
      -- | System defined Units, see above enum.
      standardUnits :: (Core.Maybe CounterMetadata_StandardUnits)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CounterMetadata' with the minimum fields required to make a request.
  newCounterMetadata ::
    CounterMetadata
  newCounterMetadata =
    CounterMetadata
      { description = Core.Nothing,
        kind = Core.Nothing,
        otherUnits = Core.Nothing,
        standardUnits = Core.Nothing
      }
  
  instance Core.FromJSON CounterMetadata where
    parseJSON =
      Core.withObject
        "CounterMetadata"
        ( \o ->
            CounterMetadata
              Core.<$> (o Core..:? "description")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "otherUnits")
              Core.<*> (o Core..:? "standardUnits")
        )
  
  instance Core.ToJSON CounterMetadata where
    toJSON CounterMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("description" Core..=) Core.<$> description,
              ("kind" Core..=) Core.<$> kind,
              ("otherUnits" Core..=) Core.<$> otherUnits,
              ("standardUnits" Core..=) Core.<$> standardUnits
            ]
        )
  
  -- | Identifies a counter within a per-job namespace. Counters whose structured names are the same get merged into a single value for the job.
  --
  -- /See:/ 'newCounterStructuredName' smart constructor.
  data CounterStructuredName = CounterStructuredName
    { -- | Name of the optimized step being executed by the workers.
      componentStepName :: (Core.Maybe Core.Text),
      -- | Name of the stage. An execution step contains multiple component steps.
      executionStepName :: (Core.Maybe Core.Text),
      -- | Index of an input collection that\'s being read from\/written to as a side input. The index identifies a step\'s side inputs starting by 1 (e.g. the first side input has input/index 1, the third has input/index 3). Side inputs are identified by a pair of (original/step/name, input_index). This field helps uniquely identify them.
      inputIndex :: (Core.Maybe Core.Int32),
      -- | Counter name. Not necessarily globally-unique, but unique within the context of the other fields. Required.
      name :: (Core.Maybe Core.Text),
      -- | One of the standard Origins defined above.
      origin :: (Core.Maybe CounterStructuredName_Origin),
      -- | A string containing a more specific namespace of the counter\'s origin.
      originNamespace :: (Core.Maybe Core.Text),
      -- | The step name requesting an operation, such as GBK. I.e. the ParDo causing a read\/write from shuffle to occur, or a read from side inputs.
      originalRequestingStepName :: (Core.Maybe Core.Text),
      -- | System generated name of the original step in the user\'s graph, before optimization.
      originalStepName :: (Core.Maybe Core.Text),
      -- | Portion of this counter, either key or value.
      portion :: (Core.Maybe CounterStructuredName_Portion),
      -- | ID of a particular worker.
      workerId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CounterStructuredName' with the minimum fields required to make a request.
  newCounterStructuredName ::
    CounterStructuredName
  newCounterStructuredName =
    CounterStructuredName
      { componentStepName = Core.Nothing,
        executionStepName = Core.Nothing,
        inputIndex = Core.Nothing,
        name = Core.Nothing,
        origin = Core.Nothing,
        originNamespace = Core.Nothing,
        originalRequestingStepName = Core.Nothing,
        originalStepName = Core.Nothing,
        portion = Core.Nothing,
        workerId = Core.Nothing
      }
  
  instance Core.FromJSON CounterStructuredName where
    parseJSON =
      Core.withObject
        "CounterStructuredName"
        ( \o ->
            CounterStructuredName
              Core.<$> (o Core..:? "componentStepName")
              Core.<*> (o Core..:? "executionStepName")
              Core.<*> (o Core..:? "inputIndex")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "origin")
              Core.<*> (o Core..:? "originNamespace")
              Core.<*> (o Core..:? "originalRequestingStepName")
              Core.<*> (o Core..:? "originalStepName")
              Core.<*> (o Core..:? "portion")
              Core.<*> (o Core..:? "workerId")
        )
  
  instance Core.ToJSON CounterStructuredName where
    toJSON CounterStructuredName {..} =
      Core.object
        ( Core.catMaybes
            [ ("componentStepName" Core..=) Core.<$> componentStepName,
              ("executionStepName" Core..=) Core.<$> executionStepName,
              ("inputIndex" Core..=) Core.<$> inputIndex,
              ("name" Core..=) Core.<$> name,
              ("origin" Core..=) Core.<$> origin,
              ("originNamespace" Core..=) Core.<$> originNamespace,
              ("originalRequestingStepName" Core..=)
                Core.<$> originalRequestingStepName,
              ("originalStepName" Core..=) Core.<$> originalStepName,
              ("portion" Core..=) Core.<$> portion,
              ("workerId" Core..=) Core.<$> workerId
            ]
        )
  
  -- | A single message which encapsulates structured name and metadata for a given counter.
  --
  -- /See:/ 'newCounterStructuredNameAndMetadata' smart constructor.
  data CounterStructuredNameAndMetadata = CounterStructuredNameAndMetadata
    { -- | Metadata associated with a counter
      metadata :: (Core.Maybe CounterMetadata),
      -- | Structured name of the counter.
      name :: (Core.Maybe CounterStructuredName)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CounterStructuredNameAndMetadata' with the minimum fields required to make a request.
  newCounterStructuredNameAndMetadata ::
    CounterStructuredNameAndMetadata
  newCounterStructuredNameAndMetadata =
    CounterStructuredNameAndMetadata
      { metadata = Core.Nothing,
        name = Core.Nothing
      }
  
  instance Core.FromJSON CounterStructuredNameAndMetadata where
    parseJSON =
      Core.withObject
        "CounterStructuredNameAndMetadata"
        ( \o ->
            CounterStructuredNameAndMetadata
              Core.<$> (o Core..:? "metadata")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON CounterStructuredNameAndMetadata where
    toJSON CounterStructuredNameAndMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("metadata" Core..=) Core.<$> metadata,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | An update to a Counter sent from a worker. Next ID: 17
  --
  -- /See:/ 'newCounterUpdate' smart constructor.
  data CounterUpdate = CounterUpdate
    { -- | Boolean value for And, Or.
      boolean :: (Core.Maybe Core.Bool),
      -- | Bounded trie data
      boundedTrie :: (Core.Maybe BoundedTrie),
      -- | True if this counter is reported as the total cumulative aggregate value accumulated since the worker started working on this WorkItem. By default this is false, indicating that this counter is reported as a delta.
      cumulative :: (Core.Maybe Core.Bool),
      -- | Distribution data
      distribution :: (Core.Maybe DistributionUpdate),
      -- | Floating point value for Sum, Max, Min.
      floatingPoint :: (Core.Maybe Core.Double),
      -- | List of floating point numbers, for Set.
      floatingPointList :: (Core.Maybe FloatingPointList),
      -- | Floating point mean aggregation value for Mean.
      floatingPointMean :: (Core.Maybe FloatingPointMean),
      -- | Integer value for Sum, Max, Min.
      integer :: (Core.Maybe SplitInt64),
      -- | Gauge data
      integerGauge :: (Core.Maybe IntegerGauge),
      -- | List of integers, for Set.
      integerList :: (Core.Maybe IntegerList),
      -- | Integer mean aggregation value for Mean.
      integerMean :: (Core.Maybe IntegerMean),
      -- | Value for internally-defined counters used by the Dataflow service.
      internal :: (Core.Maybe Core.Value),
      -- | Counter name and aggregation type.
      nameAndKind :: (Core.Maybe NameAndKind),
      -- | The service-generated short identifier for this counter. The short_id -> (name, metadata) mapping is constant for the lifetime of a job.
      shortId :: (Core.Maybe Core.Int64),
      -- | List of strings, for Set.
      stringList :: (Core.Maybe StringList),
      -- | Counter structured name and metadata.
      structuredNameAndMetadata :: (Core.Maybe CounterStructuredNameAndMetadata)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CounterUpdate' with the minimum fields required to make a request.
  newCounterUpdate ::
    CounterUpdate
  newCounterUpdate =
    CounterUpdate
      { boolean = Core.Nothing,
        boundedTrie = Core.Nothing,
        cumulative = Core.Nothing,
        distribution = Core.Nothing,
        floatingPoint = Core.Nothing,
        floatingPointList = Core.Nothing,
        floatingPointMean = Core.Nothing,
        integer = Core.Nothing,
        integerGauge = Core.Nothing,
        integerList = Core.Nothing,
        integerMean = Core.Nothing,
        internal = Core.Nothing,
        nameAndKind = Core.Nothing,
        shortId = Core.Nothing,
        stringList = Core.Nothing,
        structuredNameAndMetadata = Core.Nothing
      }
  
  instance Core.FromJSON CounterUpdate where
    parseJSON =
      Core.withObject
        "CounterUpdate"
        ( \o ->
            CounterUpdate
              Core.<$> (o Core..:? "boolean")
              Core.<*> (o Core..:? "boundedTrie")
              Core.<*> (o Core..:? "cumulative")
              Core.<*> (o Core..:? "distribution")
              Core.<*> (o Core..:? "floatingPoint")
              Core.<*> (o Core..:? "floatingPointList")
              Core.<*> (o Core..:? "floatingPointMean")
              Core.<*> (o Core..:? "integer")
              Core.<*> (o Core..:? "integerGauge")
              Core.<*> (o Core..:? "integerList")
              Core.<*> (o Core..:? "integerMean")
              Core.<*> (o Core..:? "internal")
              Core.<*> (o Core..:? "nameAndKind")
              Core.<*> (o Core..:? "shortId" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "stringList")
              Core.<*> (o Core..:? "structuredNameAndMetadata")
        )
  
  instance Core.ToJSON CounterUpdate where
    toJSON CounterUpdate {..} =
      Core.object
        ( Core.catMaybes
            [ ("boolean" Core..=) Core.<$> boolean,
              ("boundedTrie" Core..=) Core.<$> boundedTrie,
              ("cumulative" Core..=) Core.<$> cumulative,
              ("distribution" Core..=) Core.<$> distribution,
              ("floatingPoint" Core..=) Core.<$> floatingPoint,
              ("floatingPointList" Core..=) Core.<$> floatingPointList,
              ("floatingPointMean" Core..=) Core.<$> floatingPointMean,
              ("integer" Core..=) Core.<$> integer,
              ("integerGauge" Core..=) Core.<$> integerGauge,
              ("integerList" Core..=) Core.<$> integerList,
              ("integerMean" Core..=) Core.<$> integerMean,
              ("internal" Core..=) Core.<$> internal,
              ("nameAndKind" Core..=) Core.<$> nameAndKind,
              ("shortId" Core..=) Core.. Core.AsText Core.<$> shortId,
              ("stringList" Core..=) Core.<$> stringList,
              ("structuredNameAndMetadata" Core..=)
                Core.<$> structuredNameAndMetadata
            ]
        )
  
  -- | A request to create a Cloud Dataflow job from a template.
  --
  -- /See:/ 'newCreateJobFromTemplateRequest' smart constructor.
  data CreateJobFromTemplateRequest = CreateJobFromTemplateRequest
    { -- | The runtime environment for the job.
      environment :: (Core.Maybe RuntimeEnvironment),
      -- | Required. A Cloud Storage path to the template from which to create the job. Must be a valid Cloud Storage URL, beginning with @gs:\/\/@.
      gcsPath :: (Core.Maybe Core.Text),
      -- | Required. The job name to use for the created job.
      jobName :: (Core.Maybe Core.Text),
      -- | The [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) to which to direct the request.
      location :: (Core.Maybe Core.Text),
      -- | The runtime parameters to pass to the job.
      parameters :: (Core.Maybe CreateJobFromTemplateRequest_Parameters)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateJobFromTemplateRequest' with the minimum fields required to make a request.
  newCreateJobFromTemplateRequest ::
    CreateJobFromTemplateRequest
  newCreateJobFromTemplateRequest =
    CreateJobFromTemplateRequest
      { environment = Core.Nothing,
        gcsPath = Core.Nothing,
        jobName = Core.Nothing,
        location = Core.Nothing,
        parameters = Core.Nothing
      }
  
  instance Core.FromJSON CreateJobFromTemplateRequest where
    parseJSON =
      Core.withObject
        "CreateJobFromTemplateRequest"
        ( \o ->
            CreateJobFromTemplateRequest
              Core.<$> (o Core..:? "environment")
              Core.<*> (o Core..:? "gcsPath")
              Core.<*> (o Core..:? "jobName")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "parameters")
        )
  
  instance Core.ToJSON CreateJobFromTemplateRequest where
    toJSON CreateJobFromTemplateRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("environment" Core..=) Core.<$> environment,
              ("gcsPath" Core..=) Core.<$> gcsPath,
              ("jobName" Core..=) Core.<$> jobName,
              ("location" Core..=) Core.<$> location,
              ("parameters" Core..=) Core.<$> parameters
            ]
        )
  
  -- | The runtime parameters to pass to the job.
  --
  -- /See:/ 'newCreateJobFromTemplateRequest_Parameters' smart constructor.
  newtype CreateJobFromTemplateRequest_Parameters = CreateJobFromTemplateRequest_Parameters
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CreateJobFromTemplateRequest_Parameters' with the minimum fields required to make a request.
  newCreateJobFromTemplateRequest_Parameters ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    CreateJobFromTemplateRequest_Parameters
  newCreateJobFromTemplateRequest_Parameters additional =
    CreateJobFromTemplateRequest_Parameters {additional = additional}
  
  instance Core.FromJSON CreateJobFromTemplateRequest_Parameters where
    parseJSON =
      Core.withObject
        "CreateJobFromTemplateRequest_Parameters"
        ( \o ->
            CreateJobFromTemplateRequest_Parameters
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON CreateJobFromTemplateRequest_Parameters where
    toJSON CreateJobFromTemplateRequest_Parameters {..} =
      Core.toJSON additional
  
  -- | Identifies the location of a custom souce.
  --
  -- /See:/ 'newCustomSourceLocation' smart constructor.
  newtype CustomSourceLocation = CustomSourceLocation
    { -- | Whether this source is stateful.
      stateful :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CustomSourceLocation' with the minimum fields required to make a request.
  newCustomSourceLocation ::
    CustomSourceLocation
  newCustomSourceLocation =
    CustomSourceLocation {stateful = Core.Nothing}
  
  instance Core.FromJSON CustomSourceLocation where
    parseJSON =
      Core.withObject
        "CustomSourceLocation"
        (\o -> CustomSourceLocation Core.<$> (o Core..:? "stateful"))
  
  instance Core.ToJSON CustomSourceLocation where
    toJSON CustomSourceLocation {..} =
      Core.object
        (Core.catMaybes [("stateful" Core..=) Core.<$> stateful])
  
  -- | Data disk assignment for a given VM instance.
  --
  -- /See:/ 'newDataDiskAssignment' smart constructor.
  data DataDiskAssignment = DataDiskAssignment
    { -- | Mounted data disks. The order is important a data disk\'s 0-based index in this list defines which persistent directory the disk is mounted to, for example the list of { \"myproject-1014-104817-4c2-harness-0-disk-0\" }, { \"myproject-1014-104817-4c2-harness-0-disk-1\" }.
      dataDisks :: (Core.Maybe [Core.Text]),
      -- | VM instance name the data disks mounted to, for example \"myproject-1014-104817-4c2-harness-0\".
      vmInstance :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DataDiskAssignment' with the minimum fields required to make a request.
  newDataDiskAssignment ::
    DataDiskAssignment
  newDataDiskAssignment =
    DataDiskAssignment
      { dataDisks = Core.Nothing,
        vmInstance = Core.Nothing
      }
  
  instance Core.FromJSON DataDiskAssignment where
    parseJSON =
      Core.withObject
        "DataDiskAssignment"
        ( \o ->
            DataDiskAssignment
              Core.<$> (o Core..:? "dataDisks")
              Core.<*> (o Core..:? "vmInstance")
        )
  
  instance Core.ToJSON DataDiskAssignment where
    toJSON DataDiskAssignment {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataDisks" Core..=) Core.<$> dataDisks,
              ("vmInstance" Core..=) Core.<$> vmInstance
            ]
        )
  
  -- | Configuration options for sampling elements.
  --
  -- /See:/ 'newDataSamplingConfig' smart constructor.
  newtype DataSamplingConfig = DataSamplingConfig
    { -- | List of given sampling behaviors to enable. For example, specifying behaviors = [ALWAYS/ON] samples in-flight elements but does not sample exceptions. Can be used to specify multiple behaviors like, behaviors = [ALWAYS/ON, EXCEPTIONS] for specifying periodic sampling and exception sampling. If DISABLED is in the list, then sampling will be disabled and ignore the other given behaviors. Ordering does not matter.
      behaviors :: (Core.Maybe [DataSamplingConfig_BehaviorsItem])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DataSamplingConfig' with the minimum fields required to make a request.
  newDataSamplingConfig ::
    DataSamplingConfig
  newDataSamplingConfig =
    DataSamplingConfig {behaviors = Core.Nothing}
  
  instance Core.FromJSON DataSamplingConfig where
    parseJSON =
      Core.withObject
        "DataSamplingConfig"
        (\o -> DataSamplingConfig Core.<$> (o Core..:? "behaviors"))
  
  instance Core.ToJSON DataSamplingConfig where
    toJSON DataSamplingConfig {..} =
      Core.object
        (Core.catMaybes [("behaviors" Core..=) Core.<$> behaviors])
  
  -- | Contains per-worker telemetry about the data sampling feature.
  --
  -- /See:/ 'newDataSamplingReport' smart constructor.
  data DataSamplingReport = DataSamplingReport
    { -- | Optional. Delta of bytes written to file from previous report.
      bytesWrittenDelta :: (Core.Maybe Core.Int64),
      -- | Optional. Delta of bytes sampled from previous report.
      elementsSampledBytes :: (Core.Maybe Core.Int64),
      -- | Optional. Delta of number of elements sampled from previous report.
      elementsSampledCount :: (Core.Maybe Core.Int64),
      -- | Optional. Delta of number of samples taken from user code exceptions from previous report.
      exceptionsSampledCount :: (Core.Maybe Core.Int64),
      -- | Optional. Delta of number of PCollections sampled from previous report.
      pcollectionsSampledCount :: (Core.Maybe Core.Int64),
      -- | Optional. Delta of errors counts from persisting the samples from previous report.
      persistenceErrorsCount :: (Core.Maybe Core.Int64),
      -- | Optional. Delta of errors counts from retrieving, or translating the samples from previous report.
      translationErrorsCount :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DataSamplingReport' with the minimum fields required to make a request.
  newDataSamplingReport ::
    DataSamplingReport
  newDataSamplingReport =
    DataSamplingReport
      { bytesWrittenDelta = Core.Nothing,
        elementsSampledBytes = Core.Nothing,
        elementsSampledCount = Core.Nothing,
        exceptionsSampledCount = Core.Nothing,
        pcollectionsSampledCount = Core.Nothing,
        persistenceErrorsCount = Core.Nothing,
        translationErrorsCount = Core.Nothing
      }
  
  instance Core.FromJSON DataSamplingReport where
    parseJSON =
      Core.withObject
        "DataSamplingReport"
        ( \o ->
            DataSamplingReport
              Core.<$> (o Core..:? "bytesWrittenDelta" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> ( o
                           Core..:? "elementsSampledBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "elementsSampledCount"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "exceptionsSampledCount"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "pcollectionsSampledCount"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "persistenceErrorsCount"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "translationErrorsCount"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON DataSamplingReport where
    toJSON DataSamplingReport {..} =
      Core.object
        ( Core.catMaybes
            [ ("bytesWrittenDelta" Core..=)
                Core.. Core.AsText
                Core.<$> bytesWrittenDelta,
              ("elementsSampledBytes" Core..=)
                Core.. Core.AsText
                Core.<$> elementsSampledBytes,
              ("elementsSampledCount" Core..=)
                Core.. Core.AsText
                Core.<$> elementsSampledCount,
              ("exceptionsSampledCount" Core..=)
                Core.. Core.AsText
                Core.<$> exceptionsSampledCount,
              ("pcollectionsSampledCount" Core..=)
                Core.. Core.AsText
                Core.<$> pcollectionsSampledCount,
              ("persistenceErrorsCount" Core..=)
                Core.. Core.AsText
                Core.<$> persistenceErrorsCount,
              ("translationErrorsCount" Core..=)
                Core.. Core.AsText
                Core.<$> translationErrorsCount
            ]
        )
  
  -- | The gauge value of a metric.
  --
  -- /See:/ 'newDataflowGaugeValue' smart constructor.
  data DataflowGaugeValue = DataflowGaugeValue
    { -- | The timestamp when the gauge was recorded.
      measuredTime :: (Core.Maybe Core.DateTime),
      -- | The value of the gauge.
      value :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DataflowGaugeValue' with the minimum fields required to make a request.
  newDataflowGaugeValue ::
    DataflowGaugeValue
  newDataflowGaugeValue =
    DataflowGaugeValue
      { measuredTime = Core.Nothing,
        value = Core.Nothing
      }
  
  instance Core.FromJSON DataflowGaugeValue where
    parseJSON =
      Core.withObject
        "DataflowGaugeValue"
        ( \o ->
            DataflowGaugeValue
              Core.<$> (o Core..:? "measuredTime")
              Core.<*> (o Core..:? "value" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON DataflowGaugeValue where
    toJSON DataflowGaugeValue {..} =
      Core.object
        ( Core.catMaybes
            [ ("measuredTime" Core..=) Core.<$> measuredTime,
              ("value" Core..=) Core.. Core.AsText Core.<$> value
            ]
        )
  
  -- | Summary statistics for a population of values. HistogramValue contains a sequence of buckets and gives a count of values that fall into each bucket. Bucket boundares are defined by a formula and bucket widths are either fixed or exponentially increasing.
  --
  -- /See:/ 'newDataflowHistogramValue' smart constructor.
  data DataflowHistogramValue = DataflowHistogramValue
    { -- | Optional. The number of values in each bucket of the histogram, as described in @bucket_options@. @bucket_counts@ should contain N values, where N is the number of buckets specified in @bucket_options@. If @bucket_counts@ has fewer than N values, the remaining values are assumed to be 0.
      bucketCounts :: (Core.Maybe [Core.Int64]),
      -- | Describes the bucket boundaries used in the histogram.
      bucketOptions :: (Core.Maybe BucketOptions),
      -- | Number of values recorded in this histogram.
      count :: (Core.Maybe Core.Int64),
      -- | Statistics on the values recorded in the histogram that fall out of the bucket boundaries.
      outlierStats :: (Core.Maybe OutlierStats)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DataflowHistogramValue' with the minimum fields required to make a request.
  newDataflowHistogramValue ::
    DataflowHistogramValue
  newDataflowHistogramValue =
    DataflowHistogramValue
      { bucketCounts = Core.Nothing,
        bucketOptions = Core.Nothing,
        count = Core.Nothing,
        outlierStats = Core.Nothing
      }
  
  instance Core.FromJSON DataflowHistogramValue where
    parseJSON =
      Core.withObject
        "DataflowHistogramValue"
        ( \o ->
            DataflowHistogramValue
              Core.<$> ( o
                           Core..:? "bucketCounts"
                           Core.<&> Core.fmap (Core.fmap Core.fromAsText)
                       )
              Core.<*> (o Core..:? "bucketOptions")
              Core.<*> (o Core..:? "count" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "outlierStats")
        )
  
  instance Core.ToJSON DataflowHistogramValue where
    toJSON DataflowHistogramValue {..} =
      Core.object
        ( Core.catMaybes
            [ ("bucketCounts" Core..=)
                Core.. Core.fmap Core.AsText
                Core.<$> bucketCounts,
              ("bucketOptions" Core..=) Core.<$> bucketOptions,
              ("count" Core..=) Core.. Core.AsText Core.<$> count,
              ("outlierStats" Core..=) Core.<$> outlierStats
            ]
        )
  
  -- | Metadata for a Datastore connector used by the job.
  --
  -- /See:/ 'newDatastoreIODetails' smart constructor.
  data DatastoreIODetails = DatastoreIODetails
    { -- | Namespace used in the connection.
      namespace :: (Core.Maybe Core.Text),
      -- | ProjectId accessed in the connection.
      projectId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DatastoreIODetails' with the minimum fields required to make a request.
  newDatastoreIODetails ::
    DatastoreIODetails
  newDatastoreIODetails =
    DatastoreIODetails
      { namespace = Core.Nothing,
        projectId = Core.Nothing
      }
  
  instance Core.FromJSON DatastoreIODetails where
    parseJSON =
      Core.withObject
        "DatastoreIODetails"
        ( \o ->
            DatastoreIODetails
              Core.<$> (o Core..:? "namespace")
              Core.<*> (o Core..:? "projectId")
        )
  
  instance Core.ToJSON DatastoreIODetails where
    toJSON DatastoreIODetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("namespace" Core..=) Core.<$> namespace,
              ("projectId" Core..=) Core.<$> projectId
            ]
        )
  
  -- | Describes any options that have an effect on the debugging of pipelines.
  --
  -- /See:/ 'newDebugOptions' smart constructor.
  data DebugOptions = DebugOptions
    { -- | Configuration options for sampling elements from a running pipeline.
      dataSampling :: (Core.Maybe DataSamplingConfig),
      -- | Optional. When true, enables the logging of the literal hot key to the user\'s Cloud Logging.
      enableHotKeyLogging :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DebugOptions' with the minimum fields required to make a request.
  newDebugOptions ::
    DebugOptions
  newDebugOptions =
    DebugOptions
      { dataSampling = Core.Nothing,
        enableHotKeyLogging = Core.Nothing
      }
  
  instance Core.FromJSON DebugOptions where
    parseJSON =
      Core.withObject
        "DebugOptions"
        ( \o ->
            DebugOptions
              Core.<$> (o Core..:? "dataSampling")
              Core.<*> (o Core..:? "enableHotKeyLogging")
        )
  
  instance Core.ToJSON DebugOptions where
    toJSON DebugOptions {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataSampling" Core..=) Core.<$> dataSampling,
              ("enableHotKeyLogging" Core..=) Core.<$> enableHotKeyLogging
            ]
        )
  
  -- | Response from deleting a snapshot.
  --
  -- /See:/ 'newDeleteSnapshotResponse' smart constructor.
  data DeleteSnapshotResponse = DeleteSnapshotResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DeleteSnapshotResponse' with the minimum fields required to make a request.
  newDeleteSnapshotResponse ::
    DeleteSnapshotResponse
  newDeleteSnapshotResponse = DeleteSnapshotResponse
  
  instance Core.FromJSON DeleteSnapshotResponse where
    parseJSON =
      Core.withObject
        "DeleteSnapshotResponse"
        (\o -> Core.pure DeleteSnapshotResponse)
  
  instance Core.ToJSON DeleteSnapshotResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | Specification of one of the bundles produced as a result of splitting a Source (e.g. when executing a SourceSplitRequest, or when splitting an active task using WorkItemStatus.dynamic/source/split), relative to the source being split.
  --
  -- /See:/ 'newDerivedSource' smart constructor.
  data DerivedSource = DerivedSource
    { -- | What source to base the produced source on (if any).
      derivationMode :: (Core.Maybe DerivedSource_DerivationMode),
      -- | Specification of the source.
      source :: (Core.Maybe Source)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DerivedSource' with the minimum fields required to make a request.
  newDerivedSource ::
    DerivedSource
  newDerivedSource =
    DerivedSource
      { derivationMode = Core.Nothing,
        source = Core.Nothing
      }
  
  instance Core.FromJSON DerivedSource where
    parseJSON =
      Core.withObject
        "DerivedSource"
        ( \o ->
            DerivedSource
              Core.<$> (o Core..:? "derivationMode")
              Core.<*> (o Core..:? "source")
        )
  
  instance Core.ToJSON DerivedSource where
    toJSON DerivedSource {..} =
      Core.object
        ( Core.catMaybes
            [ ("derivationMode" Core..=) Core.<$> derivationMode,
              ("source" Core..=) Core.<$> source
            ]
        )
  
  -- | Describes the data disk used by a workflow job.
  --
  -- /See:/ 'newDisk' smart constructor.
  data Disk = Disk
    { -- | Disk storage type, as defined by Google Compute Engine. This must be a disk type appropriate to the project and zone in which the workers will run. If unknown or unspecified, the service will attempt to choose a reasonable default. For example, the standard persistent disk type is a resource name typically ending in \"pd-standard\". If SSD persistent disks are available, the resource name typically ends with \"pd-ssd\". The actual valid values are defined the Google Compute Engine API, not by the Cloud Dataflow API; consult the Google Compute Engine documentation for more information about determining the set of available disk types for a particular project and zone. Google Compute Engine Disk types are local to a particular project in a particular zone, and so the resource name will typically look something like this: compute.googleapis.com\/projects\/project-id\/zones\/zone\/diskTypes\/pd-standard
      diskType :: (Core.Maybe Core.Text),
      -- | Directory in a VM where disk is mounted.
      mountPoint :: (Core.Maybe Core.Text),
      -- | Size of disk in GB. If zero or unspecified, the service will attempt to choose a reasonable default.
      sizeGb :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Disk' with the minimum fields required to make a request.
  newDisk ::
    Disk
  newDisk =
    Disk
      { diskType = Core.Nothing,
        mountPoint = Core.Nothing,
        sizeGb = Core.Nothing
      }
  
  instance Core.FromJSON Disk where
    parseJSON =
      Core.withObject
        "Disk"
        ( \o ->
            Disk
              Core.<$> (o Core..:? "diskType")
              Core.<*> (o Core..:? "mountPoint")
              Core.<*> (o Core..:? "sizeGb")
        )
  
  instance Core.ToJSON Disk where
    toJSON Disk {..} =
      Core.object
        ( Core.catMaybes
            [ ("diskType" Core..=) Core.<$> diskType,
              ("mountPoint" Core..=) Core.<$> mountPoint,
              ("sizeGb" Core..=) Core.<$> sizeGb
            ]
        )
  
  -- | Data provided with a pipeline or transform to provide descriptive info.
  --
  -- /See:/ 'newDisplayData' smart constructor.
  data DisplayData = DisplayData
    { -- | Contains value if the data is of a boolean type.
      boolValue :: (Core.Maybe Core.Bool),
      -- | Contains value if the data is of duration type.
      durationValue :: (Core.Maybe Core.Duration),
      -- | Contains value if the data is of float type.
      floatValue :: (Core.Maybe Core.Double),
      -- | Contains value if the data is of int64 type.
      int64Value :: (Core.Maybe Core.Int64),
      -- | Contains value if the data is of java class type.
      javaClassValue :: (Core.Maybe Core.Text),
      -- | The key identifying the display data. This is intended to be used as a label for the display data when viewed in a dax monitoring system.
      key :: (Core.Maybe Core.Text),
      -- | An optional label to display in a dax UI for the element.
      label :: (Core.Maybe Core.Text),
      -- | The namespace for the key. This is usually a class name or programming language namespace (i.e. python module) which defines the display data. This allows a dax monitoring system to specially handle the data and perform custom rendering.
      namespace :: (Core.Maybe Core.Text),
      -- | A possible additional shorter value to display. For example a java/class/name/value of com.mypackage.MyDoFn will be stored with MyDoFn as the short/str/value and com.mypackage.MyDoFn as the java/class/name value. short/str/value can be displayed and java/class/name/value will be displayed as a tooltip.
      shortStrValue :: (Core.Maybe Core.Text),
      -- | Contains value if the data is of string type.
      strValue :: (Core.Maybe Core.Text),
      -- | Contains value if the data is of timestamp type.
      timestampValue :: (Core.Maybe Core.DateTime),
      -- | An optional full URL.
      url :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DisplayData' with the minimum fields required to make a request.
  newDisplayData ::
    DisplayData
  newDisplayData =
    DisplayData
      { boolValue = Core.Nothing,
        durationValue = Core.Nothing,
        floatValue = Core.Nothing,
        int64Value = Core.Nothing,
        javaClassValue = Core.Nothing,
        key = Core.Nothing,
        label = Core.Nothing,
        namespace = Core.Nothing,
        shortStrValue = Core.Nothing,
        strValue = Core.Nothing,
        timestampValue = Core.Nothing,
        url = Core.Nothing
      }
  
  instance Core.FromJSON DisplayData where
    parseJSON =
      Core.withObject
        "DisplayData"
        ( \o ->
            DisplayData
              Core.<$> (o Core..:? "boolValue")
              Core.<*> (o Core..:? "durationValue")
              Core.<*> (o Core..:? "floatValue")
              Core.<*> (o Core..:? "int64Value" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "javaClassValue")
              Core.<*> (o Core..:? "key")
              Core.<*> (o Core..:? "label")
              Core.<*> (o Core..:? "namespace")
              Core.<*> (o Core..:? "shortStrValue")
              Core.<*> (o Core..:? "strValue")
              Core.<*> (o Core..:? "timestampValue")
              Core.<*> (o Core..:? "url")
        )
  
  instance Core.ToJSON DisplayData where
    toJSON DisplayData {..} =
      Core.object
        ( Core.catMaybes
            [ ("boolValue" Core..=) Core.<$> boolValue,
              ("durationValue" Core..=) Core.<$> durationValue,
              ("floatValue" Core..=) Core.<$> floatValue,
              ("int64Value" Core..=) Core.. Core.AsText Core.<$> int64Value,
              ("javaClassValue" Core..=) Core.<$> javaClassValue,
              ("key" Core..=) Core.<$> key,
              ("label" Core..=) Core.<$> label,
              ("namespace" Core..=) Core.<$> namespace,
              ("shortStrValue" Core..=) Core.<$> shortStrValue,
              ("strValue" Core..=) Core.<$> strValue,
              ("timestampValue" Core..=) Core.<$> timestampValue,
              ("url" Core..=) Core.<$> url
            ]
        )
  
  -- | A metric value representing a distribution.
  --
  -- /See:/ 'newDistributionUpdate' smart constructor.
  data DistributionUpdate = DistributionUpdate
    { -- | The count of the number of elements present in the distribution.
      count :: (Core.Maybe SplitInt64),
      -- | (Optional) Histogram of value counts for the distribution.
      histogram :: (Core.Maybe Histogram),
      -- | The maximum value present in the distribution.
      max :: (Core.Maybe SplitInt64),
      -- | The minimum value present in the distribution.
      min :: (Core.Maybe SplitInt64),
      -- | Use an int64 since we\'d prefer the added precision. If overflow is a common problem we can detect it and use an additional int64 or a double.
      sum :: (Core.Maybe SplitInt64),
      -- | Use a double since the sum of squares is likely to overflow int64.
      sumOfSquares :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DistributionUpdate' with the minimum fields required to make a request.
  newDistributionUpdate ::
    DistributionUpdate
  newDistributionUpdate =
    DistributionUpdate
      { count = Core.Nothing,
        histogram = Core.Nothing,
        max = Core.Nothing,
        min = Core.Nothing,
        sum = Core.Nothing,
        sumOfSquares = Core.Nothing
      }
  
  instance Core.FromJSON DistributionUpdate where
    parseJSON =
      Core.withObject
        "DistributionUpdate"
        ( \o ->
            DistributionUpdate
              Core.<$> (o Core..:? "count")
              Core.<*> (o Core..:? "histogram")
              Core.<*> (o Core..:? "max")
              Core.<*> (o Core..:? "min")
              Core.<*> (o Core..:? "sum")
              Core.<*> (o Core..:? "sumOfSquares")
        )
  
  instance Core.ToJSON DistributionUpdate where
    toJSON DistributionUpdate {..} =
      Core.object
        ( Core.catMaybes
            [ ("count" Core..=) Core.<$> count,
              ("histogram" Core..=) Core.<$> histogram,
              ("max" Core..=) Core.<$> max,
              ("min" Core..=) Core.<$> min,
              ("sum" Core..=) Core.<$> sum,
              ("sumOfSquares" Core..=) Core.<$> sumOfSquares
            ]
        )
  
  -- | When a task splits using WorkItemStatus.dynamic/source/split, this message describes the two parts of the split relative to the description of the current task\'s input.
  --
  -- /See:/ 'newDynamicSourceSplit' smart constructor.
  data DynamicSourceSplit = DynamicSourceSplit
    { -- | Primary part (continued to be processed by worker). Specified relative to the previously-current source. Becomes current.
      primary :: (Core.Maybe DerivedSource),
      -- | Residual part (returned to the pool of work). Specified relative to the previously-current source.
      residual :: (Core.Maybe DerivedSource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DynamicSourceSplit' with the minimum fields required to make a request.
  newDynamicSourceSplit ::
    DynamicSourceSplit
  newDynamicSourceSplit =
    DynamicSourceSplit
      { primary = Core.Nothing,
        residual = Core.Nothing
      }
  
  instance Core.FromJSON DynamicSourceSplit where
    parseJSON =
      Core.withObject
        "DynamicSourceSplit"
        ( \o ->
            DynamicSourceSplit
              Core.<$> (o Core..:? "primary")
              Core.<*> (o Core..:? "residual")
        )
  
  instance Core.ToJSON DynamicSourceSplit where
    toJSON DynamicSourceSplit {..} =
      Core.object
        ( Core.catMaybes
            [ ("primary" Core..=) Core.<$> primary,
              ("residual" Core..=) Core.<$> residual
            ]
        )
  
  -- | Describes the environment in which a Dataflow Job runs.
  --
  -- /See:/ 'newEnvironment' smart constructor.
  data Environment = Environment
    { -- | The type of cluster manager API to use. If unknown or unspecified, the service will attempt to choose a reasonable default. This should be in the form of the API service name, e.g. \"compute.googleapis.com\".
      clusterManagerApiService :: (Core.Maybe Core.Text),
      -- | Optional. The dataset for the current project where various workflow related tables are stored. The supported resource type is: Google BigQuery: bigquery.googleapis.com\/{dataset}
      dataset :: (Core.Maybe Core.Text),
      -- | Optional. Any debugging options to be supplied to the job.
      debugOptions :: (Core.Maybe DebugOptions),
      -- | The list of experiments to enable. This field should be used for SDK related experiments and not for service related experiments. The proper field for service related experiments is service_options.
      experiments :: (Core.Maybe [Core.Text]),
      -- | Optional. Which Flexible Resource Scheduling mode to run in.
      flexResourceSchedulingGoal :: (Core.Maybe Environment_FlexResourceSchedulingGoal),
      -- | Experimental settings.
      internalExperiments :: (Core.Maybe Environment_InternalExperiments),
      -- | The Cloud Dataflow SDK pipeline options specified by the user. These options are passed through the service and are used to recreate the SDK pipeline options on the worker in a language agnostic and platform independent way.
      sdkPipelineOptions :: (Core.Maybe Environment_SdkPipelineOptions),
      -- | Optional. Identity to run virtual machines as. Defaults to the default account.
      serviceAccountEmail :: (Core.Maybe Core.Text),
      -- | Optional. If set, contains the Cloud KMS key identifier used to encrypt data at rest, AKA a Customer Managed Encryption Key (CMEK). Format: projects\/PROJECT/ID\/locations\/LOCATION\/keyRings\/KEY/RING\/cryptoKeys\/KEY
      serviceKmsKeyName :: (Core.Maybe Core.Text),
      -- | Optional. The list of service options to enable. This field should be used for service related experiments only. These experiments, when graduating to GA, should be replaced by dedicated fields or become default (i.e. always on).
      serviceOptions :: (Core.Maybe [Core.Text]),
      -- | Output only. The shuffle mode used for the job.
      shuffleMode :: (Core.Maybe Environment_ShuffleMode),
      -- | Optional. Specifies the Streaming Engine message processing guarantees. Reduces cost and latency but might result in duplicate messages committed to storage. Designed to run simple mapping streaming ETL jobs at the lowest cost. For example, Change Data Capture (CDC) to BigQuery is a canonical use case. For more information, see <https://cloud.google.com/dataflow/docs/guides/streaming-modes Set the pipeline streaming mode>.
      streamingMode :: (Core.Maybe Environment_StreamingMode),
      -- | The prefix of the resources the system should use for temporary storage. The system will append the suffix \"\/temp-{JOBNAME} to this resource prefix, where {JOBNAME} is the value of the job/name field. The resulting bucket and object prefix is used as the prefix of the resources used to store temporary data needed during the job execution. NOTE: This will override the value in taskrunner/settings. The supported resource type is: Google Cloud Storage: storage.googleapis.com\/{bucket}\/{object} bucket.storage.googleapis.com\/{object}
      tempStoragePrefix :: (Core.Maybe Core.Text),
      -- | Output only. Whether the job uses the Streaming Engine resource-based billing model.
      useStreamingEngineResourceBasedBilling :: (Core.Maybe Core.Bool),
      -- | A description of the process that generated the request.
      userAgent :: (Core.Maybe Environment_UserAgent),
      -- | A structure describing which components and their versions of the service are required in order to run the job.
      version :: (Core.Maybe Environment_Version),
      -- | The worker pools. At least one \"harness\" worker pool must be specified in order for the job to have workers.
      workerPools :: (Core.Maybe [WorkerPool]),
      -- | Optional. The Compute Engine region (https:\/\/cloud.google.com\/compute\/docs\/regions-zones\/regions-zones) in which worker processing should occur, e.g. \"us-west1\". Mutually exclusive with worker/zone. If neither worker/region nor worker_zone is specified, default to the control plane\'s region.
      workerRegion :: (Core.Maybe Core.Text),
      -- | Optional. The Compute Engine zone (https:\/\/cloud.google.com\/compute\/docs\/regions-zones\/regions-zones) in which worker processing should occur, e.g. \"us-west1-a\". Mutually exclusive with worker/region. If neither worker/region nor worker_zone is specified, a zone in the control plane\'s region is chosen based on available capacity.
      workerZone :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Environment' with the minimum fields required to make a request.
  newEnvironment ::
    Environment
  newEnvironment =
    Environment
      { clusterManagerApiService = Core.Nothing,
        dataset = Core.Nothing,
        debugOptions = Core.Nothing,
        experiments = Core.Nothing,
        flexResourceSchedulingGoal = Core.Nothing,
        internalExperiments = Core.Nothing,
        sdkPipelineOptions = Core.Nothing,
        serviceAccountEmail = Core.Nothing,
        serviceKmsKeyName = Core.Nothing,
        serviceOptions = Core.Nothing,
        shuffleMode = Core.Nothing,
        streamingMode = Core.Nothing,
        tempStoragePrefix = Core.Nothing,
        useStreamingEngineResourceBasedBilling = Core.Nothing,
        userAgent = Core.Nothing,
        version = Core.Nothing,
        workerPools = Core.Nothing,
        workerRegion = Core.Nothing,
        workerZone = Core.Nothing
      }
  
  instance Core.FromJSON Environment where
    parseJSON =
      Core.withObject
        "Environment"
        ( \o ->
            Environment
              Core.<$> (o Core..:? "clusterManagerApiService")
              Core.<*> (o Core..:? "dataset")
              Core.<*> (o Core..:? "debugOptions")
              Core.<*> (o Core..:? "experiments")
              Core.<*> (o Core..:? "flexResourceSchedulingGoal")
              Core.<*> (o Core..:? "internalExperiments")
              Core.<*> (o Core..:? "sdkPipelineOptions")
              Core.<*> (o Core..:? "serviceAccountEmail")
              Core.<*> (o Core..:? "serviceKmsKeyName")
              Core.<*> (o Core..:? "serviceOptions")
              Core.<*> (o Core..:? "shuffleMode")
              Core.<*> (o Core..:? "streamingMode")
              Core.<*> (o Core..:? "tempStoragePrefix")
              Core.<*> (o Core..:? "useStreamingEngineResourceBasedBilling")
              Core.<*> (o Core..:? "userAgent")
              Core.<*> (o Core..:? "version")
              Core.<*> (o Core..:? "workerPools")
              Core.<*> (o Core..:? "workerRegion")
              Core.<*> (o Core..:? "workerZone")
        )
  
  instance Core.ToJSON Environment where
    toJSON Environment {..} =
      Core.object
        ( Core.catMaybes
            [ ("clusterManagerApiService" Core..=)
                Core.<$> clusterManagerApiService,
              ("dataset" Core..=) Core.<$> dataset,
              ("debugOptions" Core..=) Core.<$> debugOptions,
              ("experiments" Core..=) Core.<$> experiments,
              ("flexResourceSchedulingGoal" Core..=)
                Core.<$> flexResourceSchedulingGoal,
              ("internalExperiments" Core..=) Core.<$> internalExperiments,
              ("sdkPipelineOptions" Core..=) Core.<$> sdkPipelineOptions,
              ("serviceAccountEmail" Core..=) Core.<$> serviceAccountEmail,
              ("serviceKmsKeyName" Core..=) Core.<$> serviceKmsKeyName,
              ("serviceOptions" Core..=) Core.<$> serviceOptions,
              ("shuffleMode" Core..=) Core.<$> shuffleMode,
              ("streamingMode" Core..=) Core.<$> streamingMode,
              ("tempStoragePrefix" Core..=) Core.<$> tempStoragePrefix,
              ("useStreamingEngineResourceBasedBilling" Core..=)
                Core.<$> useStreamingEngineResourceBasedBilling,
              ("userAgent" Core..=) Core.<$> userAgent,
              ("version" Core..=) Core.<$> version,
              ("workerPools" Core..=) Core.<$> workerPools,
              ("workerRegion" Core..=) Core.<$> workerRegion,
              ("workerZone" Core..=) Core.<$> workerZone
            ]
        )
  
  -- | Experimental settings.
  --
  -- /See:/ 'newEnvironment_InternalExperiments' smart constructor.
  newtype Environment_InternalExperiments = Environment_InternalExperiments
    { -- | 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 'Environment_InternalExperiments' with the minimum fields required to make a request.
  newEnvironment_InternalExperiments ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Environment_InternalExperiments
  newEnvironment_InternalExperiments additional =
    Environment_InternalExperiments {additional = additional}
  
  instance Core.FromJSON Environment_InternalExperiments where
    parseJSON =
      Core.withObject
        "Environment_InternalExperiments"
        ( \o ->
            Environment_InternalExperiments Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON Environment_InternalExperiments where
    toJSON Environment_InternalExperiments {..} = Core.toJSON additional
  
  -- | The Cloud Dataflow SDK pipeline options specified by the user. These options are passed through the service and are used to recreate the SDK pipeline options on the worker in a language agnostic and platform independent way.
  --
  -- /See:/ 'newEnvironment_SdkPipelineOptions' smart constructor.
  newtype Environment_SdkPipelineOptions = Environment_SdkPipelineOptions
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Environment_SdkPipelineOptions' with the minimum fields required to make a request.
  newEnvironment_SdkPipelineOptions ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Environment_SdkPipelineOptions
  newEnvironment_SdkPipelineOptions additional =
    Environment_SdkPipelineOptions {additional = additional}
  
  instance Core.FromJSON Environment_SdkPipelineOptions where
    parseJSON =
      Core.withObject
        "Environment_SdkPipelineOptions"
        ( \o ->
            Environment_SdkPipelineOptions Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON Environment_SdkPipelineOptions where
    toJSON Environment_SdkPipelineOptions {..} = Core.toJSON additional
  
  -- | A description of the process that generated the request.
  --
  -- /See:/ 'newEnvironment_UserAgent' smart constructor.
  newtype Environment_UserAgent = Environment_UserAgent
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Environment_UserAgent' with the minimum fields required to make a request.
  newEnvironment_UserAgent ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Environment_UserAgent
  newEnvironment_UserAgent additional =
    Environment_UserAgent {additional = additional}
  
  instance Core.FromJSON Environment_UserAgent where
    parseJSON =
      Core.withObject
        "Environment_UserAgent"
        (\o -> Environment_UserAgent Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Environment_UserAgent where
    toJSON Environment_UserAgent {..} = Core.toJSON additional
  
  -- | A structure describing which components and their versions of the service are required in order to run the job.
  --
  -- /See:/ 'newEnvironment_Version' smart constructor.
  newtype Environment_Version = Environment_Version
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Environment_Version' with the minimum fields required to make a request.
  newEnvironment_Version ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Environment_Version
  newEnvironment_Version additional =
    Environment_Version {additional = additional}
  
  instance Core.FromJSON Environment_Version where
    parseJSON =
      Core.withObject
        "Environment_Version"
        (\o -> Environment_Version Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Environment_Version where
    toJSON Environment_Version {..} = Core.toJSON additional
  
  -- | A message describing the state of a particular execution stage.
  --
  -- /See:/ 'newExecutionStageState' smart constructor.
  data ExecutionStageState = ExecutionStageState
    { -- | The time at which the stage transitioned to this state.
      currentStateTime :: (Core.Maybe Core.DateTime),
      -- | The name of the execution stage.
      executionStageName :: (Core.Maybe Core.Text),
      -- | Executions stage states allow the same set of values as JobState.
      executionStageState :: (Core.Maybe ExecutionStageState_ExecutionStageState)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExecutionStageState' with the minimum fields required to make a request.
  newExecutionStageState ::
    ExecutionStageState
  newExecutionStageState =
    ExecutionStageState
      { currentStateTime = Core.Nothing,
        executionStageName = Core.Nothing,
        executionStageState = Core.Nothing
      }
  
  instance Core.FromJSON ExecutionStageState where
    parseJSON =
      Core.withObject
        "ExecutionStageState"
        ( \o ->
            ExecutionStageState
              Core.<$> (o Core..:? "currentStateTime")
              Core.<*> (o Core..:? "executionStageName")
              Core.<*> (o Core..:? "executionStageState")
        )
  
  instance Core.ToJSON ExecutionStageState where
    toJSON ExecutionStageState {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentStateTime" Core..=) Core.<$> currentStateTime,
              ("executionStageName" Core..=) Core.<$> executionStageName,
              ("executionStageState" Core..=) Core.<$> executionStageState
            ]
        )
  
  -- | Description of the composing transforms, names\/ids, and input\/outputs of a stage of execution. Some composing transforms and sources may have been generated by the Dataflow service during execution planning.
  --
  -- /See:/ 'newExecutionStageSummary' smart constructor.
  data ExecutionStageSummary = ExecutionStageSummary
    { -- | Collections produced and consumed by component transforms of this stage.
      componentSource :: (Core.Maybe [ComponentSource]),
      -- | Transforms that comprise this execution stage.
      componentTransform :: (Core.Maybe [ComponentTransform]),
      -- | Dataflow service generated id for this stage.
      id :: (Core.Maybe Core.Text),
      -- | Input sources for this stage.
      inputSource :: (Core.Maybe [StageSource]),
      -- | Type of transform this stage is executing.
      kind :: (Core.Maybe ExecutionStageSummary_Kind),
      -- | Dataflow service generated name for this stage.
      name :: (Core.Maybe Core.Text),
      -- | Output sources for this stage.
      outputSource :: (Core.Maybe [StageSource]),
      -- | Other stages that must complete before this stage can run.
      prerequisiteStage :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ExecutionStageSummary' with the minimum fields required to make a request.
  newExecutionStageSummary ::
    ExecutionStageSummary
  newExecutionStageSummary =
    ExecutionStageSummary
      { componentSource = Core.Nothing,
        componentTransform = Core.Nothing,
        id = Core.Nothing,
        inputSource = Core.Nothing,
        kind = Core.Nothing,
        name = Core.Nothing,
        outputSource = Core.Nothing,
        prerequisiteStage = Core.Nothing
      }
  
  instance Core.FromJSON ExecutionStageSummary where
    parseJSON =
      Core.withObject
        "ExecutionStageSummary"
        ( \o ->
            ExecutionStageSummary
              Core.<$> (o Core..:? "componentSource")
              Core.<*> (o Core..:? "componentTransform")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "inputSource")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "outputSource")
              Core.<*> (o Core..:? "prerequisiteStage")
        )
  
  instance Core.ToJSON ExecutionStageSummary where
    toJSON ExecutionStageSummary {..} =
      Core.object
        ( Core.catMaybes
            [ ("componentSource" Core..=) Core.<$> componentSource,
              ("componentTransform" Core..=) Core.<$> componentTransform,
              ("id" Core..=) Core.<$> id,
              ("inputSource" Core..=) Core.<$> inputSource,
              ("kind" Core..=) Core.<$> kind,
              ("name" Core..=) Core.<$> name,
              ("outputSource" Core..=) Core.<$> outputSource,
              ("prerequisiteStage" Core..=) Core.<$> prerequisiteStage
            ]
        )
  
  -- | Indicates which [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) failed to respond to a request for data.
  --
  -- /See:/ 'newFailedLocation' smart constructor.
  newtype FailedLocation = FailedLocation
    { -- | The name of the [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that failed to respond.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FailedLocation' with the minimum fields required to make a request.
  newFailedLocation ::
    FailedLocation
  newFailedLocation = FailedLocation {name = Core.Nothing}
  
  instance Core.FromJSON FailedLocation where
    parseJSON =
      Core.withObject
        "FailedLocation"
        (\o -> FailedLocation Core.<$> (o Core..:? "name"))
  
  instance Core.ToJSON FailedLocation where
    toJSON FailedLocation {..} =
      Core.object (Core.catMaybes [("name" Core..=) Core.<$> name])
  
  -- | Metadata for a File connector used by the job.
  --
  -- /See:/ 'newFileIODetails' smart constructor.
  newtype FileIODetails = FileIODetails
    { -- | File Pattern used to access files by the connector.
      filePattern :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FileIODetails' with the minimum fields required to make a request.
  newFileIODetails ::
    FileIODetails
  newFileIODetails = FileIODetails {filePattern = Core.Nothing}
  
  instance Core.FromJSON FileIODetails where
    parseJSON =
      Core.withObject
        "FileIODetails"
        (\o -> FileIODetails Core.<$> (o Core..:? "filePattern"))
  
  instance Core.ToJSON FileIODetails where
    toJSON FileIODetails {..} =
      Core.object
        (Core.catMaybes [("filePattern" Core..=) Core.<$> filePattern])
  
  -- | An instruction that copies its inputs (zero or more) to its (single) output.
  --
  -- /See:/ 'newFlattenInstruction' smart constructor.
  newtype FlattenInstruction = FlattenInstruction
    { -- | Describes the inputs to the flatten instruction.
      inputs :: (Core.Maybe [InstructionInput])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FlattenInstruction' with the minimum fields required to make a request.
  newFlattenInstruction ::
    FlattenInstruction
  newFlattenInstruction = FlattenInstruction {inputs = Core.Nothing}
  
  instance Core.FromJSON FlattenInstruction where
    parseJSON =
      Core.withObject
        "FlattenInstruction"
        (\o -> FlattenInstruction Core.<$> (o Core..:? "inputs"))
  
  instance Core.ToJSON FlattenInstruction where
    toJSON FlattenInstruction {..} =
      Core.object (Core.catMaybes [("inputs" Core..=) Core.<$> inputs])
  
  -- | The environment values to be set at runtime for flex template.
  --
  -- /See:/ 'newFlexTemplateRuntimeEnvironment' smart constructor.
  data FlexTemplateRuntimeEnvironment = FlexTemplateRuntimeEnvironment
    { -- | Additional experiment flags for the job.
      additionalExperiments :: (Core.Maybe [Core.Text]),
      -- | Additional user labels to be specified for the job. Keys and values must follow the restrictions specified in the <https://cloud.google.com/compute/docs/labeling-resources#restrictions labeling restrictions> page. An object containing a list of \"key\": value pairs. Example: { \"name\": \"wrench\", \"mass\": \"1kg\", \"count\": \"3\" }.
      additionalUserLabels :: (Core.Maybe FlexTemplateRuntimeEnvironment_AdditionalUserLabels),
      -- | The algorithm to use for autoscaling
      autoscalingAlgorithm :: (Core.Maybe FlexTemplateRuntimeEnvironment_AutoscalingAlgorithm),
      -- | Worker disk size, in gigabytes.
      diskSizeGb :: (Core.Maybe Core.Int32),
      -- | If true, when processing time is spent almost entirely on garbage collection (GC), saves a heap dump before ending the thread or process. If false, ends the thread or process without saving a heap dump. Does not save a heap dump when the Java Virtual Machine (JVM) has an out of memory error during processing. The location of the heap file is either echoed back to the user, or the user is given the opportunity to download the heap file.
      dumpHeapOnOom :: (Core.Maybe Core.Bool),
      -- | If true serial port logging will be enabled for the launcher VM.
      enableLauncherVmSerialPortLogging :: (Core.Maybe Core.Bool),
      -- | Whether to enable Streaming Engine for the job.
      enableStreamingEngine :: (Core.Maybe Core.Bool),
      -- | Set FlexRS goal for the job. https:\/\/cloud.google.com\/dataflow\/docs\/guides\/flexrs
      flexrsGoal :: (Core.Maybe FlexTemplateRuntimeEnvironment_FlexrsGoal),
      -- | Configuration for VM IPs.
      ipConfiguration :: (Core.Maybe FlexTemplateRuntimeEnvironment_IpConfiguration),
      -- | Name for the Cloud KMS key for the job. Key format is: projects\/\/locations\/\/keyRings\/\/cryptoKeys\/
      kmsKeyName :: (Core.Maybe Core.Text),
      -- | The machine type to use for launching the job. The default is n1-standard-1.
      launcherMachineType :: (Core.Maybe Core.Text),
      -- | The machine type to use for the job. Defaults to the value from the template if not specified.
      machineType :: (Core.Maybe Core.Text),
      -- | The maximum number of Google Compute Engine instances to be made available to your pipeline during execution, from 1 to 1000.
      maxWorkers :: (Core.Maybe Core.Int32),
      -- | Network to which VMs will be assigned. If empty or unspecified, the service will use the network \"default\".
      network :: (Core.Maybe Core.Text),
      -- | The initial number of Google Compute Engine instances for the job.
      numWorkers :: (Core.Maybe Core.Int32),
      -- | Cloud Storage bucket (directory) to upload heap dumps to. Enabling this field implies that @dump_heap_on_oom@ is set to true.
      saveHeapDumpsToGcsPath :: (Core.Maybe Core.Text),
      -- | Docker registry location of container image to use for the \'worker harness. Default is the container for the version of the SDK. Note this field is only valid for portable pipelines.
      sdkContainerImage :: (Core.Maybe Core.Text),
      -- | The email address of the service account to run the job as.
      serviceAccountEmail :: (Core.Maybe Core.Text),
      -- | The Cloud Storage path for staging local files. Must be a valid Cloud Storage URL, beginning with @gs:\/\/@.
      stagingLocation :: (Core.Maybe Core.Text),
      -- | Optional. Specifies the Streaming Engine message processing guarantees. Reduces cost and latency but might result in duplicate messages committed to storage. Designed to run simple mapping streaming ETL jobs at the lowest cost. For example, Change Data Capture (CDC) to BigQuery is a canonical use case. For more information, see <https://cloud.google.com/dataflow/docs/guides/streaming-modes Set the pipeline streaming mode>.
      streamingMode :: (Core.Maybe FlexTemplateRuntimeEnvironment_StreamingMode),
      -- | Subnetwork to which VMs will be assigned, if desired. You can specify a subnetwork using either a complete URL or an abbreviated path. Expected to be of the form \"https:\/\/www.googleapis.com\/compute\/v1\/projects\/HOST/PROJECT/ID\/regions\/REGION\/subnetworks\/SUBNETWORK\" or \"regions\/REGION\/subnetworks\/SUBNETWORK\". If the subnetwork is located in a Shared VPC network, you must use the complete URL.
      subnetwork :: (Core.Maybe Core.Text),
      -- | The Cloud Storage path to use for temporary files. Must be a valid Cloud Storage URL, beginning with @gs:\/\/@.
      tempLocation :: (Core.Maybe Core.Text),
      -- | The Compute Engine region (https:\/\/cloud.google.com\/compute\/docs\/regions-zones\/regions-zones) in which worker processing should occur, e.g. \"us-west1\". Mutually exclusive with worker/zone. If neither worker/region nor worker_zone is specified, default to the control plane\'s region.
      workerRegion :: (Core.Maybe Core.Text),
      -- | The Compute Engine zone (https:\/\/cloud.google.com\/compute\/docs\/regions-zones\/regions-zones) in which worker processing should occur, e.g. \"us-west1-a\". Mutually exclusive with worker/region. If neither worker/region nor worker_zone is specified, a zone in the control plane\'s region is chosen based on available capacity. If both @worker_zone@ and @zone@ are set, @worker_zone@ takes precedence.
      workerZone :: (Core.Maybe Core.Text),
      -- | The Compute Engine <https://cloud.google.com/compute/docs/regions-zones/regions-zones availability zone> for launching worker instances to run your pipeline. In the future, worker_zone will take precedence.
      zone :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FlexTemplateRuntimeEnvironment' with the minimum fields required to make a request.
  newFlexTemplateRuntimeEnvironment ::
    FlexTemplateRuntimeEnvironment
  newFlexTemplateRuntimeEnvironment =
    FlexTemplateRuntimeEnvironment
      { additionalExperiments =
          Core.Nothing,
        additionalUserLabels = Core.Nothing,
        autoscalingAlgorithm = Core.Nothing,
        diskSizeGb = Core.Nothing,
        dumpHeapOnOom = Core.Nothing,
        enableLauncherVmSerialPortLogging = Core.Nothing,
        enableStreamingEngine = Core.Nothing,
        flexrsGoal = Core.Nothing,
        ipConfiguration = Core.Nothing,
        kmsKeyName = Core.Nothing,
        launcherMachineType = Core.Nothing,
        machineType = Core.Nothing,
        maxWorkers = Core.Nothing,
        network = Core.Nothing,
        numWorkers = Core.Nothing,
        saveHeapDumpsToGcsPath = Core.Nothing,
        sdkContainerImage = Core.Nothing,
        serviceAccountEmail = Core.Nothing,
        stagingLocation = Core.Nothing,
        streamingMode = Core.Nothing,
        subnetwork = Core.Nothing,
        tempLocation = Core.Nothing,
        workerRegion = Core.Nothing,
        workerZone = Core.Nothing,
        zone = Core.Nothing
      }
  
  instance Core.FromJSON FlexTemplateRuntimeEnvironment where
    parseJSON =
      Core.withObject
        "FlexTemplateRuntimeEnvironment"
        ( \o ->
            FlexTemplateRuntimeEnvironment
              Core.<$> (o Core..:? "additionalExperiments")
              Core.<*> (o Core..:? "additionalUserLabels")
              Core.<*> (o Core..:? "autoscalingAlgorithm")
              Core.<*> (o Core..:? "diskSizeGb")
              Core.<*> (o Core..:? "dumpHeapOnOom")
              Core.<*> (o Core..:? "enableLauncherVmSerialPortLogging")
              Core.<*> (o Core..:? "enableStreamingEngine")
              Core.<*> (o Core..:? "flexrsGoal")
              Core.<*> (o Core..:? "ipConfiguration")
              Core.<*> (o Core..:? "kmsKeyName")
              Core.<*> (o Core..:? "launcherMachineType")
              Core.<*> (o Core..:? "machineType")
              Core.<*> (o Core..:? "maxWorkers")
              Core.<*> (o Core..:? "network")
              Core.<*> (o Core..:? "numWorkers")
              Core.<*> (o Core..:? "saveHeapDumpsToGcsPath")
              Core.<*> (o Core..:? "sdkContainerImage")
              Core.<*> (o Core..:? "serviceAccountEmail")
              Core.<*> (o Core..:? "stagingLocation")
              Core.<*> (o Core..:? "streamingMode")
              Core.<*> (o Core..:? "subnetwork")
              Core.<*> (o Core..:? "tempLocation")
              Core.<*> (o Core..:? "workerRegion")
              Core.<*> (o Core..:? "workerZone")
              Core.<*> (o Core..:? "zone")
        )
  
  instance Core.ToJSON FlexTemplateRuntimeEnvironment where
    toJSON FlexTemplateRuntimeEnvironment {..} =
      Core.object
        ( Core.catMaybes
            [ ("additionalExperiments" Core..=) Core.<$> additionalExperiments,
              ("additionalUserLabels" Core..=) Core.<$> additionalUserLabels,
              ("autoscalingAlgorithm" Core..=) Core.<$> autoscalingAlgorithm,
              ("diskSizeGb" Core..=) Core.<$> diskSizeGb,
              ("dumpHeapOnOom" Core..=) Core.<$> dumpHeapOnOom,
              ("enableLauncherVmSerialPortLogging" Core..=)
                Core.<$> enableLauncherVmSerialPortLogging,
              ("enableStreamingEngine" Core..=) Core.<$> enableStreamingEngine,
              ("flexrsGoal" Core..=) Core.<$> flexrsGoal,
              ("ipConfiguration" Core..=) Core.<$> ipConfiguration,
              ("kmsKeyName" Core..=) Core.<$> kmsKeyName,
              ("launcherMachineType" Core..=) Core.<$> launcherMachineType,
              ("machineType" Core..=) Core.<$> machineType,
              ("maxWorkers" Core..=) Core.<$> maxWorkers,
              ("network" Core..=) Core.<$> network,
              ("numWorkers" Core..=) Core.<$> numWorkers,
              ("saveHeapDumpsToGcsPath" Core..=) Core.<$> saveHeapDumpsToGcsPath,
              ("sdkContainerImage" Core..=) Core.<$> sdkContainerImage,
              ("serviceAccountEmail" Core..=) Core.<$> serviceAccountEmail,
              ("stagingLocation" Core..=) Core.<$> stagingLocation,
              ("streamingMode" Core..=) Core.<$> streamingMode,
              ("subnetwork" Core..=) Core.<$> subnetwork,
              ("tempLocation" Core..=) Core.<$> tempLocation,
              ("workerRegion" Core..=) Core.<$> workerRegion,
              ("workerZone" Core..=) Core.<$> workerZone,
              ("zone" Core..=) Core.<$> zone
            ]
        )
  
  -- | Additional user labels to be specified for the job. Keys and values must follow the restrictions specified in the <https://cloud.google.com/compute/docs/labeling-resources#restrictions labeling restrictions> page. An object containing a list of \"key\": value pairs. Example: { \"name\": \"wrench\", \"mass\": \"1kg\", \"count\": \"3\" }.
  --
  -- /See:/ 'newFlexTemplateRuntimeEnvironment_AdditionalUserLabels' smart constructor.
  newtype FlexTemplateRuntimeEnvironment_AdditionalUserLabels = FlexTemplateRuntimeEnvironment_AdditionalUserLabels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FlexTemplateRuntimeEnvironment_AdditionalUserLabels' with the minimum fields required to make a request.
  newFlexTemplateRuntimeEnvironment_AdditionalUserLabels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    FlexTemplateRuntimeEnvironment_AdditionalUserLabels
  newFlexTemplateRuntimeEnvironment_AdditionalUserLabels additional =
    FlexTemplateRuntimeEnvironment_AdditionalUserLabels
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      FlexTemplateRuntimeEnvironment_AdditionalUserLabels
    where
    parseJSON =
      Core.withObject
        "FlexTemplateRuntimeEnvironment_AdditionalUserLabels"
        ( \o ->
            FlexTemplateRuntimeEnvironment_AdditionalUserLabels
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance
    Core.ToJSON
      FlexTemplateRuntimeEnvironment_AdditionalUserLabels
    where
    toJSON FlexTemplateRuntimeEnvironment_AdditionalUserLabels {..} =
      Core.toJSON additional
  
  -- | A metric value representing a list of floating point numbers.
  --
  -- /See:/ 'newFloatingPointList' smart constructor.
  newtype FloatingPointList = FloatingPointList
    { -- | Elements of the list.
      elements :: (Core.Maybe [Core.Double])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FloatingPointList' with the minimum fields required to make a request.
  newFloatingPointList ::
    FloatingPointList
  newFloatingPointList = FloatingPointList {elements = Core.Nothing}
  
  instance Core.FromJSON FloatingPointList where
    parseJSON =
      Core.withObject
        "FloatingPointList"
        (\o -> FloatingPointList Core.<$> (o Core..:? "elements"))
  
  instance Core.ToJSON FloatingPointList where
    toJSON FloatingPointList {..} =
      Core.object
        (Core.catMaybes [("elements" Core..=) Core.<$> elements])
  
  -- | A representation of a floating point mean metric contribution.
  --
  -- /See:/ 'newFloatingPointMean' smart constructor.
  data FloatingPointMean = FloatingPointMean
    { -- | The number of values being aggregated.
      count :: (Core.Maybe SplitInt64),
      -- | The sum of all values being aggregated.
      sum :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FloatingPointMean' with the minimum fields required to make a request.
  newFloatingPointMean ::
    FloatingPointMean
  newFloatingPointMean =
    FloatingPointMean {count = Core.Nothing, sum = Core.Nothing}
  
  instance Core.FromJSON FloatingPointMean where
    parseJSON =
      Core.withObject
        "FloatingPointMean"
        ( \o ->
            FloatingPointMean
              Core.<$> (o Core..:? "count")
              Core.<*> (o Core..:? "sum")
        )
  
  instance Core.ToJSON FloatingPointMean where
    toJSON FloatingPointMean {..} =
      Core.object
        ( Core.catMaybes
            [("count" Core..=) Core.<$> count, ("sum" Core..=) Core.<$> sum]
        )
  
  -- | Information about the GPU usage on the worker.
  --
  -- /See:/ 'newGPUUsage' smart constructor.
  data GPUUsage = GPUUsage
    { -- | Required. Timestamp of the measurement.
      timestamp :: (Core.Maybe Core.DateTime),
      -- | Required. Utilization info about the GPU.
      utilization :: (Core.Maybe GPUUtilization)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GPUUsage' with the minimum fields required to make a request.
  newGPUUsage ::
    GPUUsage
  newGPUUsage =
    GPUUsage {timestamp = Core.Nothing, utilization = Core.Nothing}
  
  instance Core.FromJSON GPUUsage where
    parseJSON =
      Core.withObject
        "GPUUsage"
        ( \o ->
            GPUUsage
              Core.<$> (o Core..:? "timestamp")
              Core.<*> (o Core..:? "utilization")
        )
  
  instance Core.ToJSON GPUUsage where
    toJSON GPUUsage {..} =
      Core.object
        ( Core.catMaybes
            [ ("timestamp" Core..=) Core.<$> timestamp,
              ("utilization" Core..=) Core.<$> utilization
            ]
        )
  
  -- | Utilization details about the GPU.
  --
  -- /See:/ 'newGPUUtilization' smart constructor.
  newtype GPUUtilization = GPUUtilization
    { -- | Required. GPU utilization rate of any kernel over the last sample period in the range of [0, 1].
      rate :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GPUUtilization' with the minimum fields required to make a request.
  newGPUUtilization ::
    GPUUtilization
  newGPUUtilization = GPUUtilization {rate = Core.Nothing}
  
  instance Core.FromJSON GPUUtilization where
    parseJSON =
      Core.withObject
        "GPUUtilization"
        (\o -> GPUUtilization Core.<$> (o Core..:? "rate"))
  
  instance Core.ToJSON GPUUtilization where
    toJSON GPUUtilization {..} =
      Core.object (Core.catMaybes [("rate" Core..=) Core.<$> rate])
  
  -- | Request to get updated debug configuration for component.
  --
  -- /See:/ 'newGetDebugConfigRequest' smart constructor.
  data GetDebugConfigRequest = GetDebugConfigRequest
    { -- | The internal component id for which debug configuration is requested.
      componentId :: (Core.Maybe Core.Text),
      -- | The [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that contains the job specified by job_id.
      location :: (Core.Maybe Core.Text),
      -- | The worker id, i.e., VM hostname.
      workerId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GetDebugConfigRequest' with the minimum fields required to make a request.
  newGetDebugConfigRequest ::
    GetDebugConfigRequest
  newGetDebugConfigRequest =
    GetDebugConfigRequest
      { componentId = Core.Nothing,
        location = Core.Nothing,
        workerId = Core.Nothing
      }
  
  instance Core.FromJSON GetDebugConfigRequest where
    parseJSON =
      Core.withObject
        "GetDebugConfigRequest"
        ( \o ->
            GetDebugConfigRequest
              Core.<$> (o Core..:? "componentId")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "workerId")
        )
  
  instance Core.ToJSON GetDebugConfigRequest where
    toJSON GetDebugConfigRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("componentId" Core..=) Core.<$> componentId,
              ("location" Core..=) Core.<$> location,
              ("workerId" Core..=) Core.<$> workerId
            ]
        )
  
  -- | Response to a get debug configuration request.
  --
  -- /See:/ 'newGetDebugConfigResponse' smart constructor.
  newtype GetDebugConfigResponse = GetDebugConfigResponse
    { -- | The encoded debug configuration for the requested component.
      config :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GetDebugConfigResponse' with the minimum fields required to make a request.
  newGetDebugConfigResponse ::
    GetDebugConfigResponse
  newGetDebugConfigResponse =
    GetDebugConfigResponse {config = Core.Nothing}
  
  instance Core.FromJSON GetDebugConfigResponse where
    parseJSON =
      Core.withObject
        "GetDebugConfigResponse"
        (\o -> GetDebugConfigResponse Core.<$> (o Core..:? "config"))
  
  instance Core.ToJSON GetDebugConfigResponse where
    toJSON GetDebugConfigResponse {..} =
      Core.object (Core.catMaybes [("config" Core..=) Core.<$> config])
  
  -- | The response to a GetTemplate request.
  --
  -- /See:/ 'newGetTemplateResponse' smart constructor.
  data GetTemplateResponse = GetTemplateResponse
    { -- | The template metadata describing the template name, available parameters, etc.
      metadata :: (Core.Maybe TemplateMetadata),
      -- | Describes the runtime metadata with SDKInfo and available parameters.
      runtimeMetadata :: (Core.Maybe RuntimeMetadata),
      -- | The status of the get template request. Any problems with the request will be indicated in the error_details.
      status :: (Core.Maybe Status),
      -- | Template Type.
      templateType :: (Core.Maybe GetTemplateResponse_TemplateType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GetTemplateResponse' with the minimum fields required to make a request.
  newGetTemplateResponse ::
    GetTemplateResponse
  newGetTemplateResponse =
    GetTemplateResponse
      { metadata = Core.Nothing,
        runtimeMetadata = Core.Nothing,
        status = Core.Nothing,
        templateType = Core.Nothing
      }
  
  instance Core.FromJSON GetTemplateResponse where
    parseJSON =
      Core.withObject
        "GetTemplateResponse"
        ( \o ->
            GetTemplateResponse
              Core.<$> (o Core..:? "metadata")
              Core.<*> (o Core..:? "runtimeMetadata")
              Core.<*> (o Core..:? "status")
              Core.<*> (o Core..:? "templateType")
        )
  
  instance Core.ToJSON GetTemplateResponse where
    toJSON GetTemplateResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("metadata" Core..=) Core.<$> metadata,
              ("runtimeMetadata" Core..=) Core.<$> runtimeMetadata,
              ("status" Core..=) Core.<$> status,
              ("templateType" Core..=) Core.<$> templateType
            ]
        )
  
  -- | Histogram of value counts for a distribution. Buckets have an inclusive lower bound and exclusive upper bound and use \"1,2,5 bucketing\": The first bucket range is from [0,1) and all subsequent bucket boundaries are powers of ten multiplied by 1, 2, or 5. Thus, bucket boundaries are 0, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, ... Negative values are not supported.
  --
  -- /See:/ 'newHistogram' smart constructor.
  data Histogram = Histogram
    { -- | Counts of values in each bucket. For efficiency, prefix and trailing buckets with count = 0 are elided. Buckets can store the full range of values of an unsigned long, with ULLONG_MAX falling into the 59th bucket with range [1e19, 2e19).
      bucketCounts :: (Core.Maybe [Core.Int64]),
      -- | Starting index of first stored bucket. The non-inclusive upper-bound of the ith bucket is given by: pow(10,(i-first/bucket/offset)\/3) * (1,2,5)[(i-first/bucket/offset)%3]
      firstBucketOffset :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Histogram' with the minimum fields required to make a request.
  newHistogram ::
    Histogram
  newHistogram =
    Histogram
      { bucketCounts = Core.Nothing,
        firstBucketOffset = Core.Nothing
      }
  
  instance Core.FromJSON Histogram where
    parseJSON =
      Core.withObject
        "Histogram"
        ( \o ->
            Histogram
              Core.<$> ( o
                           Core..:? "bucketCounts"
                           Core.<&> Core.fmap (Core.fmap Core.fromAsText)
                       )
              Core.<*> (o Core..:? "firstBucketOffset")
        )
  
  instance Core.ToJSON Histogram where
    toJSON Histogram {..} =
      Core.object
        ( Core.catMaybes
            [ ("bucketCounts" Core..=)
                Core.. Core.fmap Core.AsText
                Core.<$> bucketCounts,
              ("firstBucketOffset" Core..=) Core.<$> firstBucketOffset
            ]
        )
  
  -- | Information useful for debugging a hot key detection.
  --
  -- /See:/ 'newHotKeyDebuggingInfo' smart constructor.
  newtype HotKeyDebuggingInfo = HotKeyDebuggingInfo
    { -- | Debugging information for each detected hot key. Keyed by a hash of the key.
      detectedHotKeys :: (Core.Maybe HotKeyDebuggingInfo_DetectedHotKeys)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HotKeyDebuggingInfo' with the minimum fields required to make a request.
  newHotKeyDebuggingInfo ::
    HotKeyDebuggingInfo
  newHotKeyDebuggingInfo =
    HotKeyDebuggingInfo {detectedHotKeys = Core.Nothing}
  
  instance Core.FromJSON HotKeyDebuggingInfo where
    parseJSON =
      Core.withObject
        "HotKeyDebuggingInfo"
        ( \o ->
            HotKeyDebuggingInfo Core.<$> (o Core..:? "detectedHotKeys")
        )
  
  instance Core.ToJSON HotKeyDebuggingInfo where
    toJSON HotKeyDebuggingInfo {..} =
      Core.object
        ( Core.catMaybes
            [("detectedHotKeys" Core..=) Core.<$> detectedHotKeys]
        )
  
  -- | Debugging information for each detected hot key. Keyed by a hash of the key.
  --
  -- /See:/ 'newHotKeyDebuggingInfo_DetectedHotKeys' smart constructor.
  newtype HotKeyDebuggingInfo_DetectedHotKeys = HotKeyDebuggingInfo_DetectedHotKeys
    { additional :: (Core.HashMap Core.Text HotKeyInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HotKeyDebuggingInfo_DetectedHotKeys' with the minimum fields required to make a request.
  newHotKeyDebuggingInfo_DetectedHotKeys ::
    -- |  See 'additional'.
    Core.HashMap Core.Text HotKeyInfo ->
    HotKeyDebuggingInfo_DetectedHotKeys
  newHotKeyDebuggingInfo_DetectedHotKeys additional =
    HotKeyDebuggingInfo_DetectedHotKeys {additional = additional}
  
  instance Core.FromJSON HotKeyDebuggingInfo_DetectedHotKeys where
    parseJSON =
      Core.withObject
        "HotKeyDebuggingInfo_DetectedHotKeys"
        ( \o ->
            HotKeyDebuggingInfo_DetectedHotKeys
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON HotKeyDebuggingInfo_DetectedHotKeys where
    toJSON HotKeyDebuggingInfo_DetectedHotKeys {..} =
      Core.toJSON additional
  
  -- | Proto describing a hot key detected on a given WorkItem.
  --
  -- /See:/ 'newHotKeyDetection' smart constructor.
  data HotKeyDetection = HotKeyDetection
    { -- | The age of the hot key measured from when it was first detected.
      hotKeyAge :: (Core.Maybe Core.Duration),
      -- | System-defined name of the step containing this hot key. Unique across the workflow.
      systemName :: (Core.Maybe Core.Text),
      -- | User-provided name of the step that contains this hot key.
      userStepName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HotKeyDetection' with the minimum fields required to make a request.
  newHotKeyDetection ::
    HotKeyDetection
  newHotKeyDetection =
    HotKeyDetection
      { hotKeyAge = Core.Nothing,
        systemName = Core.Nothing,
        userStepName = Core.Nothing
      }
  
  instance Core.FromJSON HotKeyDetection where
    parseJSON =
      Core.withObject
        "HotKeyDetection"
        ( \o ->
            HotKeyDetection
              Core.<$> (o Core..:? "hotKeyAge")
              Core.<*> (o Core..:? "systemName")
              Core.<*> (o Core..:? "userStepName")
        )
  
  instance Core.ToJSON HotKeyDetection where
    toJSON HotKeyDetection {..} =
      Core.object
        ( Core.catMaybes
            [ ("hotKeyAge" Core..=) Core.<$> hotKeyAge,
              ("systemName" Core..=) Core.<$> systemName,
              ("userStepName" Core..=) Core.<$> userStepName
            ]
        )
  
  -- | Information about a hot key.
  --
  -- /See:/ 'newHotKeyInfo' smart constructor.
  data HotKeyInfo = HotKeyInfo
    { -- | The age of the hot key measured from when it was first detected.
      hotKeyAge :: (Core.Maybe Core.Duration),
      -- | A detected hot key that is causing limited parallelism. This field will be populated only if the following flag is set to true: \"--enable/hot/key_logging\".
      key :: (Core.Maybe Core.Text),
      -- | If true, then the above key is truncated and cannot be deserialized. This occurs if the key above is populated and the key size is >5MB.
      keyTruncated :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HotKeyInfo' with the minimum fields required to make a request.
  newHotKeyInfo ::
    HotKeyInfo
  newHotKeyInfo =
    HotKeyInfo
      { hotKeyAge = Core.Nothing,
        key = Core.Nothing,
        keyTruncated = Core.Nothing
      }
  
  instance Core.FromJSON HotKeyInfo where
    parseJSON =
      Core.withObject
        "HotKeyInfo"
        ( \o ->
            HotKeyInfo
              Core.<$> (o Core..:? "hotKeyAge")
              Core.<*> (o Core..:? "key")
              Core.<*> (o Core..:? "keyTruncated")
        )
  
  instance Core.ToJSON HotKeyInfo where
    toJSON HotKeyInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("hotKeyAge" Core..=) Core.<$> hotKeyAge,
              ("key" Core..=) Core.<$> key,
              ("keyTruncated" Core..=) Core.<$> keyTruncated
            ]
        )
  
  -- | An input of an instruction, as a reference to an output of a producer instruction.
  --
  -- /See:/ 'newInstructionInput' smart constructor.
  data InstructionInput = InstructionInput
    { -- | The output index (origin zero) within the producer.
      outputNum :: (Core.Maybe Core.Int32),
      -- | The index (origin zero) of the parallel instruction that produces the output to be consumed by this input. This index is relative to the list of instructions in this input\'s instruction\'s containing MapTask.
      producerInstructionIndex :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'InstructionInput' with the minimum fields required to make a request.
  newInstructionInput ::
    InstructionInput
  newInstructionInput =
    InstructionInput
      { outputNum = Core.Nothing,
        producerInstructionIndex = Core.Nothing
      }
  
  instance Core.FromJSON InstructionInput where
    parseJSON =
      Core.withObject
        "InstructionInput"
        ( \o ->
            InstructionInput
              Core.<$> (o Core..:? "outputNum")
              Core.<*> (o Core..:? "producerInstructionIndex")
        )
  
  instance Core.ToJSON InstructionInput where
    toJSON InstructionInput {..} =
      Core.object
        ( Core.catMaybes
            [ ("outputNum" Core..=) Core.<$> outputNum,
              ("producerInstructionIndex" Core..=)
                Core.<$> producerInstructionIndex
            ]
        )
  
  -- | An output of an instruction.
  --
  -- /See:/ 'newInstructionOutput' smart constructor.
  data InstructionOutput = InstructionOutput
    { -- | The codec to use to encode data being written via this output.
      codec :: (Core.Maybe InstructionOutput_Codec),
      -- | The user-provided name of this output.
      name :: (Core.Maybe Core.Text),
      -- | For system-generated byte and mean byte metrics, certain instructions should only report the key size.
      onlyCountKeyBytes :: (Core.Maybe Core.Bool),
      -- | For system-generated byte and mean byte metrics, certain instructions should only report the value size.
      onlyCountValueBytes :: (Core.Maybe Core.Bool),
      -- | System-defined name for this output in the original workflow graph. Outputs that do not contribute to an original instruction do not set this.
      originalName :: (Core.Maybe Core.Text),
      -- | System-defined name of this output. Unique across the workflow.
      systemName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'InstructionOutput' with the minimum fields required to make a request.
  newInstructionOutput ::
    InstructionOutput
  newInstructionOutput =
    InstructionOutput
      { codec = Core.Nothing,
        name = Core.Nothing,
        onlyCountKeyBytes = Core.Nothing,
        onlyCountValueBytes = Core.Nothing,
        originalName = Core.Nothing,
        systemName = Core.Nothing
      }
  
  instance Core.FromJSON InstructionOutput where
    parseJSON =
      Core.withObject
        "InstructionOutput"
        ( \o ->
            InstructionOutput
              Core.<$> (o Core..:? "codec")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "onlyCountKeyBytes")
              Core.<*> (o Core..:? "onlyCountValueBytes")
              Core.<*> (o Core..:? "originalName")
              Core.<*> (o Core..:? "systemName")
        )
  
  instance Core.ToJSON InstructionOutput where
    toJSON InstructionOutput {..} =
      Core.object
        ( Core.catMaybes
            [ ("codec" Core..=) Core.<$> codec,
              ("name" Core..=) Core.<$> name,
              ("onlyCountKeyBytes" Core..=) Core.<$> onlyCountKeyBytes,
              ("onlyCountValueBytes" Core..=) Core.<$> onlyCountValueBytes,
              ("originalName" Core..=) Core.<$> originalName,
              ("systemName" Core..=) Core.<$> systemName
            ]
        )
  
  -- | The codec to use to encode data being written via this output.
  --
  -- /See:/ 'newInstructionOutput_Codec' smart constructor.
  newtype InstructionOutput_Codec = InstructionOutput_Codec
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'InstructionOutput_Codec' with the minimum fields required to make a request.
  newInstructionOutput_Codec ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    InstructionOutput_Codec
  newInstructionOutput_Codec additional =
    InstructionOutput_Codec {additional = additional}
  
  instance Core.FromJSON InstructionOutput_Codec where
    parseJSON =
      Core.withObject
        "InstructionOutput_Codec"
        (\o -> InstructionOutput_Codec Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON InstructionOutput_Codec where
    toJSON InstructionOutput_Codec {..} = Core.toJSON additional
  
  -- | A metric value representing temporal values of a variable.
  --
  -- /See:/ 'newIntegerGauge' smart constructor.
  data IntegerGauge = IntegerGauge
    { -- | The time at which this value was measured. Measured as msecs from epoch.
      timestamp :: (Core.Maybe Core.DateTime),
      -- | The value of the variable represented by this gauge.
      value :: (Core.Maybe SplitInt64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IntegerGauge' with the minimum fields required to make a request.
  newIntegerGauge ::
    IntegerGauge
  newIntegerGauge =
    IntegerGauge {timestamp = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON IntegerGauge where
    parseJSON =
      Core.withObject
        "IntegerGauge"
        ( \o ->
            IntegerGauge
              Core.<$> (o Core..:? "timestamp")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON IntegerGauge where
    toJSON IntegerGauge {..} =
      Core.object
        ( Core.catMaybes
            [ ("timestamp" Core..=) Core.<$> timestamp,
              ("value" Core..=) Core.<$> value
            ]
        )
  
  -- | A metric value representing a list of integers.
  --
  -- /See:/ 'newIntegerList' smart constructor.
  newtype IntegerList = IntegerList
    { -- | Elements of the list.
      elements :: (Core.Maybe [SplitInt64])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IntegerList' with the minimum fields required to make a request.
  newIntegerList ::
    IntegerList
  newIntegerList = IntegerList {elements = Core.Nothing}
  
  instance Core.FromJSON IntegerList where
    parseJSON =
      Core.withObject
        "IntegerList"
        (\o -> IntegerList Core.<$> (o Core..:? "elements"))
  
  instance Core.ToJSON IntegerList where
    toJSON IntegerList {..} =
      Core.object
        (Core.catMaybes [("elements" Core..=) Core.<$> elements])
  
  -- | A representation of an integer mean metric contribution.
  --
  -- /See:/ 'newIntegerMean' smart constructor.
  data IntegerMean = IntegerMean
    { -- | The number of values being aggregated.
      count :: (Core.Maybe SplitInt64),
      -- | The sum of all values being aggregated.
      sum :: (Core.Maybe SplitInt64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'IntegerMean' with the minimum fields required to make a request.
  newIntegerMean ::
    IntegerMean
  newIntegerMean =
    IntegerMean {count = Core.Nothing, sum = Core.Nothing}
  
  instance Core.FromJSON IntegerMean where
    parseJSON =
      Core.withObject
        "IntegerMean"
        ( \o ->
            IntegerMean
              Core.<$> (o Core..:? "count")
              Core.<*> (o Core..:? "sum")
        )
  
  instance Core.ToJSON IntegerMean where
    toJSON IntegerMean {..} =
      Core.object
        ( Core.catMaybes
            [("count" Core..=) Core.<$> count, ("sum" Core..=) Core.<$> sum]
        )
  
  -- | Defines a job to be run by the Cloud Dataflow service. Do not enter confidential information when you supply string values using the API.
  --
  -- /See:/ 'newJob' smart constructor.
  data Job = Job
    { -- | The client\'s unique identifier of the job, re-used across retried attempts. If this field is set, the service will ensure its uniqueness. The request to create a job will fail if the service has knowledge of a previously submitted job with the same client\'s ID and job name. The caller may use this field to ensure idempotence of job creation across retried attempts to create a job. By default, the field is empty and, in that case, the service ignores it.
      clientRequestId :: (Core.Maybe Core.Text),
      -- | The timestamp when the job was initially created. Immutable and set by the Cloud Dataflow service.
      createTime :: (Core.Maybe Core.DateTime),
      -- | If this is specified, the job\'s initial state is populated from the given snapshot.
      createdFromSnapshotId :: (Core.Maybe Core.Text),
      -- | The current state of the job. Jobs are created in the @JOB_STATE_STOPPED@ state unless otherwise specified. A job in the @JOB_STATE_RUNNING@ state may asynchronously enter a terminal state. After a job has reached a terminal state, no further state updates may be made. This field might be mutated by the Dataflow service; callers cannot mutate it.
      currentState :: (Core.Maybe Job_CurrentState),
      -- | The timestamp associated with the current state.
      currentStateTime :: (Core.Maybe Core.DateTime),
      -- | Optional. The environment for the job.
      environment :: (Core.Maybe Environment),
      -- | Deprecated.
      executionInfo :: (Core.Maybe JobExecutionInfo),
      -- | The unique ID of this job. This field is set by the Dataflow service when the job is created, and is immutable for the life of the job.
      id :: (Core.Maybe Core.Text),
      -- | This field is populated by the Dataflow service to support filtering jobs by the metadata values provided here. Populated for ListJobs and all GetJob views SUMMARY and higher.
      jobMetadata :: (Core.Maybe JobMetadata),
      -- | User-defined labels for this job. The labels map can contain no more than 64 entries. Entries of the labels map are UTF8 strings that comply with the following restrictions: * Keys must conform to regexp: \\p{Ll}\\p{Lo}{0,62} * Values must conform to regexp: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} * Both keys and values are additionally constrained to be \<= 128 bytes in size.
      labels :: (Core.Maybe Job_Labels),
      -- | Optional. The [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that contains this job.
      location :: (Core.Maybe Core.Text),
      -- | Optional. The user-specified Dataflow job name. Only one active job with a given name can exist in a project within one region at any given time. Jobs in different regions can have the same name. If a caller attempts to create a job with the same name as an active job that already exists, the attempt returns the existing job. The name must match the regular expression @[a-z]([-a-z0-9]{0,1022}[a-z0-9])?@
      name :: (Core.Maybe Core.Text),
      -- | Preliminary field: The format of this data may change at any time. A description of the user pipeline and stages through which it is executed. Created by Cloud Dataflow service. Only retrieved with JOB/VIEW/DESCRIPTION or JOB/VIEW/ALL.
      pipelineDescription :: (Core.Maybe PipelineDescription),
      -- | The ID of the Google Cloud project that the job belongs to.
      projectId :: (Core.Maybe Core.Text),
      -- | If this job is an update of an existing job, this field is the job ID of the job it replaced. When sending a @CreateJobRequest@, you can update a job by specifying it here. The job named here is stopped, and its intermediate state is transferred to this job.
      replaceJobId :: (Core.Maybe Core.Text),
      -- | If another job is an update of this job (and thus, this job is in @JOB_STATE_UPDATED@), this field contains the ID of that job.
      replacedByJobId :: (Core.Maybe Core.Text),
      -- | The job\'s requested state. Applies to @UpdateJob@ requests. Set @requested_state@ with @UpdateJob@ requests to switch between the states @JOB_STATE_STOPPED@ and @JOB_STATE_RUNNING@. You can also use @UpdateJob@ requests to change a job\'s state from @JOB_STATE_RUNNING@ to @JOB_STATE_CANCELLED@, @JOB_STATE_DONE@, or @JOB_STATE_DRAINED@. These states irrevocably terminate the job if it hasn\'t already reached a terminal state. This field has no effect on @CreateJob@ requests.
      requestedState :: (Core.Maybe Job_RequestedState),
      -- | This field may ONLY be modified at runtime using the projects.jobs.update method to adjust job behavior. This field has no effect when specified at job creation.
      runtimeUpdatableParams :: (Core.Maybe RuntimeUpdatableParams),
      -- | Output only. Reserved for future use. This field is set only in responses from the server; it is ignored if it is set in any requests.
      satisfiesPzi :: (Core.Maybe Core.Bool),
      -- | Reserved for future use. This field is set only in responses from the server; it is ignored if it is set in any requests.
      satisfiesPzs :: (Core.Maybe Core.Bool),
      -- | Output only. Resources used by the Dataflow Service to run the job.
      serviceResources :: (Core.Maybe ServiceResources),
      -- | This field may be mutated by the Cloud Dataflow service; callers cannot mutate it.
      stageStates :: (Core.Maybe [ExecutionStageState]),
      -- | The timestamp when the job was started (transitioned to JOB/STATE/PENDING). Flexible resource scheduling jobs are started with some delay after job creation, so start/time is unset before start and is updated when the job is started by the Cloud Dataflow service. For other jobs, start/time always equals to create_time and is immutable and set by the Cloud Dataflow service.
      startTime :: (Core.Maybe Core.DateTime),
      -- | Exactly one of step or steps/location should be specified. The top-level steps that constitute the entire job. Only retrieved with JOB/VIEW_ALL.
      steps :: (Core.Maybe [Step]),
      -- | The Cloud Storage location where the steps are stored.
      stepsLocation :: (Core.Maybe Core.Text),
      -- | A set of files the system should be aware of that are used for temporary storage. These temporary files will be removed on job completion. No duplicates are allowed. No file patterns are supported. The supported files are: Google Cloud Storage: storage.googleapis.com\/{bucket}\/{object} bucket.storage.googleapis.com\/{object}
      tempFiles :: (Core.Maybe [Core.Text]),
      -- | Optional. The map of transform name prefixes of the job to be replaced to the corresponding name prefixes of the new job.
      transformNameMapping :: (Core.Maybe Job_TransformNameMapping),
      -- | Optional. The type of Dataflow job.
      type' :: (Core.Maybe Job_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Job' with the minimum fields required to make a request.
  newJob ::
    Job
  newJob =
    Job
      { clientRequestId = Core.Nothing,
        createTime = Core.Nothing,
        createdFromSnapshotId = Core.Nothing,
        currentState = Core.Nothing,
        currentStateTime = Core.Nothing,
        environment = Core.Nothing,
        executionInfo = Core.Nothing,
        id = Core.Nothing,
        jobMetadata = Core.Nothing,
        labels = Core.Nothing,
        location = Core.Nothing,
        name = Core.Nothing,
        pipelineDescription = Core.Nothing,
        projectId = Core.Nothing,
        replaceJobId = Core.Nothing,
        replacedByJobId = Core.Nothing,
        requestedState = Core.Nothing,
        runtimeUpdatableParams = Core.Nothing,
        satisfiesPzi = Core.Nothing,
        satisfiesPzs = Core.Nothing,
        serviceResources = Core.Nothing,
        stageStates = Core.Nothing,
        startTime = Core.Nothing,
        steps = Core.Nothing,
        stepsLocation = Core.Nothing,
        tempFiles = Core.Nothing,
        transformNameMapping = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON Job where
    parseJSON =
      Core.withObject
        "Job"
        ( \o ->
            Job
              Core.<$> (o Core..:? "clientRequestId")
              Core.<*> (o Core..:? "createTime")
              Core.<*> (o Core..:? "createdFromSnapshotId")
              Core.<*> (o Core..:? "currentState")
              Core.<*> (o Core..:? "currentStateTime")
              Core.<*> (o Core..:? "environment")
              Core.<*> (o Core..:? "executionInfo")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "jobMetadata")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "pipelineDescription")
              Core.<*> (o Core..:? "projectId")
              Core.<*> (o Core..:? "replaceJobId")
              Core.<*> (o Core..:? "replacedByJobId")
              Core.<*> (o Core..:? "requestedState")
              Core.<*> (o Core..:? "runtimeUpdatableParams")
              Core.<*> (o Core..:? "satisfiesPzi")
              Core.<*> (o Core..:? "satisfiesPzs")
              Core.<*> (o Core..:? "serviceResources")
              Core.<*> (o Core..:? "stageStates")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "steps")
              Core.<*> (o Core..:? "stepsLocation")
              Core.<*> (o Core..:? "tempFiles")
              Core.<*> (o Core..:? "transformNameMapping")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON Job where
    toJSON Job {..} =
      Core.object
        ( Core.catMaybes
            [ ("clientRequestId" Core..=) Core.<$> clientRequestId,
              ("createTime" Core..=) Core.<$> createTime,
              ("createdFromSnapshotId" Core..=) Core.<$> createdFromSnapshotId,
              ("currentState" Core..=) Core.<$> currentState,
              ("currentStateTime" Core..=) Core.<$> currentStateTime,
              ("environment" Core..=) Core.<$> environment,
              ("executionInfo" Core..=) Core.<$> executionInfo,
              ("id" Core..=) Core.<$> id,
              ("jobMetadata" Core..=) Core.<$> jobMetadata,
              ("labels" Core..=) Core.<$> labels,
              ("location" Core..=) Core.<$> location,
              ("name" Core..=) Core.<$> name,
              ("pipelineDescription" Core..=) Core.<$> pipelineDescription,
              ("projectId" Core..=) Core.<$> projectId,
              ("replaceJobId" Core..=) Core.<$> replaceJobId,
              ("replacedByJobId" Core..=) Core.<$> replacedByJobId,
              ("requestedState" Core..=) Core.<$> requestedState,
              ("runtimeUpdatableParams" Core..=) Core.<$> runtimeUpdatableParams,
              ("satisfiesPzi" Core..=) Core.<$> satisfiesPzi,
              ("satisfiesPzs" Core..=) Core.<$> satisfiesPzs,
              ("serviceResources" Core..=) Core.<$> serviceResources,
              ("stageStates" Core..=) Core.<$> stageStates,
              ("startTime" Core..=) Core.<$> startTime,
              ("steps" Core..=) Core.<$> steps,
              ("stepsLocation" Core..=) Core.<$> stepsLocation,
              ("tempFiles" Core..=) Core.<$> tempFiles,
              ("transformNameMapping" Core..=) Core.<$> transformNameMapping,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  -- | User-defined labels for this job. The labels map can contain no more than 64 entries. Entries of the labels map are UTF8 strings that comply with the following restrictions: * Keys must conform to regexp: \\p{Ll}\\p{Lo}{0,62} * Values must conform to regexp: [\\p{Ll}\\p{Lo}\\p{N}_-]{0,63} * Both keys and values are additionally constrained to be \<= 128 bytes in size.
  --
  -- /See:/ 'newJob_Labels' smart constructor.
  newtype Job_Labels = Job_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Job_Labels' with the minimum fields required to make a request.
  newJob_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Job_Labels
  newJob_Labels additional = Job_Labels {additional = additional}
  
  instance Core.FromJSON Job_Labels where
    parseJSON =
      Core.withObject
        "Job_Labels"
        (\o -> Job_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Job_Labels where
    toJSON Job_Labels {..} = Core.toJSON additional
  
  -- | Optional. The map of transform name prefixes of the job to be replaced to the corresponding name prefixes of the new job.
  --
  -- /See:/ 'newJob_TransformNameMapping' smart constructor.
  newtype Job_TransformNameMapping = Job_TransformNameMapping
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Job_TransformNameMapping' with the minimum fields required to make a request.
  newJob_TransformNameMapping ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    Job_TransformNameMapping
  newJob_TransformNameMapping additional =
    Job_TransformNameMapping {additional = additional}
  
  instance Core.FromJSON Job_TransformNameMapping where
    parseJSON =
      Core.withObject
        "Job_TransformNameMapping"
        (\o -> Job_TransformNameMapping Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Job_TransformNameMapping where
    toJSON Job_TransformNameMapping {..} = Core.toJSON additional
  
  -- | Information about the execution of a job.
  --
  -- /See:/ 'newJobExecutionDetails' smart constructor.
  data JobExecutionDetails = JobExecutionDetails
    { -- | If present, this response does not contain all requested tasks. To obtain the next page of results, repeat the request with page_token set to this value.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | The stages of the job execution.
      stages :: (Core.Maybe [StageSummary])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobExecutionDetails' with the minimum fields required to make a request.
  newJobExecutionDetails ::
    JobExecutionDetails
  newJobExecutionDetails =
    JobExecutionDetails
      { nextPageToken = Core.Nothing,
        stages = Core.Nothing
      }
  
  instance Core.FromJSON JobExecutionDetails where
    parseJSON =
      Core.withObject
        "JobExecutionDetails"
        ( \o ->
            JobExecutionDetails
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "stages")
        )
  
  instance Core.ToJSON JobExecutionDetails where
    toJSON JobExecutionDetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("stages" Core..=) Core.<$> stages
            ]
        )
  
  -- | Additional information about how a Cloud Dataflow job will be executed that isn\'t contained in the submitted job.
  --
  -- /See:/ 'newJobExecutionInfo' smart constructor.
  newtype JobExecutionInfo = JobExecutionInfo
    { -- | A mapping from each stage to the information about that stage.
      stages :: (Core.Maybe JobExecutionInfo_Stages)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobExecutionInfo' with the minimum fields required to make a request.
  newJobExecutionInfo ::
    JobExecutionInfo
  newJobExecutionInfo = JobExecutionInfo {stages = Core.Nothing}
  
  instance Core.FromJSON JobExecutionInfo where
    parseJSON =
      Core.withObject
        "JobExecutionInfo"
        (\o -> JobExecutionInfo Core.<$> (o Core..:? "stages"))
  
  instance Core.ToJSON JobExecutionInfo where
    toJSON JobExecutionInfo {..} =
      Core.object (Core.catMaybes [("stages" Core..=) Core.<$> stages])
  
  -- | A mapping from each stage to the information about that stage.
  --
  -- /See:/ 'newJobExecutionInfo_Stages' smart constructor.
  newtype JobExecutionInfo_Stages = JobExecutionInfo_Stages
    { additional :: (Core.HashMap Core.Text JobExecutionStageInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobExecutionInfo_Stages' with the minimum fields required to make a request.
  newJobExecutionInfo_Stages ::
    -- |  See 'additional'.
    Core.HashMap Core.Text JobExecutionStageInfo ->
    JobExecutionInfo_Stages
  newJobExecutionInfo_Stages additional =
    JobExecutionInfo_Stages {additional = additional}
  
  instance Core.FromJSON JobExecutionInfo_Stages where
    parseJSON =
      Core.withObject
        "JobExecutionInfo_Stages"
        (\o -> JobExecutionInfo_Stages Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON JobExecutionInfo_Stages where
    toJSON JobExecutionInfo_Stages {..} = Core.toJSON additional
  
  -- | Contains information about how a particular google.dataflow.v1beta3.Step will be executed.
  --
  -- /See:/ 'newJobExecutionStageInfo' smart constructor.
  newtype JobExecutionStageInfo = JobExecutionStageInfo
    { -- | The steps associated with the execution stage. Note that stages may have several steps, and that a given step might be run by more than one stage.
      stepName :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobExecutionStageInfo' with the minimum fields required to make a request.
  newJobExecutionStageInfo ::
    JobExecutionStageInfo
  newJobExecutionStageInfo =
    JobExecutionStageInfo {stepName = Core.Nothing}
  
  instance Core.FromJSON JobExecutionStageInfo where
    parseJSON =
      Core.withObject
        "JobExecutionStageInfo"
        (\o -> JobExecutionStageInfo Core.<$> (o Core..:? "stepName"))
  
  instance Core.ToJSON JobExecutionStageInfo where
    toJSON JobExecutionStageInfo {..} =
      Core.object
        (Core.catMaybes [("stepName" Core..=) Core.<$> stepName])
  
  -- | A particular message pertaining to a Dataflow job.
  --
  -- /See:/ 'newJobMessage' smart constructor.
  data JobMessage = JobMessage
    { -- | Deprecated.
      id :: (Core.Maybe Core.Text),
      -- | Importance level of the message.
      messageImportance :: (Core.Maybe JobMessage_MessageImportance),
      -- | The text of the message.
      messageText :: (Core.Maybe Core.Text),
      -- | The timestamp of the message.
      time :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobMessage' with the minimum fields required to make a request.
  newJobMessage ::
    JobMessage
  newJobMessage =
    JobMessage
      { id = Core.Nothing,
        messageImportance = Core.Nothing,
        messageText = Core.Nothing,
        time = Core.Nothing
      }
  
  instance Core.FromJSON JobMessage where
    parseJSON =
      Core.withObject
        "JobMessage"
        ( \o ->
            JobMessage
              Core.<$> (o Core..:? "id")
              Core.<*> (o Core..:? "messageImportance")
              Core.<*> (o Core..:? "messageText")
              Core.<*> (o Core..:? "time")
        )
  
  instance Core.ToJSON JobMessage where
    toJSON JobMessage {..} =
      Core.object
        ( Core.catMaybes
            [ ("id" Core..=) Core.<$> id,
              ("messageImportance" Core..=) Core.<$> messageImportance,
              ("messageText" Core..=) Core.<$> messageText,
              ("time" Core..=) Core.<$> time
            ]
        )
  
  -- | Metadata available primarily for filtering jobs. Will be included in the ListJob response and Job SUMMARY view.
  --
  -- /See:/ 'newJobMetadata' smart constructor.
  data JobMetadata = JobMetadata
    { -- | Identification of a Cloud Bigtable source used in the Dataflow job.
      bigTableDetails :: (Core.Maybe [BigTableIODetails]),
      -- | Identification of a BigQuery source used in the Dataflow job.
      bigqueryDetails :: (Core.Maybe [BigQueryIODetails]),
      -- | Identification of a Datastore source used in the Dataflow job.
      datastoreDetails :: (Core.Maybe [DatastoreIODetails]),
      -- | Identification of a File source used in the Dataflow job.
      fileDetails :: (Core.Maybe [FileIODetails]),
      -- | Identification of a Pub\/Sub source used in the Dataflow job.
      pubsubDetails :: (Core.Maybe [PubSubIODetails]),
      -- | The SDK version used to run the job.
      sdkVersion :: (Core.Maybe SdkVersion),
      -- | Identification of a Spanner source used in the Dataflow job.
      spannerDetails :: (Core.Maybe [SpannerIODetails]),
      -- | List of display properties to help UI filter jobs.
      userDisplayProperties :: (Core.Maybe JobMetadata_UserDisplayProperties)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobMetadata' with the minimum fields required to make a request.
  newJobMetadata ::
    JobMetadata
  newJobMetadata =
    JobMetadata
      { bigTableDetails = Core.Nothing,
        bigqueryDetails = Core.Nothing,
        datastoreDetails = Core.Nothing,
        fileDetails = Core.Nothing,
        pubsubDetails = Core.Nothing,
        sdkVersion = Core.Nothing,
        spannerDetails = Core.Nothing,
        userDisplayProperties = Core.Nothing
      }
  
  instance Core.FromJSON JobMetadata where
    parseJSON =
      Core.withObject
        "JobMetadata"
        ( \o ->
            JobMetadata
              Core.<$> (o Core..:? "bigTableDetails")
              Core.<*> (o Core..:? "bigqueryDetails")
              Core.<*> (o Core..:? "datastoreDetails")
              Core.<*> (o Core..:? "fileDetails")
              Core.<*> (o Core..:? "pubsubDetails")
              Core.<*> (o Core..:? "sdkVersion")
              Core.<*> (o Core..:? "spannerDetails")
              Core.<*> (o Core..:? "userDisplayProperties")
        )
  
  instance Core.ToJSON JobMetadata where
    toJSON JobMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("bigTableDetails" Core..=) Core.<$> bigTableDetails,
              ("bigqueryDetails" Core..=) Core.<$> bigqueryDetails,
              ("datastoreDetails" Core..=) Core.<$> datastoreDetails,
              ("fileDetails" Core..=) Core.<$> fileDetails,
              ("pubsubDetails" Core..=) Core.<$> pubsubDetails,
              ("sdkVersion" Core..=) Core.<$> sdkVersion,
              ("spannerDetails" Core..=) Core.<$> spannerDetails,
              ("userDisplayProperties" Core..=) Core.<$> userDisplayProperties
            ]
        )
  
  -- | List of display properties to help UI filter jobs.
  --
  -- /See:/ 'newJobMetadata_UserDisplayProperties' smart constructor.
  newtype JobMetadata_UserDisplayProperties = JobMetadata_UserDisplayProperties
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobMetadata_UserDisplayProperties' with the minimum fields required to make a request.
  newJobMetadata_UserDisplayProperties ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    JobMetadata_UserDisplayProperties
  newJobMetadata_UserDisplayProperties additional =
    JobMetadata_UserDisplayProperties {additional = additional}
  
  instance Core.FromJSON JobMetadata_UserDisplayProperties where
    parseJSON =
      Core.withObject
        "JobMetadata_UserDisplayProperties"
        ( \o ->
            JobMetadata_UserDisplayProperties
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON JobMetadata_UserDisplayProperties where
    toJSON JobMetadata_UserDisplayProperties {..} =
      Core.toJSON additional
  
  -- | JobMetrics contains a collection of metrics describing the detailed progress of a Dataflow job. Metrics correspond to user-defined and system-defined metrics in the job. For more information, see [Dataflow job metrics] (https:\/\/cloud.google.com\/dataflow\/docs\/guides\/using-monitoring-intf). This resource captures only the most recent values of each metric; time-series data can be queried for them (under the same metric names) from Cloud Monitoring.
  --
  -- /See:/ 'newJobMetrics' smart constructor.
  data JobMetrics = JobMetrics
    { -- | Timestamp as of which metric values are current.
      metricTime :: (Core.Maybe Core.DateTime),
      -- | All metrics for this job.
      metrics :: (Core.Maybe [MetricUpdate])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'JobMetrics' with the minimum fields required to make a request.
  newJobMetrics ::
    JobMetrics
  newJobMetrics =
    JobMetrics {metricTime = Core.Nothing, metrics = Core.Nothing}
  
  instance Core.FromJSON JobMetrics where
    parseJSON =
      Core.withObject
        "JobMetrics"
        ( \o ->
            JobMetrics
              Core.<$> (o Core..:? "metricTime")
              Core.<*> (o Core..:? "metrics")
        )
  
  instance Core.ToJSON JobMetrics where
    toJSON JobMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("metricTime" Core..=) Core.<$> metricTime,
              ("metrics" Core..=) Core.<$> metrics
            ]
        )
  
  -- | Data disk assignment information for a specific key-range of a sharded computation. Currently we only support UTF-8 character splits to simplify encoding into JSON.
  --
  -- /See:/ 'newKeyRangeDataDiskAssignment' smart constructor.
  data KeyRangeDataDiskAssignment = KeyRangeDataDiskAssignment
    { -- | The name of the data disk where data for this range is stored. This name is local to the Google Cloud Platform project and uniquely identifies the disk within that project, for example \"myproject-1014-104817-4c2-harness-0-disk-1\".
      dataDisk :: (Core.Maybe Core.Text),
      -- | The end (exclusive) of the key range.
      end :: (Core.Maybe Core.Text),
      -- | The start (inclusive) of the key range.
      start :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'KeyRangeDataDiskAssignment' with the minimum fields required to make a request.
  newKeyRangeDataDiskAssignment ::
    KeyRangeDataDiskAssignment
  newKeyRangeDataDiskAssignment =
    KeyRangeDataDiskAssignment
      { dataDisk = Core.Nothing,
        end = Core.Nothing,
        start = Core.Nothing
      }
  
  instance Core.FromJSON KeyRangeDataDiskAssignment where
    parseJSON =
      Core.withObject
        "KeyRangeDataDiskAssignment"
        ( \o ->
            KeyRangeDataDiskAssignment
              Core.<$> (o Core..:? "dataDisk")
              Core.<*> (o Core..:? "end")
              Core.<*> (o Core..:? "start")
        )
  
  instance Core.ToJSON KeyRangeDataDiskAssignment where
    toJSON KeyRangeDataDiskAssignment {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataDisk" Core..=) Core.<$> dataDisk,
              ("end" Core..=) Core.<$> end,
              ("start" Core..=) Core.<$> start
            ]
        )
  
  -- | Location information for a specific key-range of a sharded computation. Currently we only support UTF-8 character splits to simplify encoding into JSON.
  --
  -- /See:/ 'newKeyRangeLocation' smart constructor.
  data KeyRangeLocation = KeyRangeLocation
    { -- | The name of the data disk where data for this range is stored. This name is local to the Google Cloud Platform project and uniquely identifies the disk within that project, for example \"myproject-1014-104817-4c2-harness-0-disk-1\".
      dataDisk :: (Core.Maybe Core.Text),
      -- | The physical location of this range assignment to be used for streaming computation cross-worker message delivery.
      deliveryEndpoint :: (Core.Maybe Core.Text),
      -- | DEPRECATED. The location of the persistent state for this range, as a persistent directory in the worker local filesystem.
      deprecatedPersistentDirectory :: (Core.Maybe Core.Text),
      -- | The end (exclusive) of the key range.
      end :: (Core.Maybe Core.Text),
      -- | The start (inclusive) of the key range.
      start :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'KeyRangeLocation' with the minimum fields required to make a request.
  newKeyRangeLocation ::
    KeyRangeLocation
  newKeyRangeLocation =
    KeyRangeLocation
      { dataDisk = Core.Nothing,
        deliveryEndpoint = Core.Nothing,
        deprecatedPersistentDirectory = Core.Nothing,
        end = Core.Nothing,
        start = Core.Nothing
      }
  
  instance Core.FromJSON KeyRangeLocation where
    parseJSON =
      Core.withObject
        "KeyRangeLocation"
        ( \o ->
            KeyRangeLocation
              Core.<$> (o Core..:? "dataDisk")
              Core.<*> (o Core..:? "deliveryEndpoint")
              Core.<*> (o Core..:? "deprecatedPersistentDirectory")
              Core.<*> (o Core..:? "end")
              Core.<*> (o Core..:? "start")
        )
  
  instance Core.ToJSON KeyRangeLocation where
    toJSON KeyRangeLocation {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataDisk" Core..=) Core.<$> dataDisk,
              ("deliveryEndpoint" Core..=) Core.<$> deliveryEndpoint,
              ("deprecatedPersistentDirectory" Core..=)
                Core.<$> deprecatedPersistentDirectory,
              ("end" Core..=) Core.<$> end,
              ("start" Core..=) Core.<$> start
            ]
        )
  
  -- | Launch FlexTemplate Parameter.
  --
  -- /See:/ 'newLaunchFlexTemplateParameter' smart constructor.
  data LaunchFlexTemplateParameter = LaunchFlexTemplateParameter
    { -- | Spec about the container image to launch.
      containerSpec :: (Core.Maybe ContainerSpec),
      -- | Cloud Storage path to a file with json serialized ContainerSpec as content.
      containerSpecGcsPath :: (Core.Maybe Core.Text),
      -- | The runtime environment for the FlexTemplate job
      environment :: (Core.Maybe FlexTemplateRuntimeEnvironment),
      -- | Required. The job name to use for the created job. For update job request, job name should be same as the existing running job.
      jobName :: (Core.Maybe Core.Text),
      -- | Launch options for this flex template job. This is a common set of options across languages and templates. This should not be used to pass job parameters.
      launchOptions :: (Core.Maybe LaunchFlexTemplateParameter_LaunchOptions),
      -- | The parameters for FlexTemplate. Ex. {\"num_workers\":\"5\"}
      parameters :: (Core.Maybe LaunchFlexTemplateParameter_Parameters),
      -- | Use this to pass transform/name/mappings for streaming update jobs. Ex:{\"oldTransformName\":\"newTransformName\",...}\'
      transformNameMappings :: (Core.Maybe LaunchFlexTemplateParameter_TransformNameMappings),
      -- | Set this to true if you are sending a request to update a running streaming job. When set, the job name should be the same as the running job.
      update :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchFlexTemplateParameter' with the minimum fields required to make a request.
  newLaunchFlexTemplateParameter ::
    LaunchFlexTemplateParameter
  newLaunchFlexTemplateParameter =
    LaunchFlexTemplateParameter
      { containerSpec = Core.Nothing,
        containerSpecGcsPath = Core.Nothing,
        environment = Core.Nothing,
        jobName = Core.Nothing,
        launchOptions = Core.Nothing,
        parameters = Core.Nothing,
        transformNameMappings = Core.Nothing,
        update = Core.Nothing
      }
  
  instance Core.FromJSON LaunchFlexTemplateParameter where
    parseJSON =
      Core.withObject
        "LaunchFlexTemplateParameter"
        ( \o ->
            LaunchFlexTemplateParameter
              Core.<$> (o Core..:? "containerSpec")
              Core.<*> (o Core..:? "containerSpecGcsPath")
              Core.<*> (o Core..:? "environment")
              Core.<*> (o Core..:? "jobName")
              Core.<*> (o Core..:? "launchOptions")
              Core.<*> (o Core..:? "parameters")
              Core.<*> (o Core..:? "transformNameMappings")
              Core.<*> (o Core..:? "update")
        )
  
  instance Core.ToJSON LaunchFlexTemplateParameter where
    toJSON LaunchFlexTemplateParameter {..} =
      Core.object
        ( Core.catMaybes
            [ ("containerSpec" Core..=) Core.<$> containerSpec,
              ("containerSpecGcsPath" Core..=) Core.<$> containerSpecGcsPath,
              ("environment" Core..=) Core.<$> environment,
              ("jobName" Core..=) Core.<$> jobName,
              ("launchOptions" Core..=) Core.<$> launchOptions,
              ("parameters" Core..=) Core.<$> parameters,
              ("transformNameMappings" Core..=) Core.<$> transformNameMappings,
              ("update" Core..=) Core.<$> update
            ]
        )
  
  -- | Launch options for this flex template job. This is a common set of options across languages and templates. This should not be used to pass job parameters.
  --
  -- /See:/ 'newLaunchFlexTemplateParameter_LaunchOptions' smart constructor.
  newtype LaunchFlexTemplateParameter_LaunchOptions = LaunchFlexTemplateParameter_LaunchOptions
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchFlexTemplateParameter_LaunchOptions' with the minimum fields required to make a request.
  newLaunchFlexTemplateParameter_LaunchOptions ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    LaunchFlexTemplateParameter_LaunchOptions
  newLaunchFlexTemplateParameter_LaunchOptions additional =
    LaunchFlexTemplateParameter_LaunchOptions
      { additional =
          additional
      }
  
  instance Core.FromJSON LaunchFlexTemplateParameter_LaunchOptions where
    parseJSON =
      Core.withObject
        "LaunchFlexTemplateParameter_LaunchOptions"
        ( \o ->
            LaunchFlexTemplateParameter_LaunchOptions
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON LaunchFlexTemplateParameter_LaunchOptions where
    toJSON LaunchFlexTemplateParameter_LaunchOptions {..} =
      Core.toJSON additional
  
  -- | The parameters for FlexTemplate. Ex. {\"num_workers\":\"5\"}
  --
  -- /See:/ 'newLaunchFlexTemplateParameter_Parameters' smart constructor.
  newtype LaunchFlexTemplateParameter_Parameters = LaunchFlexTemplateParameter_Parameters
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchFlexTemplateParameter_Parameters' with the minimum fields required to make a request.
  newLaunchFlexTemplateParameter_Parameters ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    LaunchFlexTemplateParameter_Parameters
  newLaunchFlexTemplateParameter_Parameters additional =
    LaunchFlexTemplateParameter_Parameters {additional = additional}
  
  instance Core.FromJSON LaunchFlexTemplateParameter_Parameters where
    parseJSON =
      Core.withObject
        "LaunchFlexTemplateParameter_Parameters"
        ( \o ->
            LaunchFlexTemplateParameter_Parameters
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON LaunchFlexTemplateParameter_Parameters where
    toJSON LaunchFlexTemplateParameter_Parameters {..} =
      Core.toJSON additional
  
  -- | Use this to pass transform/name/mappings for streaming update jobs. Ex:{\"oldTransformName\":\"newTransformName\",...}\'
  --
  -- /See:/ 'newLaunchFlexTemplateParameter_TransformNameMappings' smart constructor.
  newtype LaunchFlexTemplateParameter_TransformNameMappings = LaunchFlexTemplateParameter_TransformNameMappings
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchFlexTemplateParameter_TransformNameMappings' with the minimum fields required to make a request.
  newLaunchFlexTemplateParameter_TransformNameMappings ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    LaunchFlexTemplateParameter_TransformNameMappings
  newLaunchFlexTemplateParameter_TransformNameMappings additional =
    LaunchFlexTemplateParameter_TransformNameMappings
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      LaunchFlexTemplateParameter_TransformNameMappings
    where
    parseJSON =
      Core.withObject
        "LaunchFlexTemplateParameter_TransformNameMappings"
        ( \o ->
            LaunchFlexTemplateParameter_TransformNameMappings
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance
    Core.ToJSON
      LaunchFlexTemplateParameter_TransformNameMappings
    where
    toJSON LaunchFlexTemplateParameter_TransformNameMappings {..} =
      Core.toJSON additional
  
  -- | A request to launch a Cloud Dataflow job from a FlexTemplate.
  --
  -- /See:/ 'newLaunchFlexTemplateRequest' smart constructor.
  data LaunchFlexTemplateRequest = LaunchFlexTemplateRequest
    { -- | Required. Parameter to launch a job form Flex Template.
      launchParameter :: (Core.Maybe LaunchFlexTemplateParameter),
      -- | If true, the request is validated but not actually executed. Defaults to false.
      validateOnly :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchFlexTemplateRequest' with the minimum fields required to make a request.
  newLaunchFlexTemplateRequest ::
    LaunchFlexTemplateRequest
  newLaunchFlexTemplateRequest =
    LaunchFlexTemplateRequest
      { launchParameter = Core.Nothing,
        validateOnly = Core.Nothing
      }
  
  instance Core.FromJSON LaunchFlexTemplateRequest where
    parseJSON =
      Core.withObject
        "LaunchFlexTemplateRequest"
        ( \o ->
            LaunchFlexTemplateRequest
              Core.<$> (o Core..:? "launchParameter")
              Core.<*> (o Core..:? "validateOnly")
        )
  
  instance Core.ToJSON LaunchFlexTemplateRequest where
    toJSON LaunchFlexTemplateRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("launchParameter" Core..=) Core.<$> launchParameter,
              ("validateOnly" Core..=) Core.<$> validateOnly
            ]
        )
  
  -- | Response to the request to launch a job from Flex Template.
  --
  -- /See:/ 'newLaunchFlexTemplateResponse' smart constructor.
  newtype LaunchFlexTemplateResponse = LaunchFlexTemplateResponse
    { -- | The job that was launched, if the request was not a dry run and the job was successfully launched.
      job :: (Core.Maybe Job)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchFlexTemplateResponse' with the minimum fields required to make a request.
  newLaunchFlexTemplateResponse ::
    LaunchFlexTemplateResponse
  newLaunchFlexTemplateResponse =
    LaunchFlexTemplateResponse {job = Core.Nothing}
  
  instance Core.FromJSON LaunchFlexTemplateResponse where
    parseJSON =
      Core.withObject
        "LaunchFlexTemplateResponse"
        (\o -> LaunchFlexTemplateResponse Core.<$> (o Core..:? "job"))
  
  instance Core.ToJSON LaunchFlexTemplateResponse where
    toJSON LaunchFlexTemplateResponse {..} =
      Core.object (Core.catMaybes [("job" Core..=) Core.<$> job])
  
  -- | Parameters to provide to the template being launched. Note that the [metadata in the pipeline code] (https:\/\/cloud.google.com\/dataflow\/docs\/guides\/templates\/creating-templates#metadata) determines which runtime parameters are valid.
  --
  -- /See:/ 'newLaunchTemplateParameters' smart constructor.
  data LaunchTemplateParameters = LaunchTemplateParameters
    { -- | The runtime environment for the job.
      environment :: (Core.Maybe RuntimeEnvironment),
      -- | Required. The job name to use for the created job. The name must match the regular expression @[a-z]([-a-z0-9]{0,1022}[a-z0-9])?@
      jobName :: (Core.Maybe Core.Text),
      -- | The runtime parameters to pass to the job.
      parameters :: (Core.Maybe LaunchTemplateParameters_Parameters),
      -- | Only applicable when updating a pipeline. Map of transform name prefixes of the job to be replaced to the corresponding name prefixes of the new job.
      transformNameMapping :: (Core.Maybe LaunchTemplateParameters_TransformNameMapping),
      -- | If set, replace the existing pipeline with the name specified by jobName with this pipeline, preserving state.
      update :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchTemplateParameters' with the minimum fields required to make a request.
  newLaunchTemplateParameters ::
    LaunchTemplateParameters
  newLaunchTemplateParameters =
    LaunchTemplateParameters
      { environment = Core.Nothing,
        jobName = Core.Nothing,
        parameters = Core.Nothing,
        transformNameMapping = Core.Nothing,
        update = Core.Nothing
      }
  
  instance Core.FromJSON LaunchTemplateParameters where
    parseJSON =
      Core.withObject
        "LaunchTemplateParameters"
        ( \o ->
            LaunchTemplateParameters
              Core.<$> (o Core..:? "environment")
              Core.<*> (o Core..:? "jobName")
              Core.<*> (o Core..:? "parameters")
              Core.<*> (o Core..:? "transformNameMapping")
              Core.<*> (o Core..:? "update")
        )
  
  instance Core.ToJSON LaunchTemplateParameters where
    toJSON LaunchTemplateParameters {..} =
      Core.object
        ( Core.catMaybes
            [ ("environment" Core..=) Core.<$> environment,
              ("jobName" Core..=) Core.<$> jobName,
              ("parameters" Core..=) Core.<$> parameters,
              ("transformNameMapping" Core..=) Core.<$> transformNameMapping,
              ("update" Core..=) Core.<$> update
            ]
        )
  
  -- | The runtime parameters to pass to the job.
  --
  -- /See:/ 'newLaunchTemplateParameters_Parameters' smart constructor.
  newtype LaunchTemplateParameters_Parameters = LaunchTemplateParameters_Parameters
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchTemplateParameters_Parameters' with the minimum fields required to make a request.
  newLaunchTemplateParameters_Parameters ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    LaunchTemplateParameters_Parameters
  newLaunchTemplateParameters_Parameters additional =
    LaunchTemplateParameters_Parameters {additional = additional}
  
  instance Core.FromJSON LaunchTemplateParameters_Parameters where
    parseJSON =
      Core.withObject
        "LaunchTemplateParameters_Parameters"
        ( \o ->
            LaunchTemplateParameters_Parameters
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON LaunchTemplateParameters_Parameters where
    toJSON LaunchTemplateParameters_Parameters {..} =
      Core.toJSON additional
  
  -- | Only applicable when updating a pipeline. Map of transform name prefixes of the job to be replaced to the corresponding name prefixes of the new job.
  --
  -- /See:/ 'newLaunchTemplateParameters_TransformNameMapping' smart constructor.
  newtype LaunchTemplateParameters_TransformNameMapping = LaunchTemplateParameters_TransformNameMapping
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchTemplateParameters_TransformNameMapping' with the minimum fields required to make a request.
  newLaunchTemplateParameters_TransformNameMapping ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    LaunchTemplateParameters_TransformNameMapping
  newLaunchTemplateParameters_TransformNameMapping additional =
    LaunchTemplateParameters_TransformNameMapping
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      LaunchTemplateParameters_TransformNameMapping
    where
    parseJSON =
      Core.withObject
        "LaunchTemplateParameters_TransformNameMapping"
        ( \o ->
            LaunchTemplateParameters_TransformNameMapping
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON LaunchTemplateParameters_TransformNameMapping where
    toJSON LaunchTemplateParameters_TransformNameMapping {..} =
      Core.toJSON additional
  
  -- | Response to the request to launch a template.
  --
  -- /See:/ 'newLaunchTemplateResponse' smart constructor.
  newtype LaunchTemplateResponse = LaunchTemplateResponse
    { -- | The job that was launched, if the request was not a dry run and the job was successfully launched.
      job :: (Core.Maybe Job)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LaunchTemplateResponse' with the minimum fields required to make a request.
  newLaunchTemplateResponse ::
    LaunchTemplateResponse
  newLaunchTemplateResponse =
    LaunchTemplateResponse {job = Core.Nothing}
  
  instance Core.FromJSON LaunchTemplateResponse where
    parseJSON =
      Core.withObject
        "LaunchTemplateResponse"
        (\o -> LaunchTemplateResponse Core.<$> (o Core..:? "job"))
  
  instance Core.ToJSON LaunchTemplateResponse where
    toJSON LaunchTemplateResponse {..} =
      Core.object (Core.catMaybes [("job" Core..=) Core.<$> job])
  
  -- | Request to lease WorkItems.
  --
  -- /See:/ 'newLeaseWorkItemRequest' smart constructor.
  data LeaseWorkItemRequest = LeaseWorkItemRequest
    { -- | The current timestamp at the worker.
      currentWorkerTime :: (Core.Maybe Core.DateTime),
      -- | The [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that contains the WorkItem\'s job.
      location :: (Core.Maybe Core.Text),
      -- | Optional. The project number of the project this worker belongs to.
      projectNumber :: (Core.Maybe Core.Int64),
      -- | The initial lease period.
      requestedLeaseDuration :: (Core.Maybe Core.Duration),
      -- | Untranslated bag-of-bytes WorkRequest from UnifiedWorker.
      unifiedWorkerRequest :: (Core.Maybe LeaseWorkItemRequest_UnifiedWorkerRequest),
      -- | Filter for WorkItem type.
      workItemTypes :: (Core.Maybe [Core.Text]),
      -- | Worker capabilities. WorkItems might be limited to workers with specific capabilities.
      workerCapabilities :: (Core.Maybe [Core.Text]),
      -- | Identifies the worker leasing work -- typically the ID of the virtual machine running the worker.
      workerId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LeaseWorkItemRequest' with the minimum fields required to make a request.
  newLeaseWorkItemRequest ::
    LeaseWorkItemRequest
  newLeaseWorkItemRequest =
    LeaseWorkItemRequest
      { currentWorkerTime = Core.Nothing,
        location = Core.Nothing,
        projectNumber = Core.Nothing,
        requestedLeaseDuration = Core.Nothing,
        unifiedWorkerRequest = Core.Nothing,
        workItemTypes = Core.Nothing,
        workerCapabilities = Core.Nothing,
        workerId = Core.Nothing
      }
  
  instance Core.FromJSON LeaseWorkItemRequest where
    parseJSON =
      Core.withObject
        "LeaseWorkItemRequest"
        ( \o ->
            LeaseWorkItemRequest
              Core.<$> (o Core..:? "currentWorkerTime")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "projectNumber" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "requestedLeaseDuration")
              Core.<*> (o Core..:? "unifiedWorkerRequest")
              Core.<*> (o Core..:? "workItemTypes")
              Core.<*> (o Core..:? "workerCapabilities")
              Core.<*> (o Core..:? "workerId")
        )
  
  instance Core.ToJSON LeaseWorkItemRequest where
    toJSON LeaseWorkItemRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentWorkerTime" Core..=) Core.<$> currentWorkerTime,
              ("location" Core..=) Core.<$> location,
              ("projectNumber" Core..=)
                Core.. Core.AsText
                Core.<$> projectNumber,
              ("requestedLeaseDuration" Core..=) Core.<$> requestedLeaseDuration,
              ("unifiedWorkerRequest" Core..=) Core.<$> unifiedWorkerRequest,
              ("workItemTypes" Core..=) Core.<$> workItemTypes,
              ("workerCapabilities" Core..=) Core.<$> workerCapabilities,
              ("workerId" Core..=) Core.<$> workerId
            ]
        )
  
  -- | Untranslated bag-of-bytes WorkRequest from UnifiedWorker.
  --
  -- /See:/ 'newLeaseWorkItemRequest_UnifiedWorkerRequest' smart constructor.
  newtype LeaseWorkItemRequest_UnifiedWorkerRequest = LeaseWorkItemRequest_UnifiedWorkerRequest
    { -- | 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 'LeaseWorkItemRequest_UnifiedWorkerRequest' with the minimum fields required to make a request.
  newLeaseWorkItemRequest_UnifiedWorkerRequest ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    LeaseWorkItemRequest_UnifiedWorkerRequest
  newLeaseWorkItemRequest_UnifiedWorkerRequest additional =
    LeaseWorkItemRequest_UnifiedWorkerRequest
      { additional =
          additional
      }
  
  instance Core.FromJSON LeaseWorkItemRequest_UnifiedWorkerRequest where
    parseJSON =
      Core.withObject
        "LeaseWorkItemRequest_UnifiedWorkerRequest"
        ( \o ->
            LeaseWorkItemRequest_UnifiedWorkerRequest
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON LeaseWorkItemRequest_UnifiedWorkerRequest where
    toJSON LeaseWorkItemRequest_UnifiedWorkerRequest {..} =
      Core.toJSON additional
  
  -- | Response to a request to lease WorkItems.
  --
  -- /See:/ 'newLeaseWorkItemResponse' smart constructor.
  data LeaseWorkItemResponse = LeaseWorkItemResponse
    { -- | Untranslated bag-of-bytes WorkResponse for UnifiedWorker.
      unifiedWorkerResponse :: (Core.Maybe LeaseWorkItemResponse_UnifiedWorkerResponse),
      -- | A list of the leased WorkItems.
      workItems :: (Core.Maybe [WorkItem])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LeaseWorkItemResponse' with the minimum fields required to make a request.
  newLeaseWorkItemResponse ::
    LeaseWorkItemResponse
  newLeaseWorkItemResponse =
    LeaseWorkItemResponse
      { unifiedWorkerResponse = Core.Nothing,
        workItems = Core.Nothing
      }
  
  instance Core.FromJSON LeaseWorkItemResponse where
    parseJSON =
      Core.withObject
        "LeaseWorkItemResponse"
        ( \o ->
            LeaseWorkItemResponse
              Core.<$> (o Core..:? "unifiedWorkerResponse")
              Core.<*> (o Core..:? "workItems")
        )
  
  instance Core.ToJSON LeaseWorkItemResponse where
    toJSON LeaseWorkItemResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("unifiedWorkerResponse" Core..=) Core.<$> unifiedWorkerResponse,
              ("workItems" Core..=) Core.<$> workItems
            ]
        )
  
  -- | Untranslated bag-of-bytes WorkResponse for UnifiedWorker.
  --
  -- /See:/ 'newLeaseWorkItemResponse_UnifiedWorkerResponse' smart constructor.
  newtype LeaseWorkItemResponse_UnifiedWorkerResponse = LeaseWorkItemResponse_UnifiedWorkerResponse
    { -- | 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 'LeaseWorkItemResponse_UnifiedWorkerResponse' with the minimum fields required to make a request.
  newLeaseWorkItemResponse_UnifiedWorkerResponse ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    LeaseWorkItemResponse_UnifiedWorkerResponse
  newLeaseWorkItemResponse_UnifiedWorkerResponse additional =
    LeaseWorkItemResponse_UnifiedWorkerResponse
      { additional =
          additional
      }
  
  instance Core.FromJSON LeaseWorkItemResponse_UnifiedWorkerResponse where
    parseJSON =
      Core.withObject
        "LeaseWorkItemResponse_UnifiedWorkerResponse"
        ( \o ->
            LeaseWorkItemResponse_UnifiedWorkerResponse
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON LeaseWorkItemResponse_UnifiedWorkerResponse where
    toJSON LeaseWorkItemResponse_UnifiedWorkerResponse {..} =
      Core.toJSON additional
  
  -- | Linear buckets with the following boundaries for indices in 0 to n-1. - i in [0, n-1]: [start + (i)/width, start + (i+1)/width)
  --
  -- /See:/ 'newLinear' smart constructor.
  data Linear = Linear
    { -- | Must be greater than 0.
      numberOfBuckets :: (Core.Maybe Core.Int32),
      -- | Lower bound of the first bucket.
      start :: (Core.Maybe Core.Double),
      -- | Distance between bucket boundaries. Must be greater than 0.
      width :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Linear' with the minimum fields required to make a request.
  newLinear ::
    Linear
  newLinear =
    Linear
      { numberOfBuckets = Core.Nothing,
        start = Core.Nothing,
        width = Core.Nothing
      }
  
  instance Core.FromJSON Linear where
    parseJSON =
      Core.withObject
        "Linear"
        ( \o ->
            Linear
              Core.<$> (o Core..:? "numberOfBuckets")
              Core.<*> (o Core..:? "start")
              Core.<*> (o Core..:? "width")
        )
  
  instance Core.ToJSON Linear where
    toJSON Linear {..} =
      Core.object
        ( Core.catMaybes
            [ ("numberOfBuckets" Core..=) Core.<$> numberOfBuckets,
              ("start" Core..=) Core.<$> start,
              ("width" Core..=) Core.<$> width
            ]
        )
  
  -- | Response to a request to list job messages.
  --
  -- /See:/ 'newListJobMessagesResponse' smart constructor.
  data ListJobMessagesResponse = ListJobMessagesResponse
    { -- | Autoscaling events in ascending timestamp order.
      autoscalingEvents :: (Core.Maybe [AutoscalingEvent]),
      -- | Messages in ascending timestamp order.
      jobMessages :: (Core.Maybe [JobMessage]),
      -- | The token to obtain the next page of results if there are more.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListJobMessagesResponse' with the minimum fields required to make a request.
  newListJobMessagesResponse ::
    ListJobMessagesResponse
  newListJobMessagesResponse =
    ListJobMessagesResponse
      { autoscalingEvents = Core.Nothing,
        jobMessages = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListJobMessagesResponse where
    parseJSON =
      Core.withObject
        "ListJobMessagesResponse"
        ( \o ->
            ListJobMessagesResponse
              Core.<$> (o Core..:? "autoscalingEvents")
              Core.<*> (o Core..:? "jobMessages")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListJobMessagesResponse where
    toJSON ListJobMessagesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("autoscalingEvents" Core..=) Core.<$> autoscalingEvents,
              ("jobMessages" Core..=) Core.<$> jobMessages,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response to a request to list Cloud Dataflow jobs in a project. This might be a partial response, depending on the page size in the ListJobsRequest. However, if the project does not have any jobs, an instance of ListJobsResponse is not returned and the requests\'s response body is empty {}.
  --
  -- /See:/ 'newListJobsResponse' smart constructor.
  data ListJobsResponse = ListJobsResponse
    { -- | Zero or more messages describing the [regional endpoints] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that failed to respond.
      failedLocation :: (Core.Maybe [FailedLocation]),
      -- | A subset of the requested job information.
      jobs :: (Core.Maybe [Job]),
      -- | Set if there may be more results than fit in this response.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListJobsResponse' with the minimum fields required to make a request.
  newListJobsResponse ::
    ListJobsResponse
  newListJobsResponse =
    ListJobsResponse
      { failedLocation = Core.Nothing,
        jobs = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListJobsResponse where
    parseJSON =
      Core.withObject
        "ListJobsResponse"
        ( \o ->
            ListJobsResponse
              Core.<$> (o Core..:? "failedLocation")
              Core.<*> (o Core..:? "jobs")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListJobsResponse where
    toJSON ListJobsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("failedLocation" Core..=) Core.<$> failedLocation,
              ("jobs" Core..=) Core.<$> jobs,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | List of snapshots.
  --
  -- /See:/ 'newListSnapshotsResponse' smart constructor.
  newtype ListSnapshotsResponse = ListSnapshotsResponse
    { -- | Returned snapshots.
      snapshots :: (Core.Maybe [Snapshot])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListSnapshotsResponse' with the minimum fields required to make a request.
  newListSnapshotsResponse ::
    ListSnapshotsResponse
  newListSnapshotsResponse =
    ListSnapshotsResponse {snapshots = Core.Nothing}
  
  instance Core.FromJSON ListSnapshotsResponse where
    parseJSON =
      Core.withObject
        "ListSnapshotsResponse"
        (\o -> ListSnapshotsResponse Core.<$> (o Core..:? "snapshots"))
  
  instance Core.ToJSON ListSnapshotsResponse where
    toJSON ListSnapshotsResponse {..} =
      Core.object
        (Core.catMaybes [("snapshots" Core..=) Core.<$> snapshots])
  
  -- | MapTask consists of an ordered set of instructions, each of which describes one particular low-level operation for the worker to perform in order to accomplish the MapTask\'s WorkItem. Each instruction must appear in the list before any instructions which depends on its output.
  --
  -- /See:/ 'newMapTask' smart constructor.
  data MapTask = MapTask
    { -- | Counter prefix that can be used to prefix counters. Not currently used in Dataflow.
      counterPrefix :: (Core.Maybe Core.Text),
      -- | The instructions in the MapTask.
      instructions :: (Core.Maybe [ParallelInstruction]),
      -- | System-defined name of the stage containing this MapTask. Unique across the workflow.
      stageName :: (Core.Maybe Core.Text),
      -- | System-defined name of this MapTask. Unique across the workflow.
      systemName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MapTask' with the minimum fields required to make a request.
  newMapTask ::
    MapTask
  newMapTask =
    MapTask
      { counterPrefix = Core.Nothing,
        instructions = Core.Nothing,
        stageName = Core.Nothing,
        systemName = Core.Nothing
      }
  
  instance Core.FromJSON MapTask where
    parseJSON =
      Core.withObject
        "MapTask"
        ( \o ->
            MapTask
              Core.<$> (o Core..:? "counterPrefix")
              Core.<*> (o Core..:? "instructions")
              Core.<*> (o Core..:? "stageName")
              Core.<*> (o Core..:? "systemName")
        )
  
  instance Core.ToJSON MapTask where
    toJSON MapTask {..} =
      Core.object
        ( Core.catMaybes
            [ ("counterPrefix" Core..=) Core.<$> counterPrefix,
              ("instructions" Core..=) Core.<$> instructions,
              ("stageName" Core..=) Core.<$> stageName,
              ("systemName" Core..=) Core.<$> systemName
            ]
        )
  
  -- | Information about the memory usage of a worker or a container within a worker.
  --
  -- /See:/ 'newMemInfo' smart constructor.
  data MemInfo = MemInfo
    { -- | Instantenous memory limit in bytes.
      currentLimitBytes :: (Core.Maybe Core.Word64),
      -- | Number of Out of Memory (OOM) events recorded since the previous measurement.
      currentOoms :: (Core.Maybe Core.Int64),
      -- | Instantenous memory (RSS) size in bytes.
      currentRssBytes :: (Core.Maybe Core.Word64),
      -- | Timestamp of the measurement.
      timestamp :: (Core.Maybe Core.DateTime),
      -- | Total memory (RSS) usage since start up in GB * ms.
      totalGbMs :: (Core.Maybe Core.Word64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MemInfo' with the minimum fields required to make a request.
  newMemInfo ::
    MemInfo
  newMemInfo =
    MemInfo
      { currentLimitBytes = Core.Nothing,
        currentOoms = Core.Nothing,
        currentRssBytes = Core.Nothing,
        timestamp = Core.Nothing,
        totalGbMs = Core.Nothing
      }
  
  instance Core.FromJSON MemInfo where
    parseJSON =
      Core.withObject
        "MemInfo"
        ( \o ->
            MemInfo
              Core.<$> (o Core..:? "currentLimitBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "currentOoms" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "currentRssBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "timestamp")
              Core.<*> (o Core..:? "totalGbMs" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON MemInfo where
    toJSON MemInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentLimitBytes" Core..=)
                Core.. Core.AsText
                Core.<$> currentLimitBytes,
              ("currentOoms" Core..=) Core.. Core.AsText Core.<$> currentOoms,
              ("currentRssBytes" Core..=)
                Core.. Core.AsText
                Core.<$> currentRssBytes,
              ("timestamp" Core..=) Core.<$> timestamp,
              ("totalGbMs" Core..=) Core.. Core.AsText Core.<$> totalGbMs
            ]
        )
  
  -- | The metric short id is returned to the user alongside an offset into ReportWorkItemStatusRequest
  --
  -- /See:/ 'newMetricShortId' smart constructor.
  data MetricShortId = MetricShortId
    { -- | The index of the corresponding metric in the ReportWorkItemStatusRequest. Required.
      metricIndex :: (Core.Maybe Core.Int32),
      -- | The service-generated short identifier for the metric.
      shortId :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MetricShortId' with the minimum fields required to make a request.
  newMetricShortId ::
    MetricShortId
  newMetricShortId =
    MetricShortId {metricIndex = Core.Nothing, shortId = Core.Nothing}
  
  instance Core.FromJSON MetricShortId where
    parseJSON =
      Core.withObject
        "MetricShortId"
        ( \o ->
            MetricShortId
              Core.<$> (o Core..:? "metricIndex")
              Core.<*> (o Core..:? "shortId" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON MetricShortId where
    toJSON MetricShortId {..} =
      Core.object
        ( Core.catMaybes
            [ ("metricIndex" Core..=) Core.<$> metricIndex,
              ("shortId" Core..=) Core.. Core.AsText Core.<$> shortId
            ]
        )
  
  -- | Identifies a metric, by describing the source which generated the metric.
  --
  -- /See:/ 'newMetricStructuredName' smart constructor.
  data MetricStructuredName = MetricStructuredName
    { -- | Zero or more labeled fields which identify the part of the job this metric is associated with, such as the name of a step or collection. For example, built-in counters associated with steps will have context[\'step\'] = . Counters associated with PCollections in the SDK will have context[\'pcollection\'] = .
      context :: (Core.Maybe MetricStructuredName_Context),
      -- | Worker-defined metric name.
      name :: (Core.Maybe Core.Text),
      -- | Origin (namespace) of metric name. May be blank for user-define metrics; will be \"dataflow\" for metrics defined by the Dataflow service or SDK.
      origin :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MetricStructuredName' with the minimum fields required to make a request.
  newMetricStructuredName ::
    MetricStructuredName
  newMetricStructuredName =
    MetricStructuredName
      { context = Core.Nothing,
        name = Core.Nothing,
        origin = Core.Nothing
      }
  
  instance Core.FromJSON MetricStructuredName where
    parseJSON =
      Core.withObject
        "MetricStructuredName"
        ( \o ->
            MetricStructuredName
              Core.<$> (o Core..:? "context")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "origin")
        )
  
  instance Core.ToJSON MetricStructuredName where
    toJSON MetricStructuredName {..} =
      Core.object
        ( Core.catMaybes
            [ ("context" Core..=) Core.<$> context,
              ("name" Core..=) Core.<$> name,
              ("origin" Core..=) Core.<$> origin
            ]
        )
  
  -- | Zero or more labeled fields which identify the part of the job this metric is associated with, such as the name of a step or collection. For example, built-in counters associated with steps will have context[\'step\'] = . Counters associated with PCollections in the SDK will have context[\'pcollection\'] = .
  --
  -- /See:/ 'newMetricStructuredName_Context' smart constructor.
  newtype MetricStructuredName_Context = MetricStructuredName_Context
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MetricStructuredName_Context' with the minimum fields required to make a request.
  newMetricStructuredName_Context ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    MetricStructuredName_Context
  newMetricStructuredName_Context additional =
    MetricStructuredName_Context {additional = additional}
  
  instance Core.FromJSON MetricStructuredName_Context where
    parseJSON =
      Core.withObject
        "MetricStructuredName_Context"
        ( \o ->
            MetricStructuredName_Context Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON MetricStructuredName_Context where
    toJSON MetricStructuredName_Context {..} = Core.toJSON additional
  
  -- | Describes the state of a metric. Next ID: 14
  --
  -- /See:/ 'newMetricUpdate' smart constructor.
  data MetricUpdate = MetricUpdate
    { -- | True if this metric is reported as the total cumulative aggregate value accumulated since the worker started working on this WorkItem. By default this is false, indicating that this metric is reported as a delta that is not associated with any WorkItem.
      cumulative :: (Core.Maybe Core.Bool),
      -- | A struct value describing properties of a distribution of numeric values.
      distribution :: (Core.Maybe Core.Value),
      -- | A struct value describing properties of a Gauge. Metrics of gauge type show the value of a metric across time, and is aggregated based on the newest value.
      gauge :: (Core.Maybe Core.Value),
      -- | Worker-computed aggregate value for internal use by the Dataflow service.
      internal :: (Core.Maybe Core.Value),
      -- | Metric aggregation kind. The possible metric aggregation kinds are \"Sum\", \"Max\", \"Min\", \"Mean\", \"Set\", \"And\", \"Or\", and \"Distribution\". The specified aggregation kind is case-insensitive. If omitted, this is not an aggregated value but instead a single metric sample value.
      kind :: (Core.Maybe Core.Text),
      -- | Worker-computed aggregate value for the \"Mean\" aggregation kind. This holds the count of the aggregated values and is used in combination with mean_sum above to obtain the actual mean aggregate value. The only possible value type is Long.
      meanCount :: (Core.Maybe Core.Value),
      -- | Worker-computed aggregate value for the \"Mean\" aggregation kind. This holds the sum of the aggregated values and is used in combination with mean_count below to obtain the actual mean aggregate value. The only possible value types are Long and Double.
      meanSum :: (Core.Maybe Core.Value),
      -- | Name of the metric.
      name :: (Core.Maybe MetricStructuredName),
      -- | Worker-computed aggregate value for aggregation kinds \"Sum\", \"Max\", \"Min\", \"And\", and \"Or\". The possible value types are Long, Double, and Boolean.
      scalar :: (Core.Maybe Core.Value),
      -- | Worker-computed aggregate value for the \"Set\" aggregation kind. The only possible value type is a list of Values whose type can be Long, Double, String, or BoundedTrie according to the metric\'s type. All Values in the list must be of the same type.
      set :: (Core.Maybe Core.Value),
      -- | Worker-computed aggregate value for the \"Trie\" aggregation kind. The only possible value type is a BoundedTrieNode.
      trie :: (Core.Maybe Core.Value),
      -- | Timestamp associated with the metric value. Optional when workers are reporting work progress; it will be filled in responses from the metrics API.
      updateTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MetricUpdate' with the minimum fields required to make a request.
  newMetricUpdate ::
    MetricUpdate
  newMetricUpdate =
    MetricUpdate
      { cumulative = Core.Nothing,
        distribution = Core.Nothing,
        gauge = Core.Nothing,
        internal = Core.Nothing,
        kind = Core.Nothing,
        meanCount = Core.Nothing,
        meanSum = Core.Nothing,
        name = Core.Nothing,
        scalar = Core.Nothing,
        set = Core.Nothing,
        trie = Core.Nothing,
        updateTime = Core.Nothing
      }
  
  instance Core.FromJSON MetricUpdate where
    parseJSON =
      Core.withObject
        "MetricUpdate"
        ( \o ->
            MetricUpdate
              Core.<$> (o Core..:? "cumulative")
              Core.<*> (o Core..:? "distribution")
              Core.<*> (o Core..:? "gauge")
              Core.<*> (o Core..:? "internal")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "meanCount")
              Core.<*> (o Core..:? "meanSum")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "scalar")
              Core.<*> (o Core..:? "set")
              Core.<*> (o Core..:? "trie")
              Core.<*> (o Core..:? "updateTime")
        )
  
  instance Core.ToJSON MetricUpdate where
    toJSON MetricUpdate {..} =
      Core.object
        ( Core.catMaybes
            [ ("cumulative" Core..=) Core.<$> cumulative,
              ("distribution" Core..=) Core.<$> distribution,
              ("gauge" Core..=) Core.<$> gauge,
              ("internal" Core..=) Core.<$> internal,
              ("kind" Core..=) Core.<$> kind,
              ("meanCount" Core..=) Core.<$> meanCount,
              ("meanSum" Core..=) Core.<$> meanSum,
              ("name" Core..=) Core.<$> name,
              ("scalar" Core..=) Core.<$> scalar,
              ("set" Core..=) Core.<$> set,
              ("trie" Core..=) Core.<$> trie,
              ("updateTime" Core..=) Core.<$> updateTime
            ]
        )
  
  -- | The value of a metric along with its name and labels.
  --
  -- /See:/ 'newMetricValue' smart constructor.
  data MetricValue = MetricValue
    { -- | Base name for this metric.
      metric :: (Core.Maybe Core.Text),
      -- | Optional. Set of metric labels for this metric.
      metricLabels :: (Core.Maybe MetricValue_MetricLabels),
      -- | Non-cumulative int64 value of this metric.
      valueGauge64 :: (Core.Maybe DataflowGaugeValue),
      -- | Histogram value of this metric.
      valueHistogram :: (Core.Maybe DataflowHistogramValue),
      -- | Integer value of this metric.
      valueInt64 :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MetricValue' with the minimum fields required to make a request.
  newMetricValue ::
    MetricValue
  newMetricValue =
    MetricValue
      { metric = Core.Nothing,
        metricLabels = Core.Nothing,
        valueGauge64 = Core.Nothing,
        valueHistogram = Core.Nothing,
        valueInt64 = Core.Nothing
      }
  
  instance Core.FromJSON MetricValue where
    parseJSON =
      Core.withObject
        "MetricValue"
        ( \o ->
            MetricValue
              Core.<$> (o Core..:? "metric")
              Core.<*> (o Core..:? "metricLabels")
              Core.<*> (o Core..:? "valueGauge64")
              Core.<*> (o Core..:? "valueHistogram")
              Core.<*> (o Core..:? "valueInt64" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON MetricValue where
    toJSON MetricValue {..} =
      Core.object
        ( Core.catMaybes
            [ ("metric" Core..=) Core.<$> metric,
              ("metricLabels" Core..=) Core.<$> metricLabels,
              ("valueGauge64" Core..=) Core.<$> valueGauge64,
              ("valueHistogram" Core..=) Core.<$> valueHistogram,
              ("valueInt64" Core..=) Core.. Core.AsText Core.<$> valueInt64
            ]
        )
  
  -- | Optional. Set of metric labels for this metric.
  --
  -- /See:/ 'newMetricValue_MetricLabels' smart constructor.
  newtype MetricValue_MetricLabels = MetricValue_MetricLabels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MetricValue_MetricLabels' with the minimum fields required to make a request.
  newMetricValue_MetricLabels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    MetricValue_MetricLabels
  newMetricValue_MetricLabels additional =
    MetricValue_MetricLabels {additional = additional}
  
  instance Core.FromJSON MetricValue_MetricLabels where
    parseJSON =
      Core.withObject
        "MetricValue_MetricLabels"
        (\o -> MetricValue_MetricLabels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON MetricValue_MetricLabels where
    toJSON MetricValue_MetricLabels {..} = Core.toJSON additional
  
  -- | Describes mounted data disk.
  --
  -- /See:/ 'newMountedDataDisk' smart constructor.
  newtype MountedDataDisk = MountedDataDisk
    { -- | The name of the data disk. This name is local to the Google Cloud Platform project and uniquely identifies the disk within that project, for example \"myproject-1014-104817-4c2-harness-0-disk-1\".
      dataDisk :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MountedDataDisk' with the minimum fields required to make a request.
  newMountedDataDisk ::
    MountedDataDisk
  newMountedDataDisk = MountedDataDisk {dataDisk = Core.Nothing}
  
  instance Core.FromJSON MountedDataDisk where
    parseJSON =
      Core.withObject
        "MountedDataDisk"
        (\o -> MountedDataDisk Core.<$> (o Core..:? "dataDisk"))
  
  instance Core.ToJSON MountedDataDisk where
    toJSON MountedDataDisk {..} =
      Core.object
        (Core.catMaybes [("dataDisk" Core..=) Core.<$> dataDisk])
  
  -- | Information about an output of a multi-output DoFn.
  --
  -- /See:/ 'newMultiOutputInfo' smart constructor.
  newtype MultiOutputInfo = MultiOutputInfo
    { -- | The id of the tag the user code will emit to this output by; this should correspond to the tag of some SideInputInfo.
      tag :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MultiOutputInfo' with the minimum fields required to make a request.
  newMultiOutputInfo ::
    MultiOutputInfo
  newMultiOutputInfo = MultiOutputInfo {tag = Core.Nothing}
  
  instance Core.FromJSON MultiOutputInfo where
    parseJSON =
      Core.withObject
        "MultiOutputInfo"
        (\o -> MultiOutputInfo Core.<$> (o Core..:? "tag"))
  
  instance Core.ToJSON MultiOutputInfo where
    toJSON MultiOutputInfo {..} =
      Core.object (Core.catMaybes [("tag" Core..=) Core.<$> tag])
  
  -- | Basic metadata about a counter.
  --
  -- /See:/ 'newNameAndKind' smart constructor.
  data NameAndKind = NameAndKind
    { -- | Counter aggregation kind.
      kind :: (Core.Maybe NameAndKind_Kind),
      -- | Name of the counter.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'NameAndKind' with the minimum fields required to make a request.
  newNameAndKind ::
    NameAndKind
  newNameAndKind =
    NameAndKind {kind = Core.Nothing, name = Core.Nothing}
  
  instance Core.FromJSON NameAndKind where
    parseJSON =
      Core.withObject
        "NameAndKind"
        ( \o ->
            NameAndKind
              Core.<$> (o Core..:? "kind")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON NameAndKind where
    toJSON NameAndKind {..} =
      Core.object
        ( Core.catMaybes
            [("kind" Core..=) Core.<$> kind, ("name" Core..=) Core.<$> name]
        )
  
  -- | Statistics for the underflow and overflow bucket.
  --
  -- /See:/ 'newOutlierStats' smart constructor.
  data OutlierStats = OutlierStats
    { -- | Number of values that are larger than the upper bound of the largest bucket.
      overflowCount :: (Core.Maybe Core.Int64),
      -- | Mean of values in the overflow bucket.
      overflowMean :: (Core.Maybe Core.Double),
      -- | Number of values that are smaller than the lower bound of the smallest bucket.
      underflowCount :: (Core.Maybe Core.Int64),
      -- | Mean of values in the undeflow bucket.
      underflowMean :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'OutlierStats' with the minimum fields required to make a request.
  newOutlierStats ::
    OutlierStats
  newOutlierStats =
    OutlierStats
      { overflowCount = Core.Nothing,
        overflowMean = Core.Nothing,
        underflowCount = Core.Nothing,
        underflowMean = Core.Nothing
      }
  
  instance Core.FromJSON OutlierStats where
    parseJSON =
      Core.withObject
        "OutlierStats"
        ( \o ->
            OutlierStats
              Core.<$> (o Core..:? "overflowCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "overflowMean")
              Core.<*> (o Core..:? "underflowCount" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "underflowMean")
        )
  
  instance Core.ToJSON OutlierStats where
    toJSON OutlierStats {..} =
      Core.object
        ( Core.catMaybes
            [ ("overflowCount" Core..=)
                Core.. Core.AsText
                Core.<$> overflowCount,
              ("overflowMean" Core..=) Core.<$> overflowMean,
              ("underflowCount" Core..=)
                Core.. Core.AsText
                Core.<$> underflowCount,
              ("underflowMean" Core..=) Core.<$> underflowMean
            ]
        )
  
  -- | The packages that must be installed in order for a worker to run the steps of the Cloud Dataflow job that will be assigned to its worker pool. This is the mechanism by which the Cloud Dataflow SDK causes code to be loaded onto the workers. For example, the Cloud Dataflow Java SDK might use this to install jars containing the user\'s code and all of the various dependencies (libraries, data files, etc.) required in order for that code to run.
  --
  -- /See:/ 'newPackage' smart constructor.
  data Package = Package
    { -- | The resource to read the package from. The supported resource type is: Google Cloud Storage: storage.googleapis.com\/{bucket} bucket.storage.googleapis.com\/
      location :: (Core.Maybe Core.Text),
      -- | The name of the package.
      name :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Package' with the minimum fields required to make a request.
  newPackage ::
    Package
  newPackage = Package {location = Core.Nothing, name = Core.Nothing}
  
  instance Core.FromJSON Package where
    parseJSON =
      Core.withObject
        "Package"
        ( \o ->
            Package
              Core.<$> (o Core..:? "location")
              Core.<*> (o Core..:? "name")
        )
  
  instance Core.ToJSON Package where
    toJSON Package {..} =
      Core.object
        ( Core.catMaybes
            [ ("location" Core..=) Core.<$> location,
              ("name" Core..=) Core.<$> name
            ]
        )
  
  -- | An instruction that does a ParDo operation. Takes one main input and zero or more side inputs, and produces zero or more outputs. Runs user code.
  --
  -- /See:/ 'newParDoInstruction' smart constructor.
  data ParDoInstruction = ParDoInstruction
    { -- | The input.
      input :: (Core.Maybe InstructionInput),
      -- | Information about each of the outputs, if user_fn is a MultiDoFn.
      multiOutputInfos :: (Core.Maybe [MultiOutputInfo]),
      -- | The number of outputs.
      numOutputs :: (Core.Maybe Core.Int32),
      -- | Zero or more side inputs.
      sideInputs :: (Core.Maybe [SideInputInfo]),
      -- | The user function to invoke.
      userFn :: (Core.Maybe ParDoInstruction_UserFn)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParDoInstruction' with the minimum fields required to make a request.
  newParDoInstruction ::
    ParDoInstruction
  newParDoInstruction =
    ParDoInstruction
      { input = Core.Nothing,
        multiOutputInfos = Core.Nothing,
        numOutputs = Core.Nothing,
        sideInputs = Core.Nothing,
        userFn = Core.Nothing
      }
  
  instance Core.FromJSON ParDoInstruction where
    parseJSON =
      Core.withObject
        "ParDoInstruction"
        ( \o ->
            ParDoInstruction
              Core.<$> (o Core..:? "input")
              Core.<*> (o Core..:? "multiOutputInfos")
              Core.<*> (o Core..:? "numOutputs")
              Core.<*> (o Core..:? "sideInputs")
              Core.<*> (o Core..:? "userFn")
        )
  
  instance Core.ToJSON ParDoInstruction where
    toJSON ParDoInstruction {..} =
      Core.object
        ( Core.catMaybes
            [ ("input" Core..=) Core.<$> input,
              ("multiOutputInfos" Core..=) Core.<$> multiOutputInfos,
              ("numOutputs" Core..=) Core.<$> numOutputs,
              ("sideInputs" Core..=) Core.<$> sideInputs,
              ("userFn" Core..=) Core.<$> userFn
            ]
        )
  
  -- | The user function to invoke.
  --
  -- /See:/ 'newParDoInstruction_UserFn' smart constructor.
  newtype ParDoInstruction_UserFn = ParDoInstruction_UserFn
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParDoInstruction_UserFn' with the minimum fields required to make a request.
  newParDoInstruction_UserFn ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    ParDoInstruction_UserFn
  newParDoInstruction_UserFn additional =
    ParDoInstruction_UserFn {additional = additional}
  
  instance Core.FromJSON ParDoInstruction_UserFn where
    parseJSON =
      Core.withObject
        "ParDoInstruction_UserFn"
        (\o -> ParDoInstruction_UserFn Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON ParDoInstruction_UserFn where
    toJSON ParDoInstruction_UserFn {..} = Core.toJSON additional
  
  -- | Describes a particular operation comprising a MapTask.
  --
  -- /See:/ 'newParallelInstruction' smart constructor.
  data ParallelInstruction = ParallelInstruction
    { -- | Additional information for Flatten instructions.
      flatten :: (Core.Maybe FlattenInstruction),
      -- | User-provided name of this operation.
      name :: (Core.Maybe Core.Text),
      -- | System-defined name for the operation in the original workflow graph.
      originalName :: (Core.Maybe Core.Text),
      -- | Describes the outputs of the instruction.
      outputs :: (Core.Maybe [InstructionOutput]),
      -- | Additional information for ParDo instructions.
      parDo :: (Core.Maybe ParDoInstruction),
      -- | Additional information for PartialGroupByKey instructions.
      partialGroupByKey :: (Core.Maybe PartialGroupByKeyInstruction),
      -- | Additional information for Read instructions.
      read :: (Core.Maybe ReadInstruction),
      -- | System-defined name of this operation. Unique across the workflow.
      systemName :: (Core.Maybe Core.Text),
      -- | Additional information for Write instructions.
      write :: (Core.Maybe WriteInstruction)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParallelInstruction' with the minimum fields required to make a request.
  newParallelInstruction ::
    ParallelInstruction
  newParallelInstruction =
    ParallelInstruction
      { flatten = Core.Nothing,
        name = Core.Nothing,
        originalName = Core.Nothing,
        outputs = Core.Nothing,
        parDo = Core.Nothing,
        partialGroupByKey = Core.Nothing,
        read = Core.Nothing,
        systemName = Core.Nothing,
        write = Core.Nothing
      }
  
  instance Core.FromJSON ParallelInstruction where
    parseJSON =
      Core.withObject
        "ParallelInstruction"
        ( \o ->
            ParallelInstruction
              Core.<$> (o Core..:? "flatten")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "originalName")
              Core.<*> (o Core..:? "outputs")
              Core.<*> (o Core..:? "parDo")
              Core.<*> (o Core..:? "partialGroupByKey")
              Core.<*> (o Core..:? "read")
              Core.<*> (o Core..:? "systemName")
              Core.<*> (o Core..:? "write")
        )
  
  instance Core.ToJSON ParallelInstruction where
    toJSON ParallelInstruction {..} =
      Core.object
        ( Core.catMaybes
            [ ("flatten" Core..=) Core.<$> flatten,
              ("name" Core..=) Core.<$> name,
              ("originalName" Core..=) Core.<$> originalName,
              ("outputs" Core..=) Core.<$> outputs,
              ("parDo" Core..=) Core.<$> parDo,
              ("partialGroupByKey" Core..=) Core.<$> partialGroupByKey,
              ("read" Core..=) Core.<$> read,
              ("systemName" Core..=) Core.<$> systemName,
              ("write" Core..=) Core.<$> write
            ]
        )
  
  -- | Structured data associated with this message.
  --
  -- /See:/ 'newParameter' smart constructor.
  data Parameter = Parameter
    { -- | Key or name for this parameter.
      key :: (Core.Maybe Core.Text),
      -- | Value for this parameter.
      value :: (Core.Maybe Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Parameter' with the minimum fields required to make a request.
  newParameter ::
    Parameter
  newParameter = Parameter {key = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON Parameter where
    parseJSON =
      Core.withObject
        "Parameter"
        ( \o ->
            Parameter
              Core.<$> (o Core..:? "key")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON Parameter where
    toJSON Parameter {..} =
      Core.object
        ( Core.catMaybes
            [("key" Core..=) Core.<$> key, ("value" Core..=) Core.<$> value]
        )
  
  -- | Metadata for a specific parameter.
  --
  -- /See:/ 'newParameterMetadata' smart constructor.
  data ParameterMetadata = ParameterMetadata
    { -- | Optional. Additional metadata for describing this parameter.
      customMetadata :: (Core.Maybe ParameterMetadata_CustomMetadata),
      -- | Optional. The default values will pre-populate the parameter with the given value from the proto. If default_value is left empty, the parameter will be populated with a default of the relevant type, e.g. false for a boolean.
      defaultValue :: (Core.Maybe Core.Text),
      -- | Optional. The options shown when ENUM ParameterType is specified.
      enumOptions :: (Core.Maybe [ParameterMetadataEnumOption]),
      -- | Optional. Specifies a group name for this parameter to be rendered under. Group header text will be rendered exactly as specified in this field. Only considered when parent_name is NOT provided.
      groupName :: (Core.Maybe Core.Text),
      -- | Required. The help text to display for the parameter.
      helpText :: (Core.Maybe Core.Text),
      -- | Optional. Whether the parameter should be hidden in the UI.
      hiddenUi :: (Core.Maybe Core.Bool),
      -- | Optional. Whether the parameter is optional. Defaults to false.
      isOptional :: (Core.Maybe Core.Bool),
      -- | Required. The label to display for the parameter.
      label :: (Core.Maybe Core.Text),
      -- | Required. The name of the parameter.
      name :: (Core.Maybe Core.Text),
      -- | Optional. The type of the parameter. Used for selecting input picker.
      paramType :: (Core.Maybe ParameterMetadata_ParamType),
      -- | Optional. Specifies the name of the parent parameter. Used in conjunction with \'parent/trigger/values\' to make this parameter conditional (will only be rendered conditionally). Should be mappable to a ParameterMetadata.name field.
      parentName :: (Core.Maybe Core.Text),
      -- | Optional. The value(s) of the \'parent/name\' parameter which will trigger this parameter to be shown. If left empty, ANY non-empty value in parent/name will trigger this parameter to be shown. Only considered when this parameter is conditional (when \'parent_name\' has been provided).
      parentTriggerValues :: (Core.Maybe [Core.Text]),
      -- | Optional. Regexes that the parameter must match.
      regexes :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParameterMetadata' with the minimum fields required to make a request.
  newParameterMetadata ::
    ParameterMetadata
  newParameterMetadata =
    ParameterMetadata
      { customMetadata = Core.Nothing,
        defaultValue = Core.Nothing,
        enumOptions = Core.Nothing,
        groupName = Core.Nothing,
        helpText = Core.Nothing,
        hiddenUi = Core.Nothing,
        isOptional = Core.Nothing,
        label = Core.Nothing,
        name = Core.Nothing,
        paramType = Core.Nothing,
        parentName = Core.Nothing,
        parentTriggerValues = Core.Nothing,
        regexes = Core.Nothing
      }
  
  instance Core.FromJSON ParameterMetadata where
    parseJSON =
      Core.withObject
        "ParameterMetadata"
        ( \o ->
            ParameterMetadata
              Core.<$> (o Core..:? "customMetadata")
              Core.<*> (o Core..:? "defaultValue")
              Core.<*> (o Core..:? "enumOptions")
              Core.<*> (o Core..:? "groupName")
              Core.<*> (o Core..:? "helpText")
              Core.<*> (o Core..:? "hiddenUi")
              Core.<*> (o Core..:? "isOptional")
              Core.<*> (o Core..:? "label")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "paramType")
              Core.<*> (o Core..:? "parentName")
              Core.<*> (o Core..:? "parentTriggerValues")
              Core.<*> (o Core..:? "regexes")
        )
  
  instance Core.ToJSON ParameterMetadata where
    toJSON ParameterMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("customMetadata" Core..=) Core.<$> customMetadata,
              ("defaultValue" Core..=) Core.<$> defaultValue,
              ("enumOptions" Core..=) Core.<$> enumOptions,
              ("groupName" Core..=) Core.<$> groupName,
              ("helpText" Core..=) Core.<$> helpText,
              ("hiddenUi" Core..=) Core.<$> hiddenUi,
              ("isOptional" Core..=) Core.<$> isOptional,
              ("label" Core..=) Core.<$> label,
              ("name" Core..=) Core.<$> name,
              ("paramType" Core..=) Core.<$> paramType,
              ("parentName" Core..=) Core.<$> parentName,
              ("parentTriggerValues" Core..=) Core.<$> parentTriggerValues,
              ("regexes" Core..=) Core.<$> regexes
            ]
        )
  
  -- | Optional. Additional metadata for describing this parameter.
  --
  -- /See:/ 'newParameterMetadata_CustomMetadata' smart constructor.
  newtype ParameterMetadata_CustomMetadata = ParameterMetadata_CustomMetadata
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParameterMetadata_CustomMetadata' with the minimum fields required to make a request.
  newParameterMetadata_CustomMetadata ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    ParameterMetadata_CustomMetadata
  newParameterMetadata_CustomMetadata additional =
    ParameterMetadata_CustomMetadata {additional = additional}
  
  instance Core.FromJSON ParameterMetadata_CustomMetadata where
    parseJSON =
      Core.withObject
        "ParameterMetadata_CustomMetadata"
        ( \o ->
            ParameterMetadata_CustomMetadata Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON ParameterMetadata_CustomMetadata where
    toJSON ParameterMetadata_CustomMetadata {..} =
      Core.toJSON additional
  
  -- | ParameterMetadataEnumOption specifies the option shown in the enum form.
  --
  -- /See:/ 'newParameterMetadataEnumOption' smart constructor.
  data ParameterMetadataEnumOption = ParameterMetadataEnumOption
    { -- | Optional. The description to display for the enum option.
      description :: (Core.Maybe Core.Text),
      -- | Optional. The label to display for the enum option.
      label :: (Core.Maybe Core.Text),
      -- | Required. The value of the enum option.
      value :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ParameterMetadataEnumOption' with the minimum fields required to make a request.
  newParameterMetadataEnumOption ::
    ParameterMetadataEnumOption
  newParameterMetadataEnumOption =
    ParameterMetadataEnumOption
      { description = Core.Nothing,
        label = Core.Nothing,
        value = Core.Nothing
      }
  
  instance Core.FromJSON ParameterMetadataEnumOption where
    parseJSON =
      Core.withObject
        "ParameterMetadataEnumOption"
        ( \o ->
            ParameterMetadataEnumOption
              Core.<$> (o Core..:? "description")
              Core.<*> (o Core..:? "label")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON ParameterMetadataEnumOption where
    toJSON ParameterMetadataEnumOption {..} =
      Core.object
        ( Core.catMaybes
            [ ("description" Core..=) Core.<$> description,
              ("label" Core..=) Core.<$> label,
              ("value" Core..=) Core.<$> value
            ]
        )
  
  -- | An instruction that does a partial group-by-key. One input and one output.
  --
  -- /See:/ 'newPartialGroupByKeyInstruction' smart constructor.
  data PartialGroupByKeyInstruction = PartialGroupByKeyInstruction
    { -- | Describes the input to the partial group-by-key instruction.
      input :: (Core.Maybe InstructionInput),
      -- | The codec to use for interpreting an element in the input PTable.
      inputElementCodec :: (Core.Maybe PartialGroupByKeyInstruction_InputElementCodec),
      -- | If this instruction includes a combining function this is the name of the intermediate store between the GBK and the CombineValues.
      originalCombineValuesInputStoreName :: (Core.Maybe Core.Text),
      -- | If this instruction includes a combining function, this is the name of the CombineValues instruction lifted into this instruction.
      originalCombineValuesStepName :: (Core.Maybe Core.Text),
      -- | Zero or more side inputs.
      sideInputs :: (Core.Maybe [SideInputInfo]),
      -- | The value combining function to invoke.
      valueCombiningFn :: (Core.Maybe PartialGroupByKeyInstruction_ValueCombiningFn)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PartialGroupByKeyInstruction' with the minimum fields required to make a request.
  newPartialGroupByKeyInstruction ::
    PartialGroupByKeyInstruction
  newPartialGroupByKeyInstruction =
    PartialGroupByKeyInstruction
      { input = Core.Nothing,
        inputElementCodec = Core.Nothing,
        originalCombineValuesInputStoreName = Core.Nothing,
        originalCombineValuesStepName = Core.Nothing,
        sideInputs = Core.Nothing,
        valueCombiningFn = Core.Nothing
      }
  
  instance Core.FromJSON PartialGroupByKeyInstruction where
    parseJSON =
      Core.withObject
        "PartialGroupByKeyInstruction"
        ( \o ->
            PartialGroupByKeyInstruction
              Core.<$> (o Core..:? "input")
              Core.<*> (o Core..:? "inputElementCodec")
              Core.<*> (o Core..:? "originalCombineValuesInputStoreName")
              Core.<*> (o Core..:? "originalCombineValuesStepName")
              Core.<*> (o Core..:? "sideInputs")
              Core.<*> (o Core..:? "valueCombiningFn")
        )
  
  instance Core.ToJSON PartialGroupByKeyInstruction where
    toJSON PartialGroupByKeyInstruction {..} =
      Core.object
        ( Core.catMaybes
            [ ("input" Core..=) Core.<$> input,
              ("inputElementCodec" Core..=) Core.<$> inputElementCodec,
              ("originalCombineValuesInputStoreName" Core..=)
                Core.<$> originalCombineValuesInputStoreName,
              ("originalCombineValuesStepName" Core..=)
                Core.<$> originalCombineValuesStepName,
              ("sideInputs" Core..=) Core.<$> sideInputs,
              ("valueCombiningFn" Core..=) Core.<$> valueCombiningFn
            ]
        )
  
  -- | The codec to use for interpreting an element in the input PTable.
  --
  -- /See:/ 'newPartialGroupByKeyInstruction_InputElementCodec' smart constructor.
  newtype PartialGroupByKeyInstruction_InputElementCodec = PartialGroupByKeyInstruction_InputElementCodec
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PartialGroupByKeyInstruction_InputElementCodec' with the minimum fields required to make a request.
  newPartialGroupByKeyInstruction_InputElementCodec ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    PartialGroupByKeyInstruction_InputElementCodec
  newPartialGroupByKeyInstruction_InputElementCodec additional =
    PartialGroupByKeyInstruction_InputElementCodec
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      PartialGroupByKeyInstruction_InputElementCodec
    where
    parseJSON =
      Core.withObject
        "PartialGroupByKeyInstruction_InputElementCodec"
        ( \o ->
            PartialGroupByKeyInstruction_InputElementCodec
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON PartialGroupByKeyInstruction_InputElementCodec where
    toJSON PartialGroupByKeyInstruction_InputElementCodec {..} =
      Core.toJSON additional
  
  -- | The value combining function to invoke.
  --
  -- /See:/ 'newPartialGroupByKeyInstruction_ValueCombiningFn' smart constructor.
  newtype PartialGroupByKeyInstruction_ValueCombiningFn = PartialGroupByKeyInstruction_ValueCombiningFn
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PartialGroupByKeyInstruction_ValueCombiningFn' with the minimum fields required to make a request.
  newPartialGroupByKeyInstruction_ValueCombiningFn ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    PartialGroupByKeyInstruction_ValueCombiningFn
  newPartialGroupByKeyInstruction_ValueCombiningFn additional =
    PartialGroupByKeyInstruction_ValueCombiningFn
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      PartialGroupByKeyInstruction_ValueCombiningFn
    where
    parseJSON =
      Core.withObject
        "PartialGroupByKeyInstruction_ValueCombiningFn"
        ( \o ->
            PartialGroupByKeyInstruction_ValueCombiningFn
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON PartialGroupByKeyInstruction_ValueCombiningFn where
    toJSON PartialGroupByKeyInstruction_ValueCombiningFn {..} =
      Core.toJSON additional
  
  -- | Metrics for a particular unfused step and namespace. A metric is uniquely identified by the @metrics_namespace@, @original_step@, @metric name@ and @metric_labels@.
  --
  -- /See:/ 'newPerStepNamespaceMetrics' smart constructor.
  data PerStepNamespaceMetrics = PerStepNamespaceMetrics
    { -- | Optional. Metrics that are recorded for this namespace and unfused step.
      metricValues :: (Core.Maybe [MetricValue]),
      -- | The namespace of these metrics on the worker.
      metricsNamespace :: (Core.Maybe Core.Text),
      -- | The original system name of the unfused step that these metrics are reported from.
      originalStep :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PerStepNamespaceMetrics' with the minimum fields required to make a request.
  newPerStepNamespaceMetrics ::
    PerStepNamespaceMetrics
  newPerStepNamespaceMetrics =
    PerStepNamespaceMetrics
      { metricValues = Core.Nothing,
        metricsNamespace = Core.Nothing,
        originalStep = Core.Nothing
      }
  
  instance Core.FromJSON PerStepNamespaceMetrics where
    parseJSON =
      Core.withObject
        "PerStepNamespaceMetrics"
        ( \o ->
            PerStepNamespaceMetrics
              Core.<$> (o Core..:? "metricValues")
              Core.<*> (o Core..:? "metricsNamespace")
              Core.<*> (o Core..:? "originalStep")
        )
  
  instance Core.ToJSON PerStepNamespaceMetrics where
    toJSON PerStepNamespaceMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("metricValues" Core..=) Core.<$> metricValues,
              ("metricsNamespace" Core..=) Core.<$> metricsNamespace,
              ("originalStep" Core..=) Core.<$> originalStep
            ]
        )
  
  -- | Per worker metrics.
  --
  -- /See:/ 'newPerWorkerMetrics' smart constructor.
  newtype PerWorkerMetrics = PerWorkerMetrics
    { -- | Optional. Metrics for a particular unfused step and namespace.
      perStepNamespaceMetrics :: (Core.Maybe [PerStepNamespaceMetrics])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PerWorkerMetrics' with the minimum fields required to make a request.
  newPerWorkerMetrics ::
    PerWorkerMetrics
  newPerWorkerMetrics =
    PerWorkerMetrics {perStepNamespaceMetrics = Core.Nothing}
  
  instance Core.FromJSON PerWorkerMetrics where
    parseJSON =
      Core.withObject
        "PerWorkerMetrics"
        ( \o ->
            PerWorkerMetrics Core.<$> (o Core..:? "perStepNamespaceMetrics")
        )
  
  instance Core.ToJSON PerWorkerMetrics where
    toJSON PerWorkerMetrics {..} =
      Core.object
        ( Core.catMaybes
            [ ("perStepNamespaceMetrics" Core..=)
                Core.<$> perStepNamespaceMetrics
            ]
        )
  
  -- | A descriptive representation of submitted pipeline as well as the executed form. This data is provided by the Dataflow service for ease of visualizing the pipeline and interpreting Dataflow provided metrics.
  --
  -- /See:/ 'newPipelineDescription' smart constructor.
  data PipelineDescription = PipelineDescription
    { -- | Pipeline level display data.
      displayData :: (Core.Maybe [DisplayData]),
      -- | Description of each stage of execution of the pipeline.
      executionPipelineStage :: (Core.Maybe [ExecutionStageSummary]),
      -- | Description of each transform in the pipeline and collections between them.
      originalPipelineTransform :: (Core.Maybe [TransformSummary]),
      -- | A hash value of the submitted pipeline portable graph step names if exists.
      stepNamesHash :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PipelineDescription' with the minimum fields required to make a request.
  newPipelineDescription ::
    PipelineDescription
  newPipelineDescription =
    PipelineDescription
      { displayData = Core.Nothing,
        executionPipelineStage = Core.Nothing,
        originalPipelineTransform = Core.Nothing,
        stepNamesHash = Core.Nothing
      }
  
  instance Core.FromJSON PipelineDescription where
    parseJSON =
      Core.withObject
        "PipelineDescription"
        ( \o ->
            PipelineDescription
              Core.<$> (o Core..:? "displayData")
              Core.<*> (o Core..:? "executionPipelineStage")
              Core.<*> (o Core..:? "originalPipelineTransform")
              Core.<*> (o Core..:? "stepNamesHash")
        )
  
  instance Core.ToJSON PipelineDescription where
    toJSON PipelineDescription {..} =
      Core.object
        ( Core.catMaybes
            [ ("displayData" Core..=) Core.<$> displayData,
              ("executionPipelineStage" Core..=) Core.<$> executionPipelineStage,
              ("originalPipelineTransform" Core..=)
                Core.<$> originalPipelineTransform,
              ("stepNamesHash" Core..=) Core.<$> stepNamesHash
            ]
        )
  
  -- | A point in the timeseries.
  --
  -- /See:/ 'newPoint' smart constructor.
  data Point = Point
    { -- | The timestamp of the point.
      time :: (Core.Maybe Core.DateTime),
      -- | The value of the point.
      value :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Point' with the minimum fields required to make a request.
  newPoint ::
    Point
  newPoint = Point {time = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON Point where
    parseJSON =
      Core.withObject
        "Point"
        ( \o ->
            Point Core.<$> (o Core..:? "time") Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON Point where
    toJSON Point {..} =
      Core.object
        ( Core.catMaybes
            [("time" Core..=) Core.<$> time, ("value" Core..=) Core.<$> value]
        )
  
  -- | Position defines a position within a collection of data. The value can be either the end position, a key (used with ordered collections), a byte offset, or a record index.
  --
  -- /See:/ 'newPosition' smart constructor.
  data Position = Position
    { -- | Position is a byte offset.
      byteOffset :: (Core.Maybe Core.Int64),
      -- | CloudPosition is a concat position.
      concatPosition :: (Core.Maybe ConcatPosition),
      -- | Position is past all other positions. Also useful for the end position of an unbounded range.
      end :: (Core.Maybe Core.Bool),
      -- | Position is a string key, ordered lexicographically.
      key :: (Core.Maybe Core.Text),
      -- | Position is a record index.
      recordIndex :: (Core.Maybe Core.Int64),
      -- | CloudPosition is a base64 encoded BatchShufflePosition (with FIXED sharding).
      shufflePosition :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Position' with the minimum fields required to make a request.
  newPosition ::
    Position
  newPosition =
    Position
      { byteOffset = Core.Nothing,
        concatPosition = Core.Nothing,
        end = Core.Nothing,
        key = Core.Nothing,
        recordIndex = Core.Nothing,
        shufflePosition = Core.Nothing
      }
  
  instance Core.FromJSON Position where
    parseJSON =
      Core.withObject
        "Position"
        ( \o ->
            Position
              Core.<$> (o Core..:? "byteOffset" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "concatPosition")
              Core.<*> (o Core..:? "end")
              Core.<*> (o Core..:? "key")
              Core.<*> (o Core..:? "recordIndex" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "shufflePosition")
        )
  
  instance Core.ToJSON Position where
    toJSON Position {..} =
      Core.object
        ( Core.catMaybes
            [ ("byteOffset" Core..=) Core.. Core.AsText Core.<$> byteOffset,
              ("concatPosition" Core..=) Core.<$> concatPosition,
              ("end" Core..=) Core.<$> end,
              ("key" Core..=) Core.<$> key,
              ("recordIndex" Core..=) Core.. Core.AsText Core.<$> recordIndex,
              ("shufflePosition" Core..=) Core.<$> shufflePosition
            ]
        )
  
  -- | Information about the progress of some component of job execution.
  --
  -- /See:/ 'newProgressTimeseries' smart constructor.
  data ProgressTimeseries = ProgressTimeseries
    { -- | The current progress of the component, in the range [0,1].
      currentProgress :: (Core.Maybe Core.Double),
      -- | History of progress for the component. Points are sorted by time.
      dataPoints :: (Core.Maybe [Point])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ProgressTimeseries' with the minimum fields required to make a request.
  newProgressTimeseries ::
    ProgressTimeseries
  newProgressTimeseries =
    ProgressTimeseries
      { currentProgress = Core.Nothing,
        dataPoints = Core.Nothing
      }
  
  instance Core.FromJSON ProgressTimeseries where
    parseJSON =
      Core.withObject
        "ProgressTimeseries"
        ( \o ->
            ProgressTimeseries
              Core.<$> (o Core..:? "currentProgress")
              Core.<*> (o Core..:? "dataPoints")
        )
  
  instance Core.ToJSON ProgressTimeseries where
    toJSON ProgressTimeseries {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentProgress" Core..=) Core.<$> currentProgress,
              ("dataPoints" Core..=) Core.<$> dataPoints
            ]
        )
  
  -- | Metadata for a Pub\/Sub connector used by the job.
  --
  -- /See:/ 'newPubSubIODetails' smart constructor.
  data PubSubIODetails = PubSubIODetails
    { -- | Subscription used in the connection.
      subscription :: (Core.Maybe Core.Text),
      -- | Topic accessed in the connection.
      topic :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PubSubIODetails' with the minimum fields required to make a request.
  newPubSubIODetails ::
    PubSubIODetails
  newPubSubIODetails =
    PubSubIODetails
      { subscription = Core.Nothing,
        topic = Core.Nothing
      }
  
  instance Core.FromJSON PubSubIODetails where
    parseJSON =
      Core.withObject
        "PubSubIODetails"
        ( \o ->
            PubSubIODetails
              Core.<$> (o Core..:? "subscription")
              Core.<*> (o Core..:? "topic")
        )
  
  instance Core.ToJSON PubSubIODetails where
    toJSON PubSubIODetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("subscription" Core..=) Core.<$> subscription,
              ("topic" Core..=) Core.<$> topic
            ]
        )
  
  -- | Identifies a pubsub location to use for transferring data into or out of a streaming Dataflow job.
  --
  -- /See:/ 'newPubsubLocation' smart constructor.
  data PubsubLocation = PubsubLocation
    { -- | Indicates whether the pipeline allows late-arriving data.
      dropLateData :: (Core.Maybe Core.Bool),
      -- | If true, then this location represents dynamic topics.
      dynamicDestinations :: (Core.Maybe Core.Bool),
      -- | If set, contains a pubsub label from which to extract record ids. If left empty, record deduplication will be strictly best effort.
      idLabel :: (Core.Maybe Core.Text),
      -- | A pubsub subscription, in the form of \"pubsub.googleapis.com\/subscriptions\/\/\"
      subscription :: (Core.Maybe Core.Text),
      -- | If set, contains a pubsub label from which to extract record timestamps. If left empty, record timestamps will be generated upon arrival.
      timestampLabel :: (Core.Maybe Core.Text),
      -- | A pubsub topic, in the form of \"pubsub.googleapis.com\/topics\/\/\"
      topic :: (Core.Maybe Core.Text),
      -- | If set, specifies the pubsub subscription that will be used for tracking custom time timestamps for watermark estimation.
      trackingSubscription :: (Core.Maybe Core.Text),
      -- | If true, then the client has requested to get pubsub attributes.
      withAttributes :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PubsubLocation' with the minimum fields required to make a request.
  newPubsubLocation ::
    PubsubLocation
  newPubsubLocation =
    PubsubLocation
      { dropLateData = Core.Nothing,
        dynamicDestinations = Core.Nothing,
        idLabel = Core.Nothing,
        subscription = Core.Nothing,
        timestampLabel = Core.Nothing,
        topic = Core.Nothing,
        trackingSubscription = Core.Nothing,
        withAttributes = Core.Nothing
      }
  
  instance Core.FromJSON PubsubLocation where
    parseJSON =
      Core.withObject
        "PubsubLocation"
        ( \o ->
            PubsubLocation
              Core.<$> (o Core..:? "dropLateData")
              Core.<*> (o Core..:? "dynamicDestinations")
              Core.<*> (o Core..:? "idLabel")
              Core.<*> (o Core..:? "subscription")
              Core.<*> (o Core..:? "timestampLabel")
              Core.<*> (o Core..:? "topic")
              Core.<*> (o Core..:? "trackingSubscription")
              Core.<*> (o Core..:? "withAttributes")
        )
  
  instance Core.ToJSON PubsubLocation where
    toJSON PubsubLocation {..} =
      Core.object
        ( Core.catMaybes
            [ ("dropLateData" Core..=) Core.<$> dropLateData,
              ("dynamicDestinations" Core..=) Core.<$> dynamicDestinations,
              ("idLabel" Core..=) Core.<$> idLabel,
              ("subscription" Core..=) Core.<$> subscription,
              ("timestampLabel" Core..=) Core.<$> timestampLabel,
              ("topic" Core..=) Core.<$> topic,
              ("trackingSubscription" Core..=) Core.<$> trackingSubscription,
              ("withAttributes" Core..=) Core.<$> withAttributes
            ]
        )
  
  -- | Represents a Pubsub snapshot.
  --
  -- /See:/ 'newPubsubSnapshotMetadata' smart constructor.
  data PubsubSnapshotMetadata = PubsubSnapshotMetadata
    { -- | The expire time of the Pubsub snapshot.
      expireTime :: (Core.Maybe Core.DateTime),
      -- | The name of the Pubsub snapshot.
      snapshotName :: (Core.Maybe Core.Text),
      -- | The name of the Pubsub topic.
      topicName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PubsubSnapshotMetadata' with the minimum fields required to make a request.
  newPubsubSnapshotMetadata ::
    PubsubSnapshotMetadata
  newPubsubSnapshotMetadata =
    PubsubSnapshotMetadata
      { expireTime = Core.Nothing,
        snapshotName = Core.Nothing,
        topicName = Core.Nothing
      }
  
  instance Core.FromJSON PubsubSnapshotMetadata where
    parseJSON =
      Core.withObject
        "PubsubSnapshotMetadata"
        ( \o ->
            PubsubSnapshotMetadata
              Core.<$> (o Core..:? "expireTime")
              Core.<*> (o Core..:? "snapshotName")
              Core.<*> (o Core..:? "topicName")
        )
  
  instance Core.ToJSON PubsubSnapshotMetadata where
    toJSON PubsubSnapshotMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("expireTime" Core..=) Core.<$> expireTime,
              ("snapshotName" Core..=) Core.<$> snapshotName,
              ("topicName" Core..=) Core.<$> topicName
            ]
        )
  
  -- | An instruction that reads records. Takes no inputs, produces one output.
  --
  -- /See:/ 'newReadInstruction' smart constructor.
  newtype ReadInstruction = ReadInstruction
    { -- | The source to read from.
      source :: (Core.Maybe Source)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReadInstruction' with the minimum fields required to make a request.
  newReadInstruction ::
    ReadInstruction
  newReadInstruction = ReadInstruction {source = Core.Nothing}
  
  instance Core.FromJSON ReadInstruction where
    parseJSON =
      Core.withObject
        "ReadInstruction"
        (\o -> ReadInstruction Core.<$> (o Core..:? "source"))
  
  instance Core.ToJSON ReadInstruction where
    toJSON ReadInstruction {..} =
      Core.object (Core.catMaybes [("source" Core..=) Core.<$> source])
  
  -- | Request to report the status of WorkItems.
  --
  -- /See:/ 'newReportWorkItemStatusRequest' smart constructor.
  data ReportWorkItemStatusRequest = ReportWorkItemStatusRequest
    { -- | The current timestamp at the worker.
      currentWorkerTime :: (Core.Maybe Core.DateTime),
      -- | The [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that contains the WorkItem\'s job.
      location :: (Core.Maybe Core.Text),
      -- | Optional. The project number of the project which owns the WorkItem\'s job.
      projectNumber :: (Core.Maybe Core.Int64),
      -- | Untranslated bag-of-bytes WorkProgressUpdateRequest from UnifiedWorker.
      unifiedWorkerRequest :: (Core.Maybe ReportWorkItemStatusRequest_UnifiedWorkerRequest),
      -- | The order is unimportant, except that the order of the WorkItemServiceState messages in the ReportWorkItemStatusResponse corresponds to the order of WorkItemStatus messages here.
      workItemStatuses :: (Core.Maybe [WorkItemStatus]),
      -- | The ID of the worker reporting the WorkItem status. If this does not match the ID of the worker which the Dataflow service believes currently has the lease on the WorkItem, the report will be dropped (with an error response).
      workerId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReportWorkItemStatusRequest' with the minimum fields required to make a request.
  newReportWorkItemStatusRequest ::
    ReportWorkItemStatusRequest
  newReportWorkItemStatusRequest =
    ReportWorkItemStatusRequest
      { currentWorkerTime = Core.Nothing,
        location = Core.Nothing,
        projectNumber = Core.Nothing,
        unifiedWorkerRequest = Core.Nothing,
        workItemStatuses = Core.Nothing,
        workerId = Core.Nothing
      }
  
  instance Core.FromJSON ReportWorkItemStatusRequest where
    parseJSON =
      Core.withObject
        "ReportWorkItemStatusRequest"
        ( \o ->
            ReportWorkItemStatusRequest
              Core.<$> (o Core..:? "currentWorkerTime")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "projectNumber" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "unifiedWorkerRequest")
              Core.<*> (o Core..:? "workItemStatuses")
              Core.<*> (o Core..:? "workerId")
        )
  
  instance Core.ToJSON ReportWorkItemStatusRequest where
    toJSON ReportWorkItemStatusRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentWorkerTime" Core..=) Core.<$> currentWorkerTime,
              ("location" Core..=) Core.<$> location,
              ("projectNumber" Core..=)
                Core.. Core.AsText
                Core.<$> projectNumber,
              ("unifiedWorkerRequest" Core..=) Core.<$> unifiedWorkerRequest,
              ("workItemStatuses" Core..=) Core.<$> workItemStatuses,
              ("workerId" Core..=) Core.<$> workerId
            ]
        )
  
  -- | Untranslated bag-of-bytes WorkProgressUpdateRequest from UnifiedWorker.
  --
  -- /See:/ 'newReportWorkItemStatusRequest_UnifiedWorkerRequest' smart constructor.
  newtype ReportWorkItemStatusRequest_UnifiedWorkerRequest = ReportWorkItemStatusRequest_UnifiedWorkerRequest
    { -- | 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 'ReportWorkItemStatusRequest_UnifiedWorkerRequest' with the minimum fields required to make a request.
  newReportWorkItemStatusRequest_UnifiedWorkerRequest ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    ReportWorkItemStatusRequest_UnifiedWorkerRequest
  newReportWorkItemStatusRequest_UnifiedWorkerRequest additional =
    ReportWorkItemStatusRequest_UnifiedWorkerRequest
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      ReportWorkItemStatusRequest_UnifiedWorkerRequest
    where
    parseJSON =
      Core.withObject
        "ReportWorkItemStatusRequest_UnifiedWorkerRequest"
        ( \o ->
            ReportWorkItemStatusRequest_UnifiedWorkerRequest
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance
    Core.ToJSON
      ReportWorkItemStatusRequest_UnifiedWorkerRequest
    where
    toJSON ReportWorkItemStatusRequest_UnifiedWorkerRequest {..} =
      Core.toJSON additional
  
  -- | Response from a request to report the status of WorkItems.
  --
  -- /See:/ 'newReportWorkItemStatusResponse' smart constructor.
  data ReportWorkItemStatusResponse = ReportWorkItemStatusResponse
    { -- | Untranslated bag-of-bytes WorkProgressUpdateResponse for UnifiedWorker.
      unifiedWorkerResponse :: (Core.Maybe ReportWorkItemStatusResponse_UnifiedWorkerResponse),
      -- | A set of messages indicating the service-side state for each WorkItem whose status was reported, in the same order as the WorkItemStatus messages in the ReportWorkItemStatusRequest which resulting in this response.
      workItemServiceStates :: (Core.Maybe [WorkItemServiceState])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReportWorkItemStatusResponse' with the minimum fields required to make a request.
  newReportWorkItemStatusResponse ::
    ReportWorkItemStatusResponse
  newReportWorkItemStatusResponse =
    ReportWorkItemStatusResponse
      { unifiedWorkerResponse =
          Core.Nothing,
        workItemServiceStates = Core.Nothing
      }
  
  instance Core.FromJSON ReportWorkItemStatusResponse where
    parseJSON =
      Core.withObject
        "ReportWorkItemStatusResponse"
        ( \o ->
            ReportWorkItemStatusResponse
              Core.<$> (o Core..:? "unifiedWorkerResponse")
              Core.<*> (o Core..:? "workItemServiceStates")
        )
  
  instance Core.ToJSON ReportWorkItemStatusResponse where
    toJSON ReportWorkItemStatusResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("unifiedWorkerResponse" Core..=) Core.<$> unifiedWorkerResponse,
              ("workItemServiceStates" Core..=) Core.<$> workItemServiceStates
            ]
        )
  
  -- | Untranslated bag-of-bytes WorkProgressUpdateResponse for UnifiedWorker.
  --
  -- /See:/ 'newReportWorkItemStatusResponse_UnifiedWorkerResponse' smart constructor.
  newtype ReportWorkItemStatusResponse_UnifiedWorkerResponse = ReportWorkItemStatusResponse_UnifiedWorkerResponse
    { -- | 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 'ReportWorkItemStatusResponse_UnifiedWorkerResponse' with the minimum fields required to make a request.
  newReportWorkItemStatusResponse_UnifiedWorkerResponse ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    ReportWorkItemStatusResponse_UnifiedWorkerResponse
  newReportWorkItemStatusResponse_UnifiedWorkerResponse additional =
    ReportWorkItemStatusResponse_UnifiedWorkerResponse
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      ReportWorkItemStatusResponse_UnifiedWorkerResponse
    where
    parseJSON =
      Core.withObject
        "ReportWorkItemStatusResponse_UnifiedWorkerResponse"
        ( \o ->
            ReportWorkItemStatusResponse_UnifiedWorkerResponse
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance
    Core.ToJSON
      ReportWorkItemStatusResponse_UnifiedWorkerResponse
    where
    toJSON ReportWorkItemStatusResponse_UnifiedWorkerResponse {..} =
      Core.toJSON additional
  
  -- | Represents the level of parallelism in a WorkItem\'s input, reported by the worker.
  --
  -- /See:/ 'newReportedParallelism' smart constructor.
  data ReportedParallelism = ReportedParallelism
    { -- | Specifies whether the parallelism is infinite. If true, \"value\" is ignored. Infinite parallelism means the service will assume that the work item can always be split into more non-empty work items by dynamic splitting. This is a work-around for lack of support for infinity by the current JSON-based Java RPC stack.
      isInfinite :: (Core.Maybe Core.Bool),
      -- | Specifies the level of parallelism in case it is finite.
      value :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ReportedParallelism' with the minimum fields required to make a request.
  newReportedParallelism ::
    ReportedParallelism
  newReportedParallelism =
    ReportedParallelism
      { isInfinite = Core.Nothing,
        value = Core.Nothing
      }
  
  instance Core.FromJSON ReportedParallelism where
    parseJSON =
      Core.withObject
        "ReportedParallelism"
        ( \o ->
            ReportedParallelism
              Core.<$> (o Core..:? "isInfinite")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON ReportedParallelism where
    toJSON ReportedParallelism {..} =
      Core.object
        ( Core.catMaybes
            [ ("isInfinite" Core..=) Core.<$> isInfinite,
              ("value" Core..=) Core.<$> value
            ]
        )
  
  -- | Worker metrics exported from workers. This contains resource utilization metrics accumulated from a variety of sources. For more information, see go\/df-resource-signals.
  --
  -- /See:/ 'newResourceUtilizationReport' smart constructor.
  data ResourceUtilizationReport = ResourceUtilizationReport
    { -- | Per container information. Key: container name.
      containers :: (Core.Maybe ResourceUtilizationReport_Containers),
      -- | CPU utilization samples.
      cpuTime :: (Core.Maybe [CPUTime]),
      -- | Optional. GPU usage samples.
      gpuUsage :: (Core.Maybe [GPUUsage]),
      -- | Memory utilization samples.
      memoryInfo :: (Core.Maybe [MemInfo])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceUtilizationReport' with the minimum fields required to make a request.
  newResourceUtilizationReport ::
    ResourceUtilizationReport
  newResourceUtilizationReport =
    ResourceUtilizationReport
      { containers = Core.Nothing,
        cpuTime = Core.Nothing,
        gpuUsage = Core.Nothing,
        memoryInfo = Core.Nothing
      }
  
  instance Core.FromJSON ResourceUtilizationReport where
    parseJSON =
      Core.withObject
        "ResourceUtilizationReport"
        ( \o ->
            ResourceUtilizationReport
              Core.<$> (o Core..:? "containers")
              Core.<*> (o Core..:? "cpuTime")
              Core.<*> (o Core..:? "gpuUsage")
              Core.<*> (o Core..:? "memoryInfo")
        )
  
  instance Core.ToJSON ResourceUtilizationReport where
    toJSON ResourceUtilizationReport {..} =
      Core.object
        ( Core.catMaybes
            [ ("containers" Core..=) Core.<$> containers,
              ("cpuTime" Core..=) Core.<$> cpuTime,
              ("gpuUsage" Core..=) Core.<$> gpuUsage,
              ("memoryInfo" Core..=) Core.<$> memoryInfo
            ]
        )
  
  -- | Per container information. Key: container name.
  --
  -- /See:/ 'newResourceUtilizationReport_Containers' smart constructor.
  newtype ResourceUtilizationReport_Containers = ResourceUtilizationReport_Containers
    { additional :: (Core.HashMap Core.Text ResourceUtilizationReport)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceUtilizationReport_Containers' with the minimum fields required to make a request.
  newResourceUtilizationReport_Containers ::
    -- |  See 'additional'.
    Core.HashMap Core.Text ResourceUtilizationReport ->
    ResourceUtilizationReport_Containers
  newResourceUtilizationReport_Containers additional =
    ResourceUtilizationReport_Containers {additional = additional}
  
  instance Core.FromJSON ResourceUtilizationReport_Containers where
    parseJSON =
      Core.withObject
        "ResourceUtilizationReport_Containers"
        ( \o ->
            ResourceUtilizationReport_Containers
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON ResourceUtilizationReport_Containers where
    toJSON ResourceUtilizationReport_Containers {..} =
      Core.toJSON additional
  
  -- | Service-side response to WorkerMessage reporting resource utilization.
  --
  -- /See:/ 'newResourceUtilizationReportResponse' smart constructor.
  data ResourceUtilizationReportResponse = ResourceUtilizationReportResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ResourceUtilizationReportResponse' with the minimum fields required to make a request.
  newResourceUtilizationReportResponse ::
    ResourceUtilizationReportResponse
  newResourceUtilizationReportResponse =
    ResourceUtilizationReportResponse
  
  instance Core.FromJSON ResourceUtilizationReportResponse where
    parseJSON =
      Core.withObject
        "ResourceUtilizationReportResponse"
        (\o -> Core.pure ResourceUtilizationReportResponse)
  
  instance Core.ToJSON ResourceUtilizationReportResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | The environment values to set at runtime.
  --
  -- /See:/ 'newRuntimeEnvironment' smart constructor.
  data RuntimeEnvironment = RuntimeEnvironment
    { -- | Optional. Additional experiment flags for the job, specified with the @--experiments@ option.
      additionalExperiments :: (Core.Maybe [Core.Text]),
      -- | Optional. Additional user labels to be specified for the job. Keys and values should follow the restrictions specified in the <https://cloud.google.com/compute/docs/labeling-resources#restrictions labeling restrictions> page. An object containing a list of \"key\": value pairs. Example: { \"name\": \"wrench\", \"mass\": \"1kg\", \"count\": \"3\" }.
      additionalUserLabels :: (Core.Maybe RuntimeEnvironment_AdditionalUserLabels),
      -- | Optional. Whether to bypass the safety checks for the job\'s temporary directory. Use with caution.
      bypassTempDirValidation :: (Core.Maybe Core.Bool),
      -- | Optional. The disk size, in gigabytes, to use on each remote Compute Engine worker instance.
      diskSizeGb :: (Core.Maybe Core.Int32),
      -- | Optional. Whether to enable Streaming Engine for the job.
      enableStreamingEngine :: (Core.Maybe Core.Bool),
      -- | Optional. Configuration for VM IPs.
      ipConfiguration :: (Core.Maybe RuntimeEnvironment_IpConfiguration),
      -- | Optional. Name for the Cloud KMS key for the job. Key format is: projects\/\/locations\/\/keyRings\/\/cryptoKeys\/
      kmsKeyName :: (Core.Maybe Core.Text),
      -- | Optional. The machine type to use for the job. Defaults to the value from the template if not specified.
      machineType :: (Core.Maybe Core.Text),
      -- | Optional. The maximum number of Google Compute Engine instances to be made available to your pipeline during execution, from 1 to 1000. The default value is 1.
      maxWorkers :: (Core.Maybe Core.Int32),
      -- | Optional. Network to which VMs will be assigned. If empty or unspecified, the service will use the network \"default\".
      network :: (Core.Maybe Core.Text),
      -- | Optional. The initial number of Google Compute Engine instances for the job. The default value is 11.
      numWorkers :: (Core.Maybe Core.Int32),
      -- | Optional. The email address of the service account to run the job as.
      serviceAccountEmail :: (Core.Maybe Core.Text),
      -- | Optional. Specifies the Streaming Engine message processing guarantees. Reduces cost and latency but might result in duplicate messages committed to storage. Designed to run simple mapping streaming ETL jobs at the lowest cost. For example, Change Data Capture (CDC) to BigQuery is a canonical use case. For more information, see <https://cloud.google.com/dataflow/docs/guides/streaming-modes Set the pipeline streaming mode>.
      streamingMode :: (Core.Maybe RuntimeEnvironment_StreamingMode),
      -- | Optional. Subnetwork to which VMs will be assigned, if desired. You can specify a subnetwork using either a complete URL or an abbreviated path. Expected to be of the form \"https:\/\/www.googleapis.com\/compute\/v1\/projects\/HOST/PROJECT/ID\/regions\/REGION\/subnetworks\/SUBNETWORK\" or \"regions\/REGION\/subnetworks\/SUBNETWORK\". If the subnetwork is located in a Shared VPC network, you must use the complete URL.
      subnetwork :: (Core.Maybe Core.Text),
      -- | Required. The Cloud Storage path to use for temporary files. Must be a valid Cloud Storage URL, beginning with @gs:\/\/@.
      tempLocation :: (Core.Maybe Core.Text),
      -- | Required. The Compute Engine region (https:\/\/cloud.google.com\/compute\/docs\/regions-zones\/regions-zones) in which worker processing should occur, e.g. \"us-west1\". Mutually exclusive with worker/zone. If neither worker/region nor worker_zone is specified, default to the control plane\'s region.
      workerRegion :: (Core.Maybe Core.Text),
      -- | Optional. The Compute Engine zone (https:\/\/cloud.google.com\/compute\/docs\/regions-zones\/regions-zones) in which worker processing should occur, e.g. \"us-west1-a\". Mutually exclusive with worker/region. If neither worker/region nor worker_zone is specified, a zone in the control plane\'s region is chosen based on available capacity. If both @worker_zone@ and @zone@ are set, @worker_zone@ takes precedence.
      workerZone :: (Core.Maybe Core.Text),
      -- | Optional. The Compute Engine <https://cloud.google.com/compute/docs/regions-zones/regions-zones availability zone> for launching worker instances to run your pipeline. In the future, worker_zone will take precedence.
      zone :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RuntimeEnvironment' with the minimum fields required to make a request.
  newRuntimeEnvironment ::
    RuntimeEnvironment
  newRuntimeEnvironment =
    RuntimeEnvironment
      { additionalExperiments = Core.Nothing,
        additionalUserLabels = Core.Nothing,
        bypassTempDirValidation = Core.Nothing,
        diskSizeGb = Core.Nothing,
        enableStreamingEngine = Core.Nothing,
        ipConfiguration = Core.Nothing,
        kmsKeyName = Core.Nothing,
        machineType = Core.Nothing,
        maxWorkers = Core.Nothing,
        network = Core.Nothing,
        numWorkers = Core.Nothing,
        serviceAccountEmail = Core.Nothing,
        streamingMode = Core.Nothing,
        subnetwork = Core.Nothing,
        tempLocation = Core.Nothing,
        workerRegion = Core.Nothing,
        workerZone = Core.Nothing,
        zone = Core.Nothing
      }
  
  instance Core.FromJSON RuntimeEnvironment where
    parseJSON =
      Core.withObject
        "RuntimeEnvironment"
        ( \o ->
            RuntimeEnvironment
              Core.<$> (o Core..:? "additionalExperiments")
              Core.<*> (o Core..:? "additionalUserLabels")
              Core.<*> (o Core..:? "bypassTempDirValidation")
              Core.<*> (o Core..:? "diskSizeGb")
              Core.<*> (o Core..:? "enableStreamingEngine")
              Core.<*> (o Core..:? "ipConfiguration")
              Core.<*> (o Core..:? "kmsKeyName")
              Core.<*> (o Core..:? "machineType")
              Core.<*> (o Core..:? "maxWorkers")
              Core.<*> (o Core..:? "network")
              Core.<*> (o Core..:? "numWorkers")
              Core.<*> (o Core..:? "serviceAccountEmail")
              Core.<*> (o Core..:? "streamingMode")
              Core.<*> (o Core..:? "subnetwork")
              Core.<*> (o Core..:? "tempLocation")
              Core.<*> (o Core..:? "workerRegion")
              Core.<*> (o Core..:? "workerZone")
              Core.<*> (o Core..:? "zone")
        )
  
  instance Core.ToJSON RuntimeEnvironment where
    toJSON RuntimeEnvironment {..} =
      Core.object
        ( Core.catMaybes
            [ ("additionalExperiments" Core..=) Core.<$> additionalExperiments,
              ("additionalUserLabels" Core..=) Core.<$> additionalUserLabels,
              ("bypassTempDirValidation" Core..=)
                Core.<$> bypassTempDirValidation,
              ("diskSizeGb" Core..=) Core.<$> diskSizeGb,
              ("enableStreamingEngine" Core..=) Core.<$> enableStreamingEngine,
              ("ipConfiguration" Core..=) Core.<$> ipConfiguration,
              ("kmsKeyName" Core..=) Core.<$> kmsKeyName,
              ("machineType" Core..=) Core.<$> machineType,
              ("maxWorkers" Core..=) Core.<$> maxWorkers,
              ("network" Core..=) Core.<$> network,
              ("numWorkers" Core..=) Core.<$> numWorkers,
              ("serviceAccountEmail" Core..=) Core.<$> serviceAccountEmail,
              ("streamingMode" Core..=) Core.<$> streamingMode,
              ("subnetwork" Core..=) Core.<$> subnetwork,
              ("tempLocation" Core..=) Core.<$> tempLocation,
              ("workerRegion" Core..=) Core.<$> workerRegion,
              ("workerZone" Core..=) Core.<$> workerZone,
              ("zone" Core..=) Core.<$> zone
            ]
        )
  
  -- | Optional. Additional user labels to be specified for the job. Keys and values should follow the restrictions specified in the <https://cloud.google.com/compute/docs/labeling-resources#restrictions labeling restrictions> page. An object containing a list of \"key\": value pairs. Example: { \"name\": \"wrench\", \"mass\": \"1kg\", \"count\": \"3\" }.
  --
  -- /See:/ 'newRuntimeEnvironment_AdditionalUserLabels' smart constructor.
  newtype RuntimeEnvironment_AdditionalUserLabels = RuntimeEnvironment_AdditionalUserLabels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RuntimeEnvironment_AdditionalUserLabels' with the minimum fields required to make a request.
  newRuntimeEnvironment_AdditionalUserLabels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    RuntimeEnvironment_AdditionalUserLabels
  newRuntimeEnvironment_AdditionalUserLabels additional =
    RuntimeEnvironment_AdditionalUserLabels {additional = additional}
  
  instance Core.FromJSON RuntimeEnvironment_AdditionalUserLabels where
    parseJSON =
      Core.withObject
        "RuntimeEnvironment_AdditionalUserLabels"
        ( \o ->
            RuntimeEnvironment_AdditionalUserLabels
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON RuntimeEnvironment_AdditionalUserLabels where
    toJSON RuntimeEnvironment_AdditionalUserLabels {..} =
      Core.toJSON additional
  
  -- | RuntimeMetadata describing a runtime environment.
  --
  -- /See:/ 'newRuntimeMetadata' smart constructor.
  data RuntimeMetadata = RuntimeMetadata
    { -- | The parameters for the template.
      parameters :: (Core.Maybe [ParameterMetadata]),
      -- | SDK Info for the template.
      sdkInfo :: (Core.Maybe SDKInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RuntimeMetadata' with the minimum fields required to make a request.
  newRuntimeMetadata ::
    RuntimeMetadata
  newRuntimeMetadata =
    RuntimeMetadata
      { parameters = Core.Nothing,
        sdkInfo = Core.Nothing
      }
  
  instance Core.FromJSON RuntimeMetadata where
    parseJSON =
      Core.withObject
        "RuntimeMetadata"
        ( \o ->
            RuntimeMetadata
              Core.<$> (o Core..:? "parameters")
              Core.<*> (o Core..:? "sdkInfo")
        )
  
  instance Core.ToJSON RuntimeMetadata where
    toJSON RuntimeMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("parameters" Core..=) Core.<$> parameters,
              ("sdkInfo" Core..=) Core.<$> sdkInfo
            ]
        )
  
  -- | Additional job parameters that can only be updated during runtime using the projects.jobs.update method. These fields have no effect when specified during job creation.
  --
  -- /See:/ 'newRuntimeUpdatableParams' smart constructor.
  data RuntimeUpdatableParams = RuntimeUpdatableParams
    { -- | The maximum number of workers to cap autoscaling at. This field is currently only supported for Streaming Engine jobs.
      maxNumWorkers :: (Core.Maybe Core.Int32),
      -- | The minimum number of workers to scale down to. This field is currently only supported for Streaming Engine jobs.
      minNumWorkers :: (Core.Maybe Core.Int32),
      -- | Target worker utilization, compared against the aggregate utilization of the worker pool by autoscaler, to determine upscaling and downscaling when absent other constraints such as backlog. For more information, see <https://cloud.google.com/dataflow/docs/guides/updating-a-pipeline Update an existing pipeline>.
      workerUtilizationHint :: (Core.Maybe Core.Double)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RuntimeUpdatableParams' with the minimum fields required to make a request.
  newRuntimeUpdatableParams ::
    RuntimeUpdatableParams
  newRuntimeUpdatableParams =
    RuntimeUpdatableParams
      { maxNumWorkers = Core.Nothing,
        minNumWorkers = Core.Nothing,
        workerUtilizationHint = Core.Nothing
      }
  
  instance Core.FromJSON RuntimeUpdatableParams where
    parseJSON =
      Core.withObject
        "RuntimeUpdatableParams"
        ( \o ->
            RuntimeUpdatableParams
              Core.<$> (o Core..:? "maxNumWorkers")
              Core.<*> (o Core..:? "minNumWorkers")
              Core.<*> (o Core..:? "workerUtilizationHint")
        )
  
  instance Core.ToJSON RuntimeUpdatableParams where
    toJSON RuntimeUpdatableParams {..} =
      Core.object
        ( Core.catMaybes
            [ ("maxNumWorkers" Core..=) Core.<$> maxNumWorkers,
              ("minNumWorkers" Core..=) Core.<$> minNumWorkers,
              ("workerUtilizationHint" Core..=) Core.<$> workerUtilizationHint
            ]
        )
  
  -- | SDK Information.
  --
  -- /See:/ 'newSDKInfo' smart constructor.
  data SDKInfo = SDKInfo
    { -- | Required. The SDK Language.
      language :: (Core.Maybe SDKInfo_Language),
      -- | Optional. The SDK version.
      version :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SDKInfo' with the minimum fields required to make a request.
  newSDKInfo ::
    SDKInfo
  newSDKInfo =
    SDKInfo {language = Core.Nothing, version = Core.Nothing}
  
  instance Core.FromJSON SDKInfo where
    parseJSON =
      Core.withObject
        "SDKInfo"
        ( \o ->
            SDKInfo
              Core.<$> (o Core..:? "language")
              Core.<*> (o Core..:? "version")
        )
  
  instance Core.ToJSON SDKInfo where
    toJSON SDKInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("language" Core..=) Core.<$> language,
              ("version" Core..=) Core.<$> version
            ]
        )
  
  -- | A bug found in the Dataflow SDK.
  --
  -- /See:/ 'newSdkBug' smart constructor.
  data SdkBug = SdkBug
    { -- | Output only. How severe the SDK bug is.
      severity :: (Core.Maybe SdkBug_Severity),
      -- | Output only. Describes the impact of this SDK bug.
      type' :: (Core.Maybe SdkBug_Type),
      -- | Output only. Link to more information on the bug.
      uri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SdkBug' with the minimum fields required to make a request.
  newSdkBug ::
    SdkBug
  newSdkBug =
    SdkBug
      { severity = Core.Nothing,
        type' = Core.Nothing,
        uri = Core.Nothing
      }
  
  instance Core.FromJSON SdkBug where
    parseJSON =
      Core.withObject
        "SdkBug"
        ( \o ->
            SdkBug
              Core.<$> (o Core..:? "severity")
              Core.<*> (o Core..:? "type")
              Core.<*> (o Core..:? "uri")
        )
  
  instance Core.ToJSON SdkBug where
    toJSON SdkBug {..} =
      Core.object
        ( Core.catMaybes
            [ ("severity" Core..=) Core.<$> severity,
              ("type" Core..=) Core.<$> type',
              ("uri" Core..=) Core.<$> uri
            ]
        )
  
  -- | Defines an SDK harness container for executing Dataflow pipelines.
  --
  -- /See:/ 'newSdkHarnessContainerImage' smart constructor.
  data SdkHarnessContainerImage = SdkHarnessContainerImage
    { -- | The set of capabilities enumerated in the above Environment proto. See also <https://github.com/apache/beam/blob/master/model/pipeline/src/main/proto/org/apache/beam/model/pipeline/v1/beam_runner_api.proto beamrunnerapi.proto>
      capabilities :: (Core.Maybe [Core.Text]),
      -- | A docker container image that resides in Google Container Registry.
      containerImage :: (Core.Maybe Core.Text),
      -- | Environment ID for the Beam runner API proto Environment that corresponds to the current SDK Harness.
      environmentId :: (Core.Maybe Core.Text),
      -- | If true, recommends the Dataflow service to use only one core per SDK container instance with this image. If false (or unset) recommends using more than one core per SDK container instance with this image for efficiency. Note that Dataflow service may choose to override this property if needed.
      useSingleCorePerContainer :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SdkHarnessContainerImage' with the minimum fields required to make a request.
  newSdkHarnessContainerImage ::
    SdkHarnessContainerImage
  newSdkHarnessContainerImage =
    SdkHarnessContainerImage
      { capabilities = Core.Nothing,
        containerImage = Core.Nothing,
        environmentId = Core.Nothing,
        useSingleCorePerContainer = Core.Nothing
      }
  
  instance Core.FromJSON SdkHarnessContainerImage where
    parseJSON =
      Core.withObject
        "SdkHarnessContainerImage"
        ( \o ->
            SdkHarnessContainerImage
              Core.<$> (o Core..:? "capabilities")
              Core.<*> (o Core..:? "containerImage")
              Core.<*> (o Core..:? "environmentId")
              Core.<*> (o Core..:? "useSingleCorePerContainer")
        )
  
  instance Core.ToJSON SdkHarnessContainerImage where
    toJSON SdkHarnessContainerImage {..} =
      Core.object
        ( Core.catMaybes
            [ ("capabilities" Core..=) Core.<$> capabilities,
              ("containerImage" Core..=) Core.<$> containerImage,
              ("environmentId" Core..=) Core.<$> environmentId,
              ("useSingleCorePerContainer" Core..=)
                Core.<$> useSingleCorePerContainer
            ]
        )
  
  -- | The version of the SDK used to run the job.
  --
  -- /See:/ 'newSdkVersion' smart constructor.
  data SdkVersion = SdkVersion
    { -- | Output only. Known bugs found in this SDK version.
      bugs :: (Core.Maybe [SdkBug]),
      -- | The support status for this SDK version.
      sdkSupportStatus :: (Core.Maybe SdkVersion_SdkSupportStatus),
      -- | The version of the SDK used to run the job.
      version :: (Core.Maybe Core.Text),
      -- | A readable string describing the version of the SDK.
      versionDisplayName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SdkVersion' with the minimum fields required to make a request.
  newSdkVersion ::
    SdkVersion
  newSdkVersion =
    SdkVersion
      { bugs = Core.Nothing,
        sdkSupportStatus = Core.Nothing,
        version = Core.Nothing,
        versionDisplayName = Core.Nothing
      }
  
  instance Core.FromJSON SdkVersion where
    parseJSON =
      Core.withObject
        "SdkVersion"
        ( \o ->
            SdkVersion
              Core.<$> (o Core..:? "bugs")
              Core.<*> (o Core..:? "sdkSupportStatus")
              Core.<*> (o Core..:? "version")
              Core.<*> (o Core..:? "versionDisplayName")
        )
  
  instance Core.ToJSON SdkVersion where
    toJSON SdkVersion {..} =
      Core.object
        ( Core.catMaybes
            [ ("bugs" Core..=) Core.<$> bugs,
              ("sdkSupportStatus" Core..=) Core.<$> sdkSupportStatus,
              ("version" Core..=) Core.<$> version,
              ("versionDisplayName" Core..=) Core.<$> versionDisplayName
            ]
        )
  
  -- | Request to send encoded debug information. Next ID: 8
  --
  -- /See:/ 'newSendDebugCaptureRequest' smart constructor.
  data SendDebugCaptureRequest = SendDebugCaptureRequest
    { -- | The internal component id for which debug information is sent.
      componentId :: (Core.Maybe Core.Text),
      -- | The encoded debug information.
      data' :: (Core.Maybe Core.Text),
      -- | Format for the data field above (id=5).
      dataFormat :: (Core.Maybe SendDebugCaptureRequest_DataFormat),
      -- | The [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that contains the job specified by job_id.
      location :: (Core.Maybe Core.Text),
      -- | The worker id, i.e., VM hostname.
      workerId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SendDebugCaptureRequest' with the minimum fields required to make a request.
  newSendDebugCaptureRequest ::
    SendDebugCaptureRequest
  newSendDebugCaptureRequest =
    SendDebugCaptureRequest
      { componentId = Core.Nothing,
        data' = Core.Nothing,
        dataFormat = Core.Nothing,
        location = Core.Nothing,
        workerId = Core.Nothing
      }
  
  instance Core.FromJSON SendDebugCaptureRequest where
    parseJSON =
      Core.withObject
        "SendDebugCaptureRequest"
        ( \o ->
            SendDebugCaptureRequest
              Core.<$> (o Core..:? "componentId")
              Core.<*> (o Core..:? "data")
              Core.<*> (o Core..:? "dataFormat")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "workerId")
        )
  
  instance Core.ToJSON SendDebugCaptureRequest where
    toJSON SendDebugCaptureRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("componentId" Core..=) Core.<$> componentId,
              ("data" Core..=) Core.<$> data',
              ("dataFormat" Core..=) Core.<$> dataFormat,
              ("location" Core..=) Core.<$> location,
              ("workerId" Core..=) Core.<$> workerId
            ]
        )
  
  -- | Response to a send capture request. nothing
  --
  -- /See:/ 'newSendDebugCaptureResponse' smart constructor.
  data SendDebugCaptureResponse = SendDebugCaptureResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SendDebugCaptureResponse' with the minimum fields required to make a request.
  newSendDebugCaptureResponse ::
    SendDebugCaptureResponse
  newSendDebugCaptureResponse = SendDebugCaptureResponse
  
  instance Core.FromJSON SendDebugCaptureResponse where
    parseJSON =
      Core.withObject
        "SendDebugCaptureResponse"
        (\o -> Core.pure SendDebugCaptureResponse)
  
  instance Core.ToJSON SendDebugCaptureResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | A request for sending worker messages to the service.
  --
  -- /See:/ 'newSendWorkerMessagesRequest' smart constructor.
  data SendWorkerMessagesRequest = SendWorkerMessagesRequest
    { -- | The [regional endpoint] (https:\/\/cloud.google.com\/dataflow\/docs\/concepts\/regional-endpoints) that contains the job.
      location :: (Core.Maybe Core.Text),
      -- | The WorkerMessages to send.
      workerMessages :: (Core.Maybe [WorkerMessage])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SendWorkerMessagesRequest' with the minimum fields required to make a request.
  newSendWorkerMessagesRequest ::
    SendWorkerMessagesRequest
  newSendWorkerMessagesRequest =
    SendWorkerMessagesRequest
      { location = Core.Nothing,
        workerMessages = Core.Nothing
      }
  
  instance Core.FromJSON SendWorkerMessagesRequest where
    parseJSON =
      Core.withObject
        "SendWorkerMessagesRequest"
        ( \o ->
            SendWorkerMessagesRequest
              Core.<$> (o Core..:? "location")
              Core.<*> (o Core..:? "workerMessages")
        )
  
  instance Core.ToJSON SendWorkerMessagesRequest where
    toJSON SendWorkerMessagesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("location" Core..=) Core.<$> location,
              ("workerMessages" Core..=) Core.<$> workerMessages
            ]
        )
  
  -- | The response to the worker messages.
  --
  -- /See:/ 'newSendWorkerMessagesResponse' smart constructor.
  newtype SendWorkerMessagesResponse = SendWorkerMessagesResponse
    { -- | The servers response to the worker messages.
      workerMessageResponses :: (Core.Maybe [WorkerMessageResponse])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SendWorkerMessagesResponse' with the minimum fields required to make a request.
  newSendWorkerMessagesResponse ::
    SendWorkerMessagesResponse
  newSendWorkerMessagesResponse =
    SendWorkerMessagesResponse {workerMessageResponses = Core.Nothing}
  
  instance Core.FromJSON SendWorkerMessagesResponse where
    parseJSON =
      Core.withObject
        "SendWorkerMessagesResponse"
        ( \o ->
            SendWorkerMessagesResponse
              Core.<$> (o Core..:? "workerMessageResponses")
        )
  
  instance Core.ToJSON SendWorkerMessagesResponse where
    toJSON SendWorkerMessagesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("workerMessageResponses" Core..=)
                Core.<$> workerMessageResponses
            ]
        )
  
  -- | Describes a particular function to invoke.
  --
  -- /See:/ 'newSeqMapTask' smart constructor.
  data SeqMapTask = SeqMapTask
    { -- | Information about each of the inputs.
      inputs :: (Core.Maybe [SideInputInfo]),
      -- | The user-provided name of the SeqDo operation.
      name :: (Core.Maybe Core.Text),
      -- | Information about each of the outputs.
      outputInfos :: (Core.Maybe [SeqMapTaskOutputInfo]),
      -- | System-defined name of the stage containing the SeqDo operation. Unique across the workflow.
      stageName :: (Core.Maybe Core.Text),
      -- | System-defined name of the SeqDo operation. Unique across the workflow.
      systemName :: (Core.Maybe Core.Text),
      -- | The user function to invoke.
      userFn :: (Core.Maybe SeqMapTask_UserFn)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SeqMapTask' with the minimum fields required to make a request.
  newSeqMapTask ::
    SeqMapTask
  newSeqMapTask =
    SeqMapTask
      { inputs = Core.Nothing,
        name = Core.Nothing,
        outputInfos = Core.Nothing,
        stageName = Core.Nothing,
        systemName = Core.Nothing,
        userFn = Core.Nothing
      }
  
  instance Core.FromJSON SeqMapTask where
    parseJSON =
      Core.withObject
        "SeqMapTask"
        ( \o ->
            SeqMapTask
              Core.<$> (o Core..:? "inputs")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "outputInfos")
              Core.<*> (o Core..:? "stageName")
              Core.<*> (o Core..:? "systemName")
              Core.<*> (o Core..:? "userFn")
        )
  
  instance Core.ToJSON SeqMapTask where
    toJSON SeqMapTask {..} =
      Core.object
        ( Core.catMaybes
            [ ("inputs" Core..=) Core.<$> inputs,
              ("name" Core..=) Core.<$> name,
              ("outputInfos" Core..=) Core.<$> outputInfos,
              ("stageName" Core..=) Core.<$> stageName,
              ("systemName" Core..=) Core.<$> systemName,
              ("userFn" Core..=) Core.<$> userFn
            ]
        )
  
  -- | The user function to invoke.
  --
  -- /See:/ 'newSeqMapTask_UserFn' smart constructor.
  newtype SeqMapTask_UserFn = SeqMapTask_UserFn
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SeqMapTask_UserFn' with the minimum fields required to make a request.
  newSeqMapTask_UserFn ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    SeqMapTask_UserFn
  newSeqMapTask_UserFn additional =
    SeqMapTask_UserFn {additional = additional}
  
  instance Core.FromJSON SeqMapTask_UserFn where
    parseJSON =
      Core.withObject
        "SeqMapTask_UserFn"
        (\o -> SeqMapTask_UserFn Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON SeqMapTask_UserFn where
    toJSON SeqMapTask_UserFn {..} = Core.toJSON additional
  
  -- | Information about an output of a SeqMapTask.
  --
  -- /See:/ 'newSeqMapTaskOutputInfo' smart constructor.
  data SeqMapTaskOutputInfo = SeqMapTaskOutputInfo
    { -- | The sink to write the output value to.
      sink :: (Core.Maybe Sink),
      -- | The id of the TupleTag the user code will tag the output value by.
      tag :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SeqMapTaskOutputInfo' with the minimum fields required to make a request.
  newSeqMapTaskOutputInfo ::
    SeqMapTaskOutputInfo
  newSeqMapTaskOutputInfo =
    SeqMapTaskOutputInfo {sink = Core.Nothing, tag = Core.Nothing}
  
  instance Core.FromJSON SeqMapTaskOutputInfo where
    parseJSON =
      Core.withObject
        "SeqMapTaskOutputInfo"
        ( \o ->
            SeqMapTaskOutputInfo
              Core.<$> (o Core..:? "sink")
              Core.<*> (o Core..:? "tag")
        )
  
  instance Core.ToJSON SeqMapTaskOutputInfo where
    toJSON SeqMapTaskOutputInfo {..} =
      Core.object
        ( Core.catMaybes
            [("sink" Core..=) Core.<$> sink, ("tag" Core..=) Core.<$> tag]
        )
  
  -- | Resources used by the Dataflow Service to run the job.
  --
  -- /See:/ 'newServiceResources' smart constructor.
  newtype ServiceResources = ServiceResources
    { -- | Output only. List of Cloud Zones being used by the Dataflow Service for this job. Example: us-central1-c
      zones :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ServiceResources' with the minimum fields required to make a request.
  newServiceResources ::
    ServiceResources
  newServiceResources = ServiceResources {zones = Core.Nothing}
  
  instance Core.FromJSON ServiceResources where
    parseJSON =
      Core.withObject
        "ServiceResources"
        (\o -> ServiceResources Core.<$> (o Core..:? "zones"))
  
  instance Core.ToJSON ServiceResources where
    toJSON ServiceResources {..} =
      Core.object (Core.catMaybes [("zones" Core..=) Core.<$> zones])
  
  -- | A task which consists of a shell command for the worker to execute.
  --
  -- /See:/ 'newShellTask' smart constructor.
  data ShellTask = ShellTask
    { -- | The shell command to run.
      command :: (Core.Maybe Core.Text),
      -- | Exit code for the task.
      exitCode :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ShellTask' with the minimum fields required to make a request.
  newShellTask ::
    ShellTask
  newShellTask =
    ShellTask {command = Core.Nothing, exitCode = Core.Nothing}
  
  instance Core.FromJSON ShellTask where
    parseJSON =
      Core.withObject
        "ShellTask"
        ( \o ->
            ShellTask
              Core.<$> (o Core..:? "command")
              Core.<*> (o Core..:? "exitCode")
        )
  
  instance Core.ToJSON ShellTask where
    toJSON ShellTask {..} =
      Core.object
        ( Core.catMaybes
            [ ("command" Core..=) Core.<$> command,
              ("exitCode" Core..=) Core.<$> exitCode
            ]
        )
  
  -- | Information about a side input of a DoFn or an input of a SeqDoFn.
  --
  -- /See:/ 'newSideInputInfo' smart constructor.
  data SideInputInfo = SideInputInfo
    { -- | How to interpret the source element(s) as a side input value.
      kind :: (Core.Maybe SideInputInfo_Kind),
      -- | The source(s) to read element(s) from to get the value of this side input. If more than one source, then the elements are taken from the sources, in the specified order if order matters. At least one source is required.
      sources :: (Core.Maybe [Source]),
      -- | The id of the tag the user code will access this side input by; this should correspond to the tag of some MultiOutputInfo.
      tag :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SideInputInfo' with the minimum fields required to make a request.
  newSideInputInfo ::
    SideInputInfo
  newSideInputInfo =
    SideInputInfo
      { kind = Core.Nothing,
        sources = Core.Nothing,
        tag = Core.Nothing
      }
  
  instance Core.FromJSON SideInputInfo where
    parseJSON =
      Core.withObject
        "SideInputInfo"
        ( \o ->
            SideInputInfo
              Core.<$> (o Core..:? "kind")
              Core.<*> (o Core..:? "sources")
              Core.<*> (o Core..:? "tag")
        )
  
  instance Core.ToJSON SideInputInfo where
    toJSON SideInputInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("kind" Core..=) Core.<$> kind,
              ("sources" Core..=) Core.<$> sources,
              ("tag" Core..=) Core.<$> tag
            ]
        )
  
  -- | How to interpret the source element(s) as a side input value.
  --
  -- /See:/ 'newSideInputInfo_Kind' smart constructor.
  newtype SideInputInfo_Kind = SideInputInfo_Kind
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SideInputInfo_Kind' with the minimum fields required to make a request.
  newSideInputInfo_Kind ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    SideInputInfo_Kind
  newSideInputInfo_Kind additional =
    SideInputInfo_Kind {additional = additional}
  
  instance Core.FromJSON SideInputInfo_Kind where
    parseJSON =
      Core.withObject
        "SideInputInfo_Kind"
        (\o -> SideInputInfo_Kind Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON SideInputInfo_Kind where
    toJSON SideInputInfo_Kind {..} = Core.toJSON additional
  
  -- | A sink that records can be encoded and written to.
  --
  -- /See:/ 'newSink' smart constructor.
  data Sink = Sink
    { -- | The codec to use to encode data written to the sink.
      codec :: (Core.Maybe Sink_Codec),
      -- | The sink to write to, plus its parameters.
      spec :: (Core.Maybe Sink_Spec)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Sink' with the minimum fields required to make a request.
  newSink ::
    Sink
  newSink = Sink {codec = Core.Nothing, spec = Core.Nothing}
  
  instance Core.FromJSON Sink where
    parseJSON =
      Core.withObject
        "Sink"
        ( \o ->
            Sink Core.<$> (o Core..:? "codec") Core.<*> (o Core..:? "spec")
        )
  
  instance Core.ToJSON Sink where
    toJSON Sink {..} =
      Core.object
        ( Core.catMaybes
            [("codec" Core..=) Core.<$> codec, ("spec" Core..=) Core.<$> spec]
        )
  
  -- | The codec to use to encode data written to the sink.
  --
  -- /See:/ 'newSink_Codec' smart constructor.
  newtype Sink_Codec = Sink_Codec
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Sink_Codec' with the minimum fields required to make a request.
  newSink_Codec ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Sink_Codec
  newSink_Codec additional = Sink_Codec {additional = additional}
  
  instance Core.FromJSON Sink_Codec where
    parseJSON =
      Core.withObject
        "Sink_Codec"
        (\o -> Sink_Codec Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Sink_Codec where
    toJSON Sink_Codec {..} = Core.toJSON additional
  
  -- | The sink to write to, plus its parameters.
  --
  -- /See:/ 'newSink_Spec' smart constructor.
  newtype Sink_Spec = Sink_Spec
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Sink_Spec' with the minimum fields required to make a request.
  newSink_Spec ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Sink_Spec
  newSink_Spec additional = Sink_Spec {additional = additional}
  
  instance Core.FromJSON Sink_Spec where
    parseJSON =
      Core.withObject
        "Sink_Spec"
        (\o -> Sink_Spec Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Sink_Spec where
    toJSON Sink_Spec {..} = Core.toJSON additional
  
  -- | Represents a snapshot of a job.
  --
  -- /See:/ 'newSnapshot' smart constructor.
  data Snapshot = Snapshot
    { -- | The time this snapshot was created.
      creationTime :: (Core.Maybe Core.DateTime),
      -- | User specified description of the snapshot. Maybe empty.
      description :: (Core.Maybe Core.Text),
      -- | The disk byte size of the snapshot. Only available for snapshots in READY state.
      diskSizeBytes :: (Core.Maybe Core.Int64),
      -- | The unique ID of this snapshot.
      id :: (Core.Maybe Core.Text),
      -- | The project this snapshot belongs to.
      projectId :: (Core.Maybe Core.Text),
      -- | Pub\/Sub snapshot metadata.
      pubsubMetadata :: (Core.Maybe [PubsubSnapshotMetadata]),
      -- | Cloud region where this snapshot lives in, e.g., \"us-central1\".
      region :: (Core.Maybe Core.Text),
      -- | The job this snapshot was created from.
      sourceJobId :: (Core.Maybe Core.Text),
      -- | State of the snapshot.
      state :: (Core.Maybe Snapshot_State),
      -- | The time after which this snapshot will be automatically deleted.
      ttl :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Snapshot' with the minimum fields required to make a request.
  newSnapshot ::
    Snapshot
  newSnapshot =
    Snapshot
      { creationTime = Core.Nothing,
        description = Core.Nothing,
        diskSizeBytes = Core.Nothing,
        id = Core.Nothing,
        projectId = Core.Nothing,
        pubsubMetadata = Core.Nothing,
        region = Core.Nothing,
        sourceJobId = Core.Nothing,
        state = Core.Nothing,
        ttl = Core.Nothing
      }
  
  instance Core.FromJSON Snapshot where
    parseJSON =
      Core.withObject
        "Snapshot"
        ( \o ->
            Snapshot
              Core.<$> (o Core..:? "creationTime")
              Core.<*> (o Core..:? "description")
              Core.<*> (o Core..:? "diskSizeBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "projectId")
              Core.<*> (o Core..:? "pubsubMetadata")
              Core.<*> (o Core..:? "region")
              Core.<*> (o Core..:? "sourceJobId")
              Core.<*> (o Core..:? "state")
              Core.<*> (o Core..:? "ttl")
        )
  
  instance Core.ToJSON Snapshot where
    toJSON Snapshot {..} =
      Core.object
        ( Core.catMaybes
            [ ("creationTime" Core..=) Core.<$> creationTime,
              ("description" Core..=) Core.<$> description,
              ("diskSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> diskSizeBytes,
              ("id" Core..=) Core.<$> id,
              ("projectId" Core..=) Core.<$> projectId,
              ("pubsubMetadata" Core..=) Core.<$> pubsubMetadata,
              ("region" Core..=) Core.<$> region,
              ("sourceJobId" Core..=) Core.<$> sourceJobId,
              ("state" Core..=) Core.<$> state,
              ("ttl" Core..=) Core.<$> ttl
            ]
        )
  
  -- | Request to create a snapshot of a job.
  --
  -- /See:/ 'newSnapshotJobRequest' smart constructor.
  data SnapshotJobRequest = SnapshotJobRequest
    { -- | User specified description of the snapshot. Maybe empty.
      description :: (Core.Maybe Core.Text),
      -- | The location that contains this job.
      location :: (Core.Maybe Core.Text),
      -- | If true, perform snapshots for sources which support this.
      snapshotSources :: (Core.Maybe Core.Bool),
      -- | TTL for the snapshot.
      ttl :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SnapshotJobRequest' with the minimum fields required to make a request.
  newSnapshotJobRequest ::
    SnapshotJobRequest
  newSnapshotJobRequest =
    SnapshotJobRequest
      { description = Core.Nothing,
        location = Core.Nothing,
        snapshotSources = Core.Nothing,
        ttl = Core.Nothing
      }
  
  instance Core.FromJSON SnapshotJobRequest where
    parseJSON =
      Core.withObject
        "SnapshotJobRequest"
        ( \o ->
            SnapshotJobRequest
              Core.<$> (o Core..:? "description")
              Core.<*> (o Core..:? "location")
              Core.<*> (o Core..:? "snapshotSources")
              Core.<*> (o Core..:? "ttl")
        )
  
  instance Core.ToJSON SnapshotJobRequest where
    toJSON SnapshotJobRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("description" Core..=) Core.<$> description,
              ("location" Core..=) Core.<$> location,
              ("snapshotSources" Core..=) Core.<$> snapshotSources,
              ("ttl" Core..=) Core.<$> ttl
            ]
        )
  
  -- | A source that records can be read and decoded from.
  --
  -- /See:/ 'newSource' smart constructor.
  data Source = Source
    { -- | While splitting, sources may specify the produced bundles as differences against another source, in order to save backend-side memory and allow bigger jobs. For details, see SourceSplitRequest. To support this use case, the full set of parameters of the source is logically obtained by taking the latest explicitly specified value of each parameter in the order: base/specs (later items win), spec (overrides anything in base/specs).
      baseSpecs :: (Core.Maybe [Source_BaseSpecsItem]),
      -- | The codec to use to decode data read from the source.
      codec :: (Core.Maybe Source_Codec),
      -- | Setting this value to true hints to the framework that the source doesn\'t need splitting, and using SourceSplitRequest on it would yield SOURCE/SPLIT/OUTCOME/USE/CURRENT. E.g. a file splitter may set this to true when splitting a single file into a set of byte ranges of appropriate size, and set this to false when splitting a filepattern into individual files. However, for efficiency, a file splitter may decide to produce file subranges directly from the filepattern to avoid a splitting round-trip. See SourceSplitRequest for an overview of the splitting process. This field is meaningful only in the Source objects populated by the user (e.g. when filling in a DerivedSource). Source objects supplied by the framework to the user don\'t have this field populated.
      doesNotNeedSplitting :: (Core.Maybe Core.Bool),
      -- | Optionally, metadata for this source can be supplied right away, avoiding a SourceGetMetadataOperation roundtrip (see SourceOperationRequest). This field is meaningful only in the Source objects populated by the user (e.g. when filling in a DerivedSource). Source objects supplied by the framework to the user don\'t have this field populated.
      metadata :: (Core.Maybe SourceMetadata),
      -- | The source to read from, plus its parameters.
      spec :: (Core.Maybe Source_Spec)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Source' with the minimum fields required to make a request.
  newSource ::
    Source
  newSource =
    Source
      { baseSpecs = Core.Nothing,
        codec = Core.Nothing,
        doesNotNeedSplitting = Core.Nothing,
        metadata = Core.Nothing,
        spec = Core.Nothing
      }
  
  instance Core.FromJSON Source where
    parseJSON =
      Core.withObject
        "Source"
        ( \o ->
            Source
              Core.<$> (o Core..:? "baseSpecs")
              Core.<*> (o Core..:? "codec")
              Core.<*> (o Core..:? "doesNotNeedSplitting")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "spec")
        )
  
  instance Core.ToJSON Source where
    toJSON Source {..} =
      Core.object
        ( Core.catMaybes
            [ ("baseSpecs" Core..=) Core.<$> baseSpecs,
              ("codec" Core..=) Core.<$> codec,
              ("doesNotNeedSplitting" Core..=) Core.<$> doesNotNeedSplitting,
              ("metadata" Core..=) Core.<$> metadata,
              ("spec" Core..=) Core.<$> spec
            ]
        )
  
  --
  -- /See:/ 'newSource_BaseSpecsItem' smart constructor.
  newtype Source_BaseSpecsItem = Source_BaseSpecsItem
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Source_BaseSpecsItem' with the minimum fields required to make a request.
  newSource_BaseSpecsItem ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Source_BaseSpecsItem
  newSource_BaseSpecsItem additional =
    Source_BaseSpecsItem {additional = additional}
  
  instance Core.FromJSON Source_BaseSpecsItem where
    parseJSON =
      Core.withObject
        "Source_BaseSpecsItem"
        (\o -> Source_BaseSpecsItem Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Source_BaseSpecsItem where
    toJSON Source_BaseSpecsItem {..} = Core.toJSON additional
  
  -- | The codec to use to decode data read from the source.
  --
  -- /See:/ 'newSource_Codec' smart constructor.
  newtype Source_Codec = Source_Codec
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Source_Codec' with the minimum fields required to make a request.
  newSource_Codec ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Source_Codec
  newSource_Codec additional = Source_Codec {additional = additional}
  
  instance Core.FromJSON Source_Codec where
    parseJSON =
      Core.withObject
        "Source_Codec"
        (\o -> Source_Codec Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Source_Codec where
    toJSON Source_Codec {..} = Core.toJSON additional
  
  -- | The source to read from, plus its parameters.
  --
  -- /See:/ 'newSource_Spec' smart constructor.
  newtype Source_Spec = Source_Spec
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Source_Spec' with the minimum fields required to make a request.
  newSource_Spec ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Source_Spec
  newSource_Spec additional = Source_Spec {additional = additional}
  
  instance Core.FromJSON Source_Spec where
    parseJSON =
      Core.withObject
        "Source_Spec"
        (\o -> Source_Spec Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Source_Spec where
    toJSON Source_Spec {..} = Core.toJSON additional
  
  -- | DEPRECATED in favor of DynamicSourceSplit.
  --
  -- /See:/ 'newSourceFork' smart constructor.
  data SourceFork = SourceFork
    { -- | DEPRECATED
      primary :: (Core.Maybe SourceSplitShard),
      -- | DEPRECATED
      primarySource :: (Core.Maybe DerivedSource),
      -- | DEPRECATED
      residual :: (Core.Maybe SourceSplitShard),
      -- | DEPRECATED
      residualSource :: (Core.Maybe DerivedSource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceFork' with the minimum fields required to make a request.
  newSourceFork ::
    SourceFork
  newSourceFork =
    SourceFork
      { primary = Core.Nothing,
        primarySource = Core.Nothing,
        residual = Core.Nothing,
        residualSource = Core.Nothing
      }
  
  instance Core.FromJSON SourceFork where
    parseJSON =
      Core.withObject
        "SourceFork"
        ( \o ->
            SourceFork
              Core.<$> (o Core..:? "primary")
              Core.<*> (o Core..:? "primarySource")
              Core.<*> (o Core..:? "residual")
              Core.<*> (o Core..:? "residualSource")
        )
  
  instance Core.ToJSON SourceFork where
    toJSON SourceFork {..} =
      Core.object
        ( Core.catMaybes
            [ ("primary" Core..=) Core.<$> primary,
              ("primarySource" Core..=) Core.<$> primarySource,
              ("residual" Core..=) Core.<$> residual,
              ("residualSource" Core..=) Core.<$> residualSource
            ]
        )
  
  -- | A request to compute the SourceMetadata of a Source.
  --
  -- /See:/ 'newSourceGetMetadataRequest' smart constructor.
  newtype SourceGetMetadataRequest = SourceGetMetadataRequest
    { -- | Specification of the source whose metadata should be computed.
      source :: (Core.Maybe Source)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceGetMetadataRequest' with the minimum fields required to make a request.
  newSourceGetMetadataRequest ::
    SourceGetMetadataRequest
  newSourceGetMetadataRequest =
    SourceGetMetadataRequest {source = Core.Nothing}
  
  instance Core.FromJSON SourceGetMetadataRequest where
    parseJSON =
      Core.withObject
        "SourceGetMetadataRequest"
        (\o -> SourceGetMetadataRequest Core.<$> (o Core..:? "source"))
  
  instance Core.ToJSON SourceGetMetadataRequest where
    toJSON SourceGetMetadataRequest {..} =
      Core.object (Core.catMaybes [("source" Core..=) Core.<$> source])
  
  -- | The result of a SourceGetMetadataOperation.
  --
  -- /See:/ 'newSourceGetMetadataResponse' smart constructor.
  newtype SourceGetMetadataResponse = SourceGetMetadataResponse
    { -- | The computed metadata.
      metadata :: (Core.Maybe SourceMetadata)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceGetMetadataResponse' with the minimum fields required to make a request.
  newSourceGetMetadataResponse ::
    SourceGetMetadataResponse
  newSourceGetMetadataResponse =
    SourceGetMetadataResponse {metadata = Core.Nothing}
  
  instance Core.FromJSON SourceGetMetadataResponse where
    parseJSON =
      Core.withObject
        "SourceGetMetadataResponse"
        (\o -> SourceGetMetadataResponse Core.<$> (o Core..:? "metadata"))
  
  instance Core.ToJSON SourceGetMetadataResponse where
    toJSON SourceGetMetadataResponse {..} =
      Core.object
        (Core.catMaybes [("metadata" Core..=) Core.<$> metadata])
  
  -- | Metadata about a Source useful for automatically optimizing and tuning the pipeline, etc.
  --
  -- /See:/ 'newSourceMetadata' smart constructor.
  data SourceMetadata = SourceMetadata
    { -- | An estimate of the total size (in bytes) of the data that would be read from this source. This estimate is in terms of external storage size, before any decompression or other processing done by the reader.
      estimatedSizeBytes :: (Core.Maybe Core.Int64),
      -- | Specifies that the size of this source is known to be infinite (this is a streaming source).
      infinite :: (Core.Maybe Core.Bool),
      -- | Whether this source is known to produce key\/value pairs with the (encoded) keys in lexicographically sorted order.
      producesSortedKeys :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceMetadata' with the minimum fields required to make a request.
  newSourceMetadata ::
    SourceMetadata
  newSourceMetadata =
    SourceMetadata
      { estimatedSizeBytes = Core.Nothing,
        infinite = Core.Nothing,
        producesSortedKeys = Core.Nothing
      }
  
  instance Core.FromJSON SourceMetadata where
    parseJSON =
      Core.withObject
        "SourceMetadata"
        ( \o ->
            SourceMetadata
              Core.<$> ( o
                           Core..:? "estimatedSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "infinite")
              Core.<*> (o Core..:? "producesSortedKeys")
        )
  
  instance Core.ToJSON SourceMetadata where
    toJSON SourceMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("estimatedSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> estimatedSizeBytes,
              ("infinite" Core..=) Core.<$> infinite,
              ("producesSortedKeys" Core..=) Core.<$> producesSortedKeys
            ]
        )
  
  -- | A work item that represents the different operations that can be performed on a user-defined Source specification.
  --
  -- /See:/ 'newSourceOperationRequest' smart constructor.
  data SourceOperationRequest = SourceOperationRequest
    { -- | Information about a request to get metadata about a source.
      getMetadata :: (Core.Maybe SourceGetMetadataRequest),
      -- | User-provided name of the Read instruction for this source.
      name :: (Core.Maybe Core.Text),
      -- | System-defined name for the Read instruction for this source in the original workflow graph.
      originalName :: (Core.Maybe Core.Text),
      -- | Information about a request to split a source.
      split :: (Core.Maybe SourceSplitRequest),
      -- | System-defined name of the stage containing the source operation. Unique across the workflow.
      stageName :: (Core.Maybe Core.Text),
      -- | System-defined name of the Read instruction for this source. Unique across the workflow.
      systemName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceOperationRequest' with the minimum fields required to make a request.
  newSourceOperationRequest ::
    SourceOperationRequest
  newSourceOperationRequest =
    SourceOperationRequest
      { getMetadata = Core.Nothing,
        name = Core.Nothing,
        originalName = Core.Nothing,
        split = Core.Nothing,
        stageName = Core.Nothing,
        systemName = Core.Nothing
      }
  
  instance Core.FromJSON SourceOperationRequest where
    parseJSON =
      Core.withObject
        "SourceOperationRequest"
        ( \o ->
            SourceOperationRequest
              Core.<$> (o Core..:? "getMetadata")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "originalName")
              Core.<*> (o Core..:? "split")
              Core.<*> (o Core..:? "stageName")
              Core.<*> (o Core..:? "systemName")
        )
  
  instance Core.ToJSON SourceOperationRequest where
    toJSON SourceOperationRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("getMetadata" Core..=) Core.<$> getMetadata,
              ("name" Core..=) Core.<$> name,
              ("originalName" Core..=) Core.<$> originalName,
              ("split" Core..=) Core.<$> split,
              ("stageName" Core..=) Core.<$> stageName,
              ("systemName" Core..=) Core.<$> systemName
            ]
        )
  
  -- | The result of a SourceOperationRequest, specified in ReportWorkItemStatusRequest.source_operation when the work item is completed.
  --
  -- /See:/ 'newSourceOperationResponse' smart constructor.
  data SourceOperationResponse = SourceOperationResponse
    { -- | A response to a request to get metadata about a source.
      getMetadata :: (Core.Maybe SourceGetMetadataResponse),
      -- | A response to a request to split a source.
      split :: (Core.Maybe SourceSplitResponse)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceOperationResponse' with the minimum fields required to make a request.
  newSourceOperationResponse ::
    SourceOperationResponse
  newSourceOperationResponse =
    SourceOperationResponse
      { getMetadata = Core.Nothing,
        split = Core.Nothing
      }
  
  instance Core.FromJSON SourceOperationResponse where
    parseJSON =
      Core.withObject
        "SourceOperationResponse"
        ( \o ->
            SourceOperationResponse
              Core.<$> (o Core..:? "getMetadata")
              Core.<*> (o Core..:? "split")
        )
  
  instance Core.ToJSON SourceOperationResponse where
    toJSON SourceOperationResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("getMetadata" Core..=) Core.<$> getMetadata,
              ("split" Core..=) Core.<$> split
            ]
        )
  
  -- | Hints for splitting a Source into bundles (parts for parallel processing) using SourceSplitRequest.
  --
  -- /See:/ 'newSourceSplitOptions' smart constructor.
  data SourceSplitOptions = SourceSplitOptions
    { -- | The source should be split into a set of bundles where the estimated size of each is approximately this many bytes.
      desiredBundleSizeBytes :: (Core.Maybe Core.Int64),
      -- | DEPRECATED in favor of desired/bundle/size_bytes.
      desiredShardSizeBytes :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceSplitOptions' with the minimum fields required to make a request.
  newSourceSplitOptions ::
    SourceSplitOptions
  newSourceSplitOptions =
    SourceSplitOptions
      { desiredBundleSizeBytes = Core.Nothing,
        desiredShardSizeBytes = Core.Nothing
      }
  
  instance Core.FromJSON SourceSplitOptions where
    parseJSON =
      Core.withObject
        "SourceSplitOptions"
        ( \o ->
            SourceSplitOptions
              Core.<$> ( o
                           Core..:? "desiredBundleSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "desiredShardSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON SourceSplitOptions where
    toJSON SourceSplitOptions {..} =
      Core.object
        ( Core.catMaybes
            [ ("desiredBundleSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> desiredBundleSizeBytes,
              ("desiredShardSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> desiredShardSizeBytes
            ]
        )
  
  -- | Represents the operation to split a high-level Source specification into bundles (parts for parallel processing). At a high level, splitting of a source into bundles happens as follows: SourceSplitRequest is applied to the source. If it returns SOURCE/SPLIT/OUTCOME/USE/CURRENT, no further splitting happens and the source is used \"as is\". Otherwise, splitting is applied recursively to each produced DerivedSource. As an optimization, for any Source, if its does/not/need/splitting is true, the framework assumes that splitting this source would return SOURCE/SPLIT/OUTCOME/USE_CURRENT, and doesn\'t initiate a SourceSplitRequest. This applies both to the initial source being split and to bundles produced from it.
  --
  -- /See:/ 'newSourceSplitRequest' smart constructor.
  data SourceSplitRequest = SourceSplitRequest
    { -- | Hints for tuning the splitting process.
      options :: (Core.Maybe SourceSplitOptions),
      -- | Specification of the source to be split.
      source :: (Core.Maybe Source)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceSplitRequest' with the minimum fields required to make a request.
  newSourceSplitRequest ::
    SourceSplitRequest
  newSourceSplitRequest =
    SourceSplitRequest {options = Core.Nothing, source = Core.Nothing}
  
  instance Core.FromJSON SourceSplitRequest where
    parseJSON =
      Core.withObject
        "SourceSplitRequest"
        ( \o ->
            SourceSplitRequest
              Core.<$> (o Core..:? "options")
              Core.<*> (o Core..:? "source")
        )
  
  instance Core.ToJSON SourceSplitRequest where
    toJSON SourceSplitRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("options" Core..=) Core.<$> options,
              ("source" Core..=) Core.<$> source
            ]
        )
  
  -- | The response to a SourceSplitRequest.
  --
  -- /See:/ 'newSourceSplitResponse' smart constructor.
  data SourceSplitResponse = SourceSplitResponse
    { -- | If outcome is SPLITTING_HAPPENED, then this is a list of bundles into which the source was split. Otherwise this field is ignored. This list can be empty, which means the source represents an empty input.
      bundles :: (Core.Maybe [DerivedSource]),
      -- | Indicates whether splitting happened and produced a list of bundles. If this is USE/CURRENT/SOURCE/AS/IS, the current source should be processed \"as is\" without splitting. \"bundles\" is ignored in this case. If this is SPLITTING_HAPPENED, then \"bundles\" contains a list of bundles into which the source was split.
      outcome :: (Core.Maybe SourceSplitResponse_Outcome),
      -- | DEPRECATED in favor of bundles.
      shards :: (Core.Maybe [SourceSplitShard])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceSplitResponse' with the minimum fields required to make a request.
  newSourceSplitResponse ::
    SourceSplitResponse
  newSourceSplitResponse =
    SourceSplitResponse
      { bundles = Core.Nothing,
        outcome = Core.Nothing,
        shards = Core.Nothing
      }
  
  instance Core.FromJSON SourceSplitResponse where
    parseJSON =
      Core.withObject
        "SourceSplitResponse"
        ( \o ->
            SourceSplitResponse
              Core.<$> (o Core..:? "bundles")
              Core.<*> (o Core..:? "outcome")
              Core.<*> (o Core..:? "shards")
        )
  
  instance Core.ToJSON SourceSplitResponse where
    toJSON SourceSplitResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("bundles" Core..=) Core.<$> bundles,
              ("outcome" Core..=) Core.<$> outcome,
              ("shards" Core..=) Core.<$> shards
            ]
        )
  
  -- | DEPRECATED in favor of DerivedSource.
  --
  -- /See:/ 'newSourceSplitShard' smart constructor.
  data SourceSplitShard = SourceSplitShard
    { -- | DEPRECATED
      derivationMode :: (Core.Maybe SourceSplitShard_DerivationMode),
      -- | DEPRECATED
      source :: (Core.Maybe Source)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SourceSplitShard' with the minimum fields required to make a request.
  newSourceSplitShard ::
    SourceSplitShard
  newSourceSplitShard =
    SourceSplitShard
      { derivationMode = Core.Nothing,
        source = Core.Nothing
      }
  
  instance Core.FromJSON SourceSplitShard where
    parseJSON =
      Core.withObject
        "SourceSplitShard"
        ( \o ->
            SourceSplitShard
              Core.<$> (o Core..:? "derivationMode")
              Core.<*> (o Core..:? "source")
        )
  
  instance Core.ToJSON SourceSplitShard where
    toJSON SourceSplitShard {..} =
      Core.object
        ( Core.catMaybes
            [ ("derivationMode" Core..=) Core.<$> derivationMode,
              ("source" Core..=) Core.<$> source
            ]
        )
  
  -- | Metadata for a Spanner connector used by the job.
  --
  -- /See:/ 'newSpannerIODetails' smart constructor.
  data SpannerIODetails = SpannerIODetails
    { -- | DatabaseId accessed in the connection.
      databaseId :: (Core.Maybe Core.Text),
      -- | InstanceId accessed in the connection.
      instanceId :: (Core.Maybe Core.Text),
      -- | ProjectId accessed in the connection.
      projectId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SpannerIODetails' with the minimum fields required to make a request.
  newSpannerIODetails ::
    SpannerIODetails
  newSpannerIODetails =
    SpannerIODetails
      { databaseId = Core.Nothing,
        instanceId = Core.Nothing,
        projectId = Core.Nothing
      }
  
  instance Core.FromJSON SpannerIODetails where
    parseJSON =
      Core.withObject
        "SpannerIODetails"
        ( \o ->
            SpannerIODetails
              Core.<$> (o Core..:? "databaseId")
              Core.<*> (o Core..:? "instanceId")
              Core.<*> (o Core..:? "projectId")
        )
  
  instance Core.ToJSON SpannerIODetails where
    toJSON SpannerIODetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("databaseId" Core..=) Core.<$> databaseId,
              ("instanceId" Core..=) Core.<$> instanceId,
              ("projectId" Core..=) Core.<$> projectId
            ]
        )
  
  -- | A representation of an int64, n, that is immune to precision loss when encoded in JSON.
  --
  -- /See:/ 'newSplitInt64' smart constructor.
  data SplitInt64 = SplitInt64
    { -- | The high order bits, including the sign: n >> 32.
      highBits :: (Core.Maybe Core.Int32),
      -- | The low order bits: n & 0xffffffff.
      lowBits :: (Core.Maybe Core.Word32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SplitInt64' with the minimum fields required to make a request.
  newSplitInt64 ::
    SplitInt64
  newSplitInt64 =
    SplitInt64 {highBits = Core.Nothing, lowBits = Core.Nothing}
  
  instance Core.FromJSON SplitInt64 where
    parseJSON =
      Core.withObject
        "SplitInt64"
        ( \o ->
            SplitInt64
              Core.<$> (o Core..:? "highBits")
              Core.<*> (o Core..:? "lowBits")
        )
  
  instance Core.ToJSON SplitInt64 where
    toJSON SplitInt64 {..} =
      Core.object
        ( Core.catMaybes
            [ ("highBits" Core..=) Core.<$> highBits,
              ("lowBits" Core..=) Core.<$> lowBits
            ]
        )
  
  -- | Information about the workers and work items within a stage.
  --
  -- /See:/ 'newStageExecutionDetails' smart constructor.
  data StageExecutionDetails = StageExecutionDetails
    { -- | If present, this response does not contain all requested tasks. To obtain the next page of results, repeat the request with page_token set to this value.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | Workers that have done work on the stage.
      workers :: (Core.Maybe [WorkerDetails])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StageExecutionDetails' with the minimum fields required to make a request.
  newStageExecutionDetails ::
    StageExecutionDetails
  newStageExecutionDetails =
    StageExecutionDetails
      { nextPageToken = Core.Nothing,
        workers = Core.Nothing
      }
  
  instance Core.FromJSON StageExecutionDetails where
    parseJSON =
      Core.withObject
        "StageExecutionDetails"
        ( \o ->
            StageExecutionDetails
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "workers")
        )
  
  instance Core.ToJSON StageExecutionDetails where
    toJSON StageExecutionDetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("workers" Core..=) Core.<$> workers
            ]
        )
  
  -- | Description of an input or output of an execution stage.
  --
  -- /See:/ 'newStageSource' smart constructor.
  data StageSource = StageSource
    { -- | Dataflow service generated name for this source.
      name :: (Core.Maybe Core.Text),
      -- | User name for the original user transform or collection with which this source is most closely associated.
      originalTransformOrCollection :: (Core.Maybe Core.Text),
      -- | Size of the source, if measurable.
      sizeBytes :: (Core.Maybe Core.Int64),
      -- | Human-readable name for this source; may be user or system generated.
      userName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StageSource' with the minimum fields required to make a request.
  newStageSource ::
    StageSource
  newStageSource =
    StageSource
      { name = Core.Nothing,
        originalTransformOrCollection = Core.Nothing,
        sizeBytes = Core.Nothing,
        userName = Core.Nothing
      }
  
  instance Core.FromJSON StageSource where
    parseJSON =
      Core.withObject
        "StageSource"
        ( \o ->
            StageSource
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "originalTransformOrCollection")
              Core.<*> (o Core..:? "sizeBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "userName")
        )
  
  instance Core.ToJSON StageSource where
    toJSON StageSource {..} =
      Core.object
        ( Core.catMaybes
            [ ("name" Core..=) Core.<$> name,
              ("originalTransformOrCollection" Core..=)
                Core.<$> originalTransformOrCollection,
              ("sizeBytes" Core..=) Core.. Core.AsText Core.<$> sizeBytes,
              ("userName" Core..=) Core.<$> userName
            ]
        )
  
  -- | Information about a particular execution stage of a job.
  --
  -- /See:/ 'newStageSummary' smart constructor.
  data StageSummary = StageSummary
    { -- | End time of this stage. If the work item is completed, this is the actual end time of the stage. Otherwise, it is the predicted end time.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Metrics for this stage.
      metrics :: (Core.Maybe [MetricUpdate]),
      -- | Progress for this stage. Only applicable to Batch jobs.
      progress :: (Core.Maybe ProgressTimeseries),
      -- | ID of this stage
      stageId :: (Core.Maybe Core.Text),
      -- | Start time of this stage.
      startTime :: (Core.Maybe Core.DateTime),
      -- | State of this stage.
      state :: (Core.Maybe StageSummary_State),
      -- | Straggler summary for this stage.
      stragglerSummary :: (Core.Maybe StragglerSummary)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StageSummary' with the minimum fields required to make a request.
  newStageSummary ::
    StageSummary
  newStageSummary =
    StageSummary
      { endTime = Core.Nothing,
        metrics = Core.Nothing,
        progress = Core.Nothing,
        stageId = Core.Nothing,
        startTime = Core.Nothing,
        state = Core.Nothing,
        stragglerSummary = Core.Nothing
      }
  
  instance Core.FromJSON StageSummary where
    parseJSON =
      Core.withObject
        "StageSummary"
        ( \o ->
            StageSummary
              Core.<$> (o Core..:? "endTime")
              Core.<*> (o Core..:? "metrics")
              Core.<*> (o Core..:? "progress")
              Core.<*> (o Core..:? "stageId")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "state")
              Core.<*> (o Core..:? "stragglerSummary")
        )
  
  instance Core.ToJSON StageSummary where
    toJSON StageSummary {..} =
      Core.object
        ( Core.catMaybes
            [ ("endTime" Core..=) Core.<$> endTime,
              ("metrics" Core..=) Core.<$> metrics,
              ("progress" Core..=) Core.<$> progress,
              ("stageId" Core..=) Core.<$> stageId,
              ("startTime" Core..=) Core.<$> startTime,
              ("state" Core..=) Core.<$> state,
              ("stragglerSummary" Core..=) Core.<$> stragglerSummary
            ]
        )
  
  -- | State family configuration.
  --
  -- /See:/ 'newStateFamilyConfig' smart constructor.
  data StateFamilyConfig = StateFamilyConfig
    { -- | If true, this family corresponds to a read operation.
      isRead :: (Core.Maybe Core.Bool),
      -- | The state family value.
      stateFamily :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StateFamilyConfig' with the minimum fields required to make a request.
  newStateFamilyConfig ::
    StateFamilyConfig
  newStateFamilyConfig =
    StateFamilyConfig
      { isRead = Core.Nothing,
        stateFamily = Core.Nothing
      }
  
  instance Core.FromJSON StateFamilyConfig where
    parseJSON =
      Core.withObject
        "StateFamilyConfig"
        ( \o ->
            StateFamilyConfig
              Core.<$> (o Core..:? "isRead")
              Core.<*> (o Core..:? "stateFamily")
        )
  
  instance Core.ToJSON StateFamilyConfig where
    toJSON StateFamilyConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("isRead" Core..=) Core.<$> isRead,
              ("stateFamily" Core..=) Core.<$> stateFamily
            ]
        )
  
  -- | The @Status@ type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by <https://github.com/grpc gRPC>. Each @Status@ message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the <https://cloud.google.com/apis/design/errors API Design Guide>.
  --
  -- /See:/ 'newStatus' smart constructor.
  data Status = Status
    { -- | The status code, which should be an enum value of google.rpc.Code.
      code :: (Core.Maybe Core.Int32),
      -- | A list of messages that carry the error details. There is a common set of message types for APIs to use.
      details :: (Core.Maybe [Status_DetailsItem]),
      -- | A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
      message :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Status' with the minimum fields required to make a request.
  newStatus ::
    Status
  newStatus =
    Status
      { code = Core.Nothing,
        details = Core.Nothing,
        message = Core.Nothing
      }
  
  instance Core.FromJSON Status where
    parseJSON =
      Core.withObject
        "Status"
        ( \o ->
            Status
              Core.<$> (o Core..:? "code")
              Core.<*> (o Core..:? "details")
              Core.<*> (o Core..:? "message")
        )
  
  instance Core.ToJSON Status where
    toJSON Status {..} =
      Core.object
        ( Core.catMaybes
            [ ("code" Core..=) Core.<$> code,
              ("details" Core..=) Core.<$> details,
              ("message" Core..=) Core.<$> message
            ]
        )
  
  --
  -- /See:/ 'newStatus_DetailsItem' smart constructor.
  newtype Status_DetailsItem = Status_DetailsItem
    { -- | Properties of the object. Contains field \@type with type URL.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Status_DetailsItem' with the minimum fields required to make a request.
  newStatus_DetailsItem ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Status_DetailsItem
  newStatus_DetailsItem additional =
    Status_DetailsItem {additional = additional}
  
  instance Core.FromJSON Status_DetailsItem where
    parseJSON =
      Core.withObject
        "Status_DetailsItem"
        (\o -> Status_DetailsItem Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Status_DetailsItem where
    toJSON Status_DetailsItem {..} = Core.toJSON additional
  
  -- | Defines a particular step within a Cloud Dataflow job. A job consists of multiple steps, each of which performs some specific operation as part of the overall job. Data is typically passed from one step to another as part of the job. __Note:__ The properties of this object are not stable and might change. Here\'s an example of a sequence of steps which together implement a Map-Reduce job: * Read a collection of data from some source, parsing the collection\'s elements. * Validate the elements. * Apply a user-defined function to map each element to some value and extract an element-specific key value. * Group elements with the same key into a single element with that key, transforming a multiply-keyed collection into a uniquely-keyed collection. * Write the elements out to some data sink. Note that the Cloud Dataflow service may be used to run many different types of jobs, not just Map-Reduce.
  --
  -- /See:/ 'newStep' smart constructor.
  data Step = Step
    { -- | The kind of step in the Cloud Dataflow job.
      kind :: (Core.Maybe Core.Text),
      -- | The name that identifies the step. This must be unique for each step with respect to all other steps in the Cloud Dataflow job.
      name :: (Core.Maybe Core.Text),
      -- | Named properties associated with the step. Each kind of predefined step has its own required set of properties. Must be provided on Create. Only retrieved with JOB/VIEW/ALL.
      properties :: (Core.Maybe Step_Properties)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Step' with the minimum fields required to make a request.
  newStep ::
    Step
  newStep =
    Step
      { kind = Core.Nothing,
        name = Core.Nothing,
        properties = Core.Nothing
      }
  
  instance Core.FromJSON Step where
    parseJSON =
      Core.withObject
        "Step"
        ( \o ->
            Step
              Core.<$> (o Core..:? "kind")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "properties")
        )
  
  instance Core.ToJSON Step where
    toJSON Step {..} =
      Core.object
        ( Core.catMaybes
            [ ("kind" Core..=) Core.<$> kind,
              ("name" Core..=) Core.<$> name,
              ("properties" Core..=) Core.<$> properties
            ]
        )
  
  -- | Named properties associated with the step. Each kind of predefined step has its own required set of properties. Must be provided on Create. Only retrieved with JOB/VIEW/ALL.
  --
  -- /See:/ 'newStep_Properties' smart constructor.
  newtype Step_Properties = Step_Properties
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Step_Properties' with the minimum fields required to make a request.
  newStep_Properties ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    Step_Properties
  newStep_Properties additional =
    Step_Properties {additional = additional}
  
  instance Core.FromJSON Step_Properties where
    parseJSON =
      Core.withObject
        "Step_Properties"
        (\o -> Step_Properties Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON Step_Properties where
    toJSON Step_Properties {..} = Core.toJSON additional
  
  -- | Information for a straggler.
  --
  -- /See:/ 'newStraggler' smart constructor.
  data Straggler = Straggler
    { -- | Batch straggler identification and debugging information.
      batchStraggler :: (Core.Maybe StragglerInfo),
      -- | Streaming straggler identification and debugging information.
      streamingStraggler :: (Core.Maybe StreamingStragglerInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Straggler' with the minimum fields required to make a request.
  newStraggler ::
    Straggler
  newStraggler =
    Straggler
      { batchStraggler = Core.Nothing,
        streamingStraggler = Core.Nothing
      }
  
  instance Core.FromJSON Straggler where
    parseJSON =
      Core.withObject
        "Straggler"
        ( \o ->
            Straggler
              Core.<$> (o Core..:? "batchStraggler")
              Core.<*> (o Core..:? "streamingStraggler")
        )
  
  instance Core.ToJSON Straggler where
    toJSON Straggler {..} =
      Core.object
        ( Core.catMaybes
            [ ("batchStraggler" Core..=) Core.<$> batchStraggler,
              ("streamingStraggler" Core..=) Core.<$> streamingStraggler
            ]
        )
  
  -- | Information useful for debugging a straggler. Each type will provide specialized debugging information relevant for a particular cause. The StragglerDebuggingInfo will be 1:1 mapping to the StragglerCause enum.
  --
  -- /See:/ 'newStragglerDebuggingInfo' smart constructor.
  newtype StragglerDebuggingInfo = StragglerDebuggingInfo
    { -- | Hot key debugging details.
      hotKey :: (Core.Maybe HotKeyDebuggingInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StragglerDebuggingInfo' with the minimum fields required to make a request.
  newStragglerDebuggingInfo ::
    StragglerDebuggingInfo
  newStragglerDebuggingInfo =
    StragglerDebuggingInfo {hotKey = Core.Nothing}
  
  instance Core.FromJSON StragglerDebuggingInfo where
    parseJSON =
      Core.withObject
        "StragglerDebuggingInfo"
        (\o -> StragglerDebuggingInfo Core.<$> (o Core..:? "hotKey"))
  
  instance Core.ToJSON StragglerDebuggingInfo where
    toJSON StragglerDebuggingInfo {..} =
      Core.object (Core.catMaybes [("hotKey" Core..=) Core.<$> hotKey])
  
  -- | Information useful for straggler identification and debugging.
  --
  -- /See:/ 'newStragglerInfo' smart constructor.
  data StragglerInfo = StragglerInfo
    { -- | The straggler causes, keyed by the string representation of the StragglerCause enum and contains specialized debugging information for each straggler cause.
      causes :: (Core.Maybe StragglerInfo_Causes),
      -- | The time when the work item attempt became a straggler.
      startTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StragglerInfo' with the minimum fields required to make a request.
  newStragglerInfo ::
    StragglerInfo
  newStragglerInfo =
    StragglerInfo {causes = Core.Nothing, startTime = Core.Nothing}
  
  instance Core.FromJSON StragglerInfo where
    parseJSON =
      Core.withObject
        "StragglerInfo"
        ( \o ->
            StragglerInfo
              Core.<$> (o Core..:? "causes")
              Core.<*> (o Core..:? "startTime")
        )
  
  instance Core.ToJSON StragglerInfo where
    toJSON StragglerInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("causes" Core..=) Core.<$> causes,
              ("startTime" Core..=) Core.<$> startTime
            ]
        )
  
  -- | The straggler causes, keyed by the string representation of the StragglerCause enum and contains specialized debugging information for each straggler cause.
  --
  -- /See:/ 'newStragglerInfo_Causes' smart constructor.
  newtype StragglerInfo_Causes = StragglerInfo_Causes
    { additional :: (Core.HashMap Core.Text StragglerDebuggingInfo)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StragglerInfo_Causes' with the minimum fields required to make a request.
  newStragglerInfo_Causes ::
    -- |  See 'additional'.
    Core.HashMap Core.Text StragglerDebuggingInfo ->
    StragglerInfo_Causes
  newStragglerInfo_Causes additional =
    StragglerInfo_Causes {additional = additional}
  
  instance Core.FromJSON StragglerInfo_Causes where
    parseJSON =
      Core.withObject
        "StragglerInfo_Causes"
        (\o -> StragglerInfo_Causes Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON StragglerInfo_Causes where
    toJSON StragglerInfo_Causes {..} = Core.toJSON additional
  
  -- | Summarized straggler identification details.
  --
  -- /See:/ 'newStragglerSummary' smart constructor.
  data StragglerSummary = StragglerSummary
    { -- | The most recent stragglers.
      recentStragglers :: (Core.Maybe [Straggler]),
      -- | Aggregated counts of straggler causes, keyed by the string representation of the StragglerCause enum.
      stragglerCauseCount :: (Core.Maybe StragglerSummary_StragglerCauseCount),
      -- | The total count of stragglers.
      totalStragglerCount :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StragglerSummary' with the minimum fields required to make a request.
  newStragglerSummary ::
    StragglerSummary
  newStragglerSummary =
    StragglerSummary
      { recentStragglers = Core.Nothing,
        stragglerCauseCount = Core.Nothing,
        totalStragglerCount = Core.Nothing
      }
  
  instance Core.FromJSON StragglerSummary where
    parseJSON =
      Core.withObject
        "StragglerSummary"
        ( \o ->
            StragglerSummary
              Core.<$> (o Core..:? "recentStragglers")
              Core.<*> (o Core..:? "stragglerCauseCount")
              Core.<*> ( o
                           Core..:? "totalStragglerCount"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON StragglerSummary where
    toJSON StragglerSummary {..} =
      Core.object
        ( Core.catMaybes
            [ ("recentStragglers" Core..=) Core.<$> recentStragglers,
              ("stragglerCauseCount" Core..=) Core.<$> stragglerCauseCount,
              ("totalStragglerCount" Core..=)
                Core.. Core.AsText
                Core.<$> totalStragglerCount
            ]
        )
  
  -- | Aggregated counts of straggler causes, keyed by the string representation of the StragglerCause enum.
  --
  -- /See:/ 'newStragglerSummary_StragglerCauseCount' smart constructor.
  newtype StragglerSummary_StragglerCauseCount = StragglerSummary_StragglerCauseCount
    { additional :: (Core.HashMap Core.Text Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StragglerSummary_StragglerCauseCount' with the minimum fields required to make a request.
  newStragglerSummary_StragglerCauseCount ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Int64 ->
    StragglerSummary_StragglerCauseCount
  newStragglerSummary_StragglerCauseCount additional =
    StragglerSummary_StragglerCauseCount {additional = additional}
  
  instance Core.FromJSON StragglerSummary_StragglerCauseCount where
    parseJSON =
      Core.withObject
        "StragglerSummary_StragglerCauseCount"
        ( \o ->
            StragglerSummary_StragglerCauseCount
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON StragglerSummary_StragglerCauseCount where
    toJSON StragglerSummary_StragglerCauseCount {..} =
      Core.toJSON additional
  
  -- | Describes a stream of data, either as input to be processed or as output of a streaming Dataflow job.
  --
  -- /See:/ 'newStreamLocation' smart constructor.
  data StreamLocation = StreamLocation
    { -- | The stream is a custom source.
      customSourceLocation :: (Core.Maybe CustomSourceLocation),
      -- | The stream is a pubsub stream.
      pubsubLocation :: (Core.Maybe PubsubLocation),
      -- | The stream is a streaming side input.
      sideInputLocation :: (Core.Maybe StreamingSideInputLocation),
      -- | The stream is part of another computation within the current streaming Dataflow job.
      streamingStageLocation :: (Core.Maybe StreamingStageLocation)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamLocation' with the minimum fields required to make a request.
  newStreamLocation ::
    StreamLocation
  newStreamLocation =
    StreamLocation
      { customSourceLocation = Core.Nothing,
        pubsubLocation = Core.Nothing,
        sideInputLocation = Core.Nothing,
        streamingStageLocation = Core.Nothing
      }
  
  instance Core.FromJSON StreamLocation where
    parseJSON =
      Core.withObject
        "StreamLocation"
        ( \o ->
            StreamLocation
              Core.<$> (o Core..:? "customSourceLocation")
              Core.<*> (o Core..:? "pubsubLocation")
              Core.<*> (o Core..:? "sideInputLocation")
              Core.<*> (o Core..:? "streamingStageLocation")
        )
  
  instance Core.ToJSON StreamLocation where
    toJSON StreamLocation {..} =
      Core.object
        ( Core.catMaybes
            [ ("customSourceLocation" Core..=) Core.<$> customSourceLocation,
              ("pubsubLocation" Core..=) Core.<$> pubsubLocation,
              ("sideInputLocation" Core..=) Core.<$> sideInputLocation,
              ("streamingStageLocation" Core..=)
                Core.<$> streamingStageLocation
            ]
        )
  
  -- | Streaming appliance snapshot configuration.
  --
  -- /See:/ 'newStreamingApplianceSnapshotConfig' smart constructor.
  data StreamingApplianceSnapshotConfig = StreamingApplianceSnapshotConfig
    { -- | Indicates which endpoint is used to import appliance state.
      importStateEndpoint :: (Core.Maybe Core.Text),
      -- | If set, indicates the snapshot id for the snapshot being performed.
      snapshotId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingApplianceSnapshotConfig' with the minimum fields required to make a request.
  newStreamingApplianceSnapshotConfig ::
    StreamingApplianceSnapshotConfig
  newStreamingApplianceSnapshotConfig =
    StreamingApplianceSnapshotConfig
      { importStateEndpoint =
          Core.Nothing,
        snapshotId = Core.Nothing
      }
  
  instance Core.FromJSON StreamingApplianceSnapshotConfig where
    parseJSON =
      Core.withObject
        "StreamingApplianceSnapshotConfig"
        ( \o ->
            StreamingApplianceSnapshotConfig
              Core.<$> (o Core..:? "importStateEndpoint")
              Core.<*> (o Core..:? "snapshotId")
        )
  
  instance Core.ToJSON StreamingApplianceSnapshotConfig where
    toJSON StreamingApplianceSnapshotConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("importStateEndpoint" Core..=) Core.<$> importStateEndpoint,
              ("snapshotId" Core..=) Core.<$> snapshotId
            ]
        )
  
  -- | Configuration information for a single streaming computation.
  --
  -- /See:/ 'newStreamingComputationConfig' smart constructor.
  data StreamingComputationConfig = StreamingComputationConfig
    { -- | Unique identifier for this computation.
      computationId :: (Core.Maybe Core.Text),
      -- | Instructions that comprise the computation.
      instructions :: (Core.Maybe [ParallelInstruction]),
      -- | Stage name of this computation.
      stageName :: (Core.Maybe Core.Text),
      -- | System defined name for this computation.
      systemName :: (Core.Maybe Core.Text),
      -- | Map from user name of stateful transforms in this stage to their state family.
      transformUserNameToStateFamily ::
        ( Core.Maybe
            StreamingComputationConfig_TransformUserNameToStateFamily
        )
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingComputationConfig' with the minimum fields required to make a request.
  newStreamingComputationConfig ::
    StreamingComputationConfig
  newStreamingComputationConfig =
    StreamingComputationConfig
      { computationId = Core.Nothing,
        instructions = Core.Nothing,
        stageName = Core.Nothing,
        systemName = Core.Nothing,
        transformUserNameToStateFamily = Core.Nothing
      }
  
  instance Core.FromJSON StreamingComputationConfig where
    parseJSON =
      Core.withObject
        "StreamingComputationConfig"
        ( \o ->
            StreamingComputationConfig
              Core.<$> (o Core..:? "computationId")
              Core.<*> (o Core..:? "instructions")
              Core.<*> (o Core..:? "stageName")
              Core.<*> (o Core..:? "systemName")
              Core.<*> (o Core..:? "transformUserNameToStateFamily")
        )
  
  instance Core.ToJSON StreamingComputationConfig where
    toJSON StreamingComputationConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("computationId" Core..=) Core.<$> computationId,
              ("instructions" Core..=) Core.<$> instructions,
              ("stageName" Core..=) Core.<$> stageName,
              ("systemName" Core..=) Core.<$> systemName,
              ("transformUserNameToStateFamily" Core..=)
                Core.<$> transformUserNameToStateFamily
            ]
        )
  
  -- | Map from user name of stateful transforms in this stage to their state family.
  --
  -- /See:/ 'newStreamingComputationConfig_TransformUserNameToStateFamily' smart constructor.
  newtype StreamingComputationConfig_TransformUserNameToStateFamily = StreamingComputationConfig_TransformUserNameToStateFamily
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingComputationConfig_TransformUserNameToStateFamily' with the minimum fields required to make a request.
  newStreamingComputationConfig_TransformUserNameToStateFamily ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    StreamingComputationConfig_TransformUserNameToStateFamily
  newStreamingComputationConfig_TransformUserNameToStateFamily
    additional =
      StreamingComputationConfig_TransformUserNameToStateFamily
        { additional =
            additional
        }
  
  instance
    Core.FromJSON
      StreamingComputationConfig_TransformUserNameToStateFamily
    where
    parseJSON =
      Core.withObject
        "StreamingComputationConfig_TransformUserNameToStateFamily"
        ( \o ->
            StreamingComputationConfig_TransformUserNameToStateFamily
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance
    Core.ToJSON
      StreamingComputationConfig_TransformUserNameToStateFamily
    where
    toJSON
      StreamingComputationConfig_TransformUserNameToStateFamily {..} =
        Core.toJSON additional
  
  -- | Describes full or partial data disk assignment information of the computation ranges.
  --
  -- /See:/ 'newStreamingComputationRanges' smart constructor.
  data StreamingComputationRanges = StreamingComputationRanges
    { -- | The ID of the computation.
      computationId :: (Core.Maybe Core.Text),
      -- | Data disk assignments for ranges from this computation.
      rangeAssignments :: (Core.Maybe [KeyRangeDataDiskAssignment])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingComputationRanges' with the minimum fields required to make a request.
  newStreamingComputationRanges ::
    StreamingComputationRanges
  newStreamingComputationRanges =
    StreamingComputationRanges
      { computationId = Core.Nothing,
        rangeAssignments = Core.Nothing
      }
  
  instance Core.FromJSON StreamingComputationRanges where
    parseJSON =
      Core.withObject
        "StreamingComputationRanges"
        ( \o ->
            StreamingComputationRanges
              Core.<$> (o Core..:? "computationId")
              Core.<*> (o Core..:? "rangeAssignments")
        )
  
  instance Core.ToJSON StreamingComputationRanges where
    toJSON StreamingComputationRanges {..} =
      Core.object
        ( Core.catMaybes
            [ ("computationId" Core..=) Core.<$> computationId,
              ("rangeAssignments" Core..=) Core.<$> rangeAssignments
            ]
        )
  
  -- | A task which describes what action should be performed for the specified streaming computation ranges.
  --
  -- /See:/ 'newStreamingComputationTask' smart constructor.
  data StreamingComputationTask = StreamingComputationTask
    { -- | Contains ranges of a streaming computation this task should apply to.
      computationRanges :: (Core.Maybe [StreamingComputationRanges]),
      -- | Describes the set of data disks this task should apply to.
      dataDisks :: (Core.Maybe [MountedDataDisk]),
      -- | A type of streaming computation task.
      taskType :: (Core.Maybe StreamingComputationTask_TaskType)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingComputationTask' with the minimum fields required to make a request.
  newStreamingComputationTask ::
    StreamingComputationTask
  newStreamingComputationTask =
    StreamingComputationTask
      { computationRanges = Core.Nothing,
        dataDisks = Core.Nothing,
        taskType = Core.Nothing
      }
  
  instance Core.FromJSON StreamingComputationTask where
    parseJSON =
      Core.withObject
        "StreamingComputationTask"
        ( \o ->
            StreamingComputationTask
              Core.<$> (o Core..:? "computationRanges")
              Core.<*> (o Core..:? "dataDisks")
              Core.<*> (o Core..:? "taskType")
        )
  
  instance Core.ToJSON StreamingComputationTask where
    toJSON StreamingComputationTask {..} =
      Core.object
        ( Core.catMaybes
            [ ("computationRanges" Core..=) Core.<$> computationRanges,
              ("dataDisks" Core..=) Core.<$> dataDisks,
              ("taskType" Core..=) Core.<$> taskType
            ]
        )
  
  -- | A task that carries configuration information for streaming computations.
  --
  -- /See:/ 'newStreamingConfigTask' smart constructor.
  data StreamingConfigTask = StreamingConfigTask
    { -- | Chunk size for commit streams from the harness to windmill.
      commitStreamChunkSizeBytes :: (Core.Maybe Core.Int64),
      -- | Chunk size for get data streams from the harness to windmill.
      getDataStreamChunkSizeBytes :: (Core.Maybe Core.Int64),
      -- | Maximum size for work item commit supported windmill storage layer.
      maxWorkItemCommitBytes :: (Core.Maybe Core.Int64),
      -- | Operational limits for the streaming job. Can be used by the worker to validate outputs sent to the backend.
      operationalLimits :: (Core.Maybe StreamingOperationalLimits),
      -- | Set of computation configuration information.
      streamingComputationConfigs :: (Core.Maybe [StreamingComputationConfig]),
      -- | Map from user step names to state families.
      userStepToStateFamilyNameMap :: (Core.Maybe StreamingConfigTask_UserStepToStateFamilyNameMap),
      -- | Binary encoded proto to control runtime behavior of the java runner v1 user worker.
      userWorkerRunnerV1Settings :: (Core.Maybe Core.Base64),
      -- | Binary encoded proto to control runtime behavior of the runner v2 user worker.
      userWorkerRunnerV2Settings :: (Core.Maybe Core.Base64),
      -- | If present, the worker must use this endpoint to communicate with Windmill Service dispatchers, otherwise the worker must continue to use whatever endpoint it had been using.
      windmillServiceEndpoint :: (Core.Maybe Core.Text),
      -- | If present, the worker must use this port to communicate with Windmill Service dispatchers. Only applicable when windmill/service/endpoint is specified.
      windmillServicePort :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingConfigTask' with the minimum fields required to make a request.
  newStreamingConfigTask ::
    StreamingConfigTask
  newStreamingConfigTask =
    StreamingConfigTask
      { commitStreamChunkSizeBytes = Core.Nothing,
        getDataStreamChunkSizeBytes = Core.Nothing,
        maxWorkItemCommitBytes = Core.Nothing,
        operationalLimits = Core.Nothing,
        streamingComputationConfigs = Core.Nothing,
        userStepToStateFamilyNameMap = Core.Nothing,
        userWorkerRunnerV1Settings = Core.Nothing,
        userWorkerRunnerV2Settings = Core.Nothing,
        windmillServiceEndpoint = Core.Nothing,
        windmillServicePort = Core.Nothing
      }
  
  instance Core.FromJSON StreamingConfigTask where
    parseJSON =
      Core.withObject
        "StreamingConfigTask"
        ( \o ->
            StreamingConfigTask
              Core.<$> ( o
                           Core..:? "commitStreamChunkSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "getDataStreamChunkSizeBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "maxWorkItemCommitBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "operationalLimits")
              Core.<*> (o Core..:? "streamingComputationConfigs")
              Core.<*> (o Core..:? "userStepToStateFamilyNameMap")
              Core.<*> (o Core..:? "userWorkerRunnerV1Settings")
              Core.<*> (o Core..:? "userWorkerRunnerV2Settings")
              Core.<*> (o Core..:? "windmillServiceEndpoint")
              Core.<*> ( o
                           Core..:? "windmillServicePort"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON StreamingConfigTask where
    toJSON StreamingConfigTask {..} =
      Core.object
        ( Core.catMaybes
            [ ("commitStreamChunkSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> commitStreamChunkSizeBytes,
              ("getDataStreamChunkSizeBytes" Core..=)
                Core.. Core.AsText
                Core.<$> getDataStreamChunkSizeBytes,
              ("maxWorkItemCommitBytes" Core..=)
                Core.. Core.AsText
                Core.<$> maxWorkItemCommitBytes,
              ("operationalLimits" Core..=) Core.<$> operationalLimits,
              ("streamingComputationConfigs" Core..=)
                Core.<$> streamingComputationConfigs,
              ("userStepToStateFamilyNameMap" Core..=)
                Core.<$> userStepToStateFamilyNameMap,
              ("userWorkerRunnerV1Settings" Core..=)
                Core.<$> userWorkerRunnerV1Settings,
              ("userWorkerRunnerV2Settings" Core..=)
                Core.<$> userWorkerRunnerV2Settings,
              ("windmillServiceEndpoint" Core..=)
                Core.<$> windmillServiceEndpoint,
              ("windmillServicePort" Core..=)
                Core.. Core.AsText
                Core.<$> windmillServicePort
            ]
        )
  
  -- | Map from user step names to state families.
  --
  -- /See:/ 'newStreamingConfigTask_UserStepToStateFamilyNameMap' smart constructor.
  newtype StreamingConfigTask_UserStepToStateFamilyNameMap = StreamingConfigTask_UserStepToStateFamilyNameMap
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingConfigTask_UserStepToStateFamilyNameMap' with the minimum fields required to make a request.
  newStreamingConfigTask_UserStepToStateFamilyNameMap ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    StreamingConfigTask_UserStepToStateFamilyNameMap
  newStreamingConfigTask_UserStepToStateFamilyNameMap additional =
    StreamingConfigTask_UserStepToStateFamilyNameMap
      { additional =
          additional
      }
  
  instance
    Core.FromJSON
      StreamingConfigTask_UserStepToStateFamilyNameMap
    where
    parseJSON =
      Core.withObject
        "StreamingConfigTask_UserStepToStateFamilyNameMap"
        ( \o ->
            StreamingConfigTask_UserStepToStateFamilyNameMap
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance
    Core.ToJSON
      StreamingConfigTask_UserStepToStateFamilyNameMap
    where
    toJSON StreamingConfigTask_UserStepToStateFamilyNameMap {..} =
      Core.toJSON additional
  
  -- | Operational limits imposed on streaming jobs by the backend.
  --
  -- /See:/ 'newStreamingOperationalLimits' smart constructor.
  data StreamingOperationalLimits = StreamingOperationalLimits
    { -- | The maximum size for an element in bag state.
      maxBagElementBytes :: (Core.Maybe Core.Int64),
      -- | The maximum size for an element in global data.
      maxGlobalDataBytes :: (Core.Maybe Core.Int64),
      -- | The maximum size allowed for a key.
      maxKeyBytes :: (Core.Maybe Core.Int64),
      -- | The maximum size for a single output element.
      maxProductionOutputBytes :: (Core.Maybe Core.Int64),
      -- | The maximum size for an element in sorted list state.
      maxSortedListElementBytes :: (Core.Maybe Core.Int64),
      -- | The maximum size for a source state update.
      maxSourceStateBytes :: (Core.Maybe Core.Int64),
      -- | The maximum size for a state tag.
      maxTagBytes :: (Core.Maybe Core.Int64),
      -- | The maximum size for a value state field.
      maxValueBytes :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingOperationalLimits' with the minimum fields required to make a request.
  newStreamingOperationalLimits ::
    StreamingOperationalLimits
  newStreamingOperationalLimits =
    StreamingOperationalLimits
      { maxBagElementBytes = Core.Nothing,
        maxGlobalDataBytes = Core.Nothing,
        maxKeyBytes = Core.Nothing,
        maxProductionOutputBytes = Core.Nothing,
        maxSortedListElementBytes = Core.Nothing,
        maxSourceStateBytes = Core.Nothing,
        maxTagBytes = Core.Nothing,
        maxValueBytes = Core.Nothing
      }
  
  instance Core.FromJSON StreamingOperationalLimits where
    parseJSON =
      Core.withObject
        "StreamingOperationalLimits"
        ( \o ->
            StreamingOperationalLimits
              Core.<$> ( o
                           Core..:? "maxBagElementBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "maxGlobalDataBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "maxKeyBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> ( o
                           Core..:? "maxProductionOutputBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "maxSortedListElementBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "maxSourceStateBytes"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "maxTagBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "maxValueBytes" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON StreamingOperationalLimits where
    toJSON StreamingOperationalLimits {..} =
      Core.object
        ( Core.catMaybes
            [ ("maxBagElementBytes" Core..=)
                Core.. Core.AsText
                Core.<$> maxBagElementBytes,
              ("maxGlobalDataBytes" Core..=)
                Core.. Core.AsText
                Core.<$> maxGlobalDataBytes,
              ("maxKeyBytes" Core..=) Core.. Core.AsText Core.<$> maxKeyBytes,
              ("maxProductionOutputBytes" Core..=)
                Core.. Core.AsText
                Core.<$> maxProductionOutputBytes,
              ("maxSortedListElementBytes" Core..=)
                Core.. Core.AsText
                Core.<$> maxSortedListElementBytes,
              ("maxSourceStateBytes" Core..=)
                Core.. Core.AsText
                Core.<$> maxSourceStateBytes,
              ("maxTagBytes" Core..=) Core.. Core.AsText Core.<$> maxTagBytes,
              ("maxValueBytes" Core..=)
                Core.. Core.AsText
                Core.<$> maxValueBytes
            ]
        )
  
  -- | Contains per-user worker telemetry used in streaming autoscaling.
  --
  -- /See:/ 'newStreamingScalingReport' smart constructor.
  data StreamingScalingReport = StreamingScalingReport
    { activeBundleCount :: (Core.Maybe Core.Int32),
      -- | Current acive thread count.
      activeThreadCount :: (Core.Maybe Core.Int32),
      -- | Maximum bundle count.
      maximumBundleCount :: (Core.Maybe Core.Int32),
      -- | Maximum bytes.
      maximumBytes :: (Core.Maybe Core.Int64),
      maximumBytesCount :: (Core.Maybe Core.Int32),
      -- | Maximum thread count limit.
      maximumThreadCount :: (Core.Maybe Core.Int32),
      -- | Current outstanding bundle count.
      outstandingBundleCount :: (Core.Maybe Core.Int32),
      -- | Current outstanding bytes.
      outstandingBytes :: (Core.Maybe Core.Int64),
      outstandingBytesCount :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingScalingReport' with the minimum fields required to make a request.
  newStreamingScalingReport ::
    StreamingScalingReport
  newStreamingScalingReport =
    StreamingScalingReport
      { activeBundleCount = Core.Nothing,
        activeThreadCount = Core.Nothing,
        maximumBundleCount = Core.Nothing,
        maximumBytes = Core.Nothing,
        maximumBytesCount = Core.Nothing,
        maximumThreadCount = Core.Nothing,
        outstandingBundleCount = Core.Nothing,
        outstandingBytes = Core.Nothing,
        outstandingBytesCount = Core.Nothing
      }
  
  instance Core.FromJSON StreamingScalingReport where
    parseJSON =
      Core.withObject
        "StreamingScalingReport"
        ( \o ->
            StreamingScalingReport
              Core.<$> (o Core..:? "activeBundleCount")
              Core.<*> (o Core..:? "activeThreadCount")
              Core.<*> (o Core..:? "maximumBundleCount")
              Core.<*> (o Core..:? "maximumBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "maximumBytesCount")
              Core.<*> (o Core..:? "maximumThreadCount")
              Core.<*> (o Core..:? "outstandingBundleCount")
              Core.<*> (o Core..:? "outstandingBytes" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "outstandingBytesCount")
        )
  
  instance Core.ToJSON StreamingScalingReport where
    toJSON StreamingScalingReport {..} =
      Core.object
        ( Core.catMaybes
            [ ("activeBundleCount" Core..=) Core.<$> activeBundleCount,
              ("activeThreadCount" Core..=) Core.<$> activeThreadCount,
              ("maximumBundleCount" Core..=) Core.<$> maximumBundleCount,
              ("maximumBytes" Core..=) Core.. Core.AsText Core.<$> maximumBytes,
              ("maximumBytesCount" Core..=) Core.<$> maximumBytesCount,
              ("maximumThreadCount" Core..=) Core.<$> maximumThreadCount,
              ("outstandingBundleCount" Core..=) Core.<$> outstandingBundleCount,
              ("outstandingBytes" Core..=)
                Core.. Core.AsText
                Core.<$> outstandingBytes,
              ("outstandingBytesCount" Core..=) Core.<$> outstandingBytesCount
            ]
        )
  
  -- | Contains per-user-worker streaming scaling recommendation from the backend.
  --
  -- /See:/ 'newStreamingScalingReportResponse' smart constructor.
  newtype StreamingScalingReportResponse = StreamingScalingReportResponse
    { -- | Maximum thread count limit;
      maximumThreadCount :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingScalingReportResponse' with the minimum fields required to make a request.
  newStreamingScalingReportResponse ::
    StreamingScalingReportResponse
  newStreamingScalingReportResponse =
    StreamingScalingReportResponse {maximumThreadCount = Core.Nothing}
  
  instance Core.FromJSON StreamingScalingReportResponse where
    parseJSON =
      Core.withObject
        "StreamingScalingReportResponse"
        ( \o ->
            StreamingScalingReportResponse
              Core.<$> (o Core..:? "maximumThreadCount")
        )
  
  instance Core.ToJSON StreamingScalingReportResponse where
    toJSON StreamingScalingReportResponse {..} =
      Core.object
        ( Core.catMaybes
            [("maximumThreadCount" Core..=) Core.<$> maximumThreadCount]
        )
  
  -- | A task which initializes part of a streaming Dataflow job.
  --
  -- /See:/ 'newStreamingSetupTask' smart constructor.
  data StreamingSetupTask = StreamingSetupTask
    { -- | The user has requested drain.
      drain :: (Core.Maybe Core.Bool),
      -- | The TCP port on which the worker should listen for messages from other streaming computation workers.
      receiveWorkPort :: (Core.Maybe Core.Int32),
      -- | Configures streaming appliance snapshot.
      snapshotConfig :: (Core.Maybe StreamingApplianceSnapshotConfig),
      -- | The global topology of the streaming Dataflow job.
      streamingComputationTopology :: (Core.Maybe TopologyConfig),
      -- | The TCP port used by the worker to communicate with the Dataflow worker harness.
      workerHarnessPort :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingSetupTask' with the minimum fields required to make a request.
  newStreamingSetupTask ::
    StreamingSetupTask
  newStreamingSetupTask =
    StreamingSetupTask
      { drain = Core.Nothing,
        receiveWorkPort = Core.Nothing,
        snapshotConfig = Core.Nothing,
        streamingComputationTopology = Core.Nothing,
        workerHarnessPort = Core.Nothing
      }
  
  instance Core.FromJSON StreamingSetupTask where
    parseJSON =
      Core.withObject
        "StreamingSetupTask"
        ( \o ->
            StreamingSetupTask
              Core.<$> (o Core..:? "drain")
              Core.<*> (o Core..:? "receiveWorkPort")
              Core.<*> (o Core..:? "snapshotConfig")
              Core.<*> (o Core..:? "streamingComputationTopology")
              Core.<*> (o Core..:? "workerHarnessPort")
        )
  
  instance Core.ToJSON StreamingSetupTask where
    toJSON StreamingSetupTask {..} =
      Core.object
        ( Core.catMaybes
            [ ("drain" Core..=) Core.<$> drain,
              ("receiveWorkPort" Core..=) Core.<$> receiveWorkPort,
              ("snapshotConfig" Core..=) Core.<$> snapshotConfig,
              ("streamingComputationTopology" Core..=)
                Core.<$> streamingComputationTopology,
              ("workerHarnessPort" Core..=) Core.<$> workerHarnessPort
            ]
        )
  
  -- | Identifies the location of a streaming side input.
  --
  -- /See:/ 'newStreamingSideInputLocation' smart constructor.
  data StreamingSideInputLocation = StreamingSideInputLocation
    { -- | Identifies the state family where this side input is stored.
      stateFamily :: (Core.Maybe Core.Text),
      -- | Identifies the particular side input within the streaming Dataflow job.
      tag :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingSideInputLocation' with the minimum fields required to make a request.
  newStreamingSideInputLocation ::
    StreamingSideInputLocation
  newStreamingSideInputLocation =
    StreamingSideInputLocation
      { stateFamily = Core.Nothing,
        tag = Core.Nothing
      }
  
  instance Core.FromJSON StreamingSideInputLocation where
    parseJSON =
      Core.withObject
        "StreamingSideInputLocation"
        ( \o ->
            StreamingSideInputLocation
              Core.<$> (o Core..:? "stateFamily")
              Core.<*> (o Core..:? "tag")
        )
  
  instance Core.ToJSON StreamingSideInputLocation where
    toJSON StreamingSideInputLocation {..} =
      Core.object
        ( Core.catMaybes
            [ ("stateFamily" Core..=) Core.<$> stateFamily,
              ("tag" Core..=) Core.<$> tag
            ]
        )
  
  -- | Identifies the location of a streaming computation stage, for stage-to-stage communication.
  --
  -- /See:/ 'newStreamingStageLocation' smart constructor.
  newtype StreamingStageLocation = StreamingStageLocation
    { -- | Identifies the particular stream within the streaming Dataflow job.
      streamId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingStageLocation' with the minimum fields required to make a request.
  newStreamingStageLocation ::
    StreamingStageLocation
  newStreamingStageLocation =
    StreamingStageLocation {streamId = Core.Nothing}
  
  instance Core.FromJSON StreamingStageLocation where
    parseJSON =
      Core.withObject
        "StreamingStageLocation"
        (\o -> StreamingStageLocation Core.<$> (o Core..:? "streamId"))
  
  instance Core.ToJSON StreamingStageLocation where
    toJSON StreamingStageLocation {..} =
      Core.object
        (Core.catMaybes [("streamId" Core..=) Core.<$> streamId])
  
  -- | Information useful for streaming straggler identification and debugging.
  --
  -- /See:/ 'newStreamingStragglerInfo' smart constructor.
  data StreamingStragglerInfo = StreamingStragglerInfo
    { -- | The event-time watermark lag at the time of the straggler detection.
      dataWatermarkLag :: (Core.Maybe Core.Duration),
      -- | End time of this straggler.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Start time of this straggler.
      startTime :: (Core.Maybe Core.DateTime),
      -- | The system watermark lag at the time of the straggler detection.
      systemWatermarkLag :: (Core.Maybe Core.Duration),
      -- | Name of the worker where the straggler was detected.
      workerName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StreamingStragglerInfo' with the minimum fields required to make a request.
  newStreamingStragglerInfo ::
    StreamingStragglerInfo
  newStreamingStragglerInfo =
    StreamingStragglerInfo
      { dataWatermarkLag = Core.Nothing,
        endTime = Core.Nothing,
        startTime = Core.Nothing,
        systemWatermarkLag = Core.Nothing,
        workerName = Core.Nothing
      }
  
  instance Core.FromJSON StreamingStragglerInfo where
    parseJSON =
      Core.withObject
        "StreamingStragglerInfo"
        ( \o ->
            StreamingStragglerInfo
              Core.<$> (o Core..:? "dataWatermarkLag")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "systemWatermarkLag")
              Core.<*> (o Core..:? "workerName")
        )
  
  instance Core.ToJSON StreamingStragglerInfo where
    toJSON StreamingStragglerInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataWatermarkLag" Core..=) Core.<$> dataWatermarkLag,
              ("endTime" Core..=) Core.<$> endTime,
              ("startTime" Core..=) Core.<$> startTime,
              ("systemWatermarkLag" Core..=) Core.<$> systemWatermarkLag,
              ("workerName" Core..=) Core.<$> workerName
            ]
        )
  
  -- | A metric value representing a list of strings.
  --
  -- /See:/ 'newStringList' smart constructor.
  newtype StringList = StringList
    { -- | Elements of the list.
      elements :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StringList' with the minimum fields required to make a request.
  newStringList ::
    StringList
  newStringList = StringList {elements = Core.Nothing}
  
  instance Core.FromJSON StringList where
    parseJSON =
      Core.withObject
        "StringList"
        (\o -> StringList Core.<$> (o Core..:? "elements"))
  
  instance Core.ToJSON StringList where
    toJSON StringList {..} =
      Core.object
        (Core.catMaybes [("elements" Core..=) Core.<$> elements])
  
  -- | A rich message format, including a human readable string, a key for identifying the message, and structured data associated with the message for programmatic consumption.
  --
  -- /See:/ 'newStructuredMessage' smart constructor.
  data StructuredMessage = StructuredMessage
    { -- | Identifier for this message type. Used by external systems to internationalize or personalize message.
      messageKey :: (Core.Maybe Core.Text),
      -- | Human-readable version of message.
      messageText :: (Core.Maybe Core.Text),
      -- | The structured data associated with this message.
      parameters :: (Core.Maybe [Parameter])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'StructuredMessage' with the minimum fields required to make a request.
  newStructuredMessage ::
    StructuredMessage
  newStructuredMessage =
    StructuredMessage
      { messageKey = Core.Nothing,
        messageText = Core.Nothing,
        parameters = Core.Nothing
      }
  
  instance Core.FromJSON StructuredMessage where
    parseJSON =
      Core.withObject
        "StructuredMessage"
        ( \o ->
            StructuredMessage
              Core.<$> (o Core..:? "messageKey")
              Core.<*> (o Core..:? "messageText")
              Core.<*> (o Core..:? "parameters")
        )
  
  instance Core.ToJSON StructuredMessage where
    toJSON StructuredMessage {..} =
      Core.object
        ( Core.catMaybes
            [ ("messageKey" Core..=) Core.<$> messageKey,
              ("messageText" Core..=) Core.<$> messageText,
              ("parameters" Core..=) Core.<$> parameters
            ]
        )
  
  -- | Taskrunner configuration settings.
  --
  -- /See:/ 'newTaskRunnerSettings' smart constructor.
  data TaskRunnerSettings = TaskRunnerSettings
    { -- | Whether to also send taskrunner log info to stderr.
      alsologtostderr :: (Core.Maybe Core.Bool),
      -- | The location on the worker for task-specific subdirectories.
      baseTaskDir :: (Core.Maybe Core.Text),
      -- | The base URL for the taskrunner to use when accessing Google Cloud APIs. When workers access Google Cloud APIs, they logically do so via relative URLs. If this field is specified, it supplies the base URL to use for resolving these relative URLs. The normative algorithm used is defined by RFC 1808, \"Relative Uniform Resource Locators\". If not specified, the default value is \"http:\/\/www.googleapis.com\/\"
      baseUrl :: (Core.Maybe Core.Text),
      -- | The file to store preprocessing commands in.
      commandlinesFileName :: (Core.Maybe Core.Text),
      -- | Whether to continue taskrunner if an exception is hit.
      continueOnException :: (Core.Maybe Core.Bool),
      -- | The API version of endpoint, e.g. \"v1b3\"
      dataflowApiVersion :: (Core.Maybe Core.Text),
      -- | The command to launch the worker harness.
      harnessCommand :: (Core.Maybe Core.Text),
      -- | The suggested backend language.
      languageHint :: (Core.Maybe Core.Text),
      -- | The directory on the VM to store logs.
      logDir :: (Core.Maybe Core.Text),
      -- | Whether to send taskrunner log info to Google Compute Engine VM serial console.
      logToSerialconsole :: (Core.Maybe Core.Bool),
      -- | Indicates where to put logs. If this is not specified, the logs will not be uploaded. The supported resource type is: Google Cloud Storage: storage.googleapis.com\/{bucket}\/{object} bucket.storage.googleapis.com\/{object}
      logUploadLocation :: (Core.Maybe Core.Text),
      -- | The OAuth2 scopes to be requested by the taskrunner in order to access the Cloud Dataflow API.
      oauthScopes :: (Core.Maybe [Core.Text]),
      -- | The settings to pass to the parallel worker harness.
      parallelWorkerSettings :: (Core.Maybe WorkerSettings),
      -- | The streaming worker main class name.
      streamingWorkerMainClass :: (Core.Maybe Core.Text),
      -- | The UNIX group ID on the worker VM to use for tasks launched by taskrunner; e.g. \"wheel\".
      taskGroup :: (Core.Maybe Core.Text),
      -- | The UNIX user ID on the worker VM to use for tasks launched by taskrunner; e.g. \"root\".
      taskUser :: (Core.Maybe Core.Text),
      -- | The prefix of the resources the taskrunner should use for temporary storage. The supported resource type is: Google Cloud Storage: storage.googleapis.com\/{bucket}\/{object} bucket.storage.googleapis.com\/{object}
      tempStoragePrefix :: (Core.Maybe Core.Text),
      -- | The ID string of the VM.
      vmId :: (Core.Maybe Core.Text),
      -- | The file to store the workflow in.
      workflowFileName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TaskRunnerSettings' with the minimum fields required to make a request.
  newTaskRunnerSettings ::
    TaskRunnerSettings
  newTaskRunnerSettings =
    TaskRunnerSettings
      { alsologtostderr = Core.Nothing,
        baseTaskDir = Core.Nothing,
        baseUrl = Core.Nothing,
        commandlinesFileName = Core.Nothing,
        continueOnException = Core.Nothing,
        dataflowApiVersion = Core.Nothing,
        harnessCommand = Core.Nothing,
        languageHint = Core.Nothing,
        logDir = Core.Nothing,
        logToSerialconsole = Core.Nothing,
        logUploadLocation = Core.Nothing,
        oauthScopes = Core.Nothing,
        parallelWorkerSettings = Core.Nothing,
        streamingWorkerMainClass = Core.Nothing,
        taskGroup = Core.Nothing,
        taskUser = Core.Nothing,
        tempStoragePrefix = Core.Nothing,
        vmId = Core.Nothing,
        workflowFileName = Core.Nothing
      }
  
  instance Core.FromJSON TaskRunnerSettings where
    parseJSON =
      Core.withObject
        "TaskRunnerSettings"
        ( \o ->
            TaskRunnerSettings
              Core.<$> (o Core..:? "alsologtostderr")
              Core.<*> (o Core..:? "baseTaskDir")
              Core.<*> (o Core..:? "baseUrl")
              Core.<*> (o Core..:? "commandlinesFileName")
              Core.<*> (o Core..:? "continueOnException")
              Core.<*> (o Core..:? "dataflowApiVersion")
              Core.<*> (o Core..:? "harnessCommand")
              Core.<*> (o Core..:? "languageHint")
              Core.<*> (o Core..:? "logDir")
              Core.<*> (o Core..:? "logToSerialconsole")
              Core.<*> (o Core..:? "logUploadLocation")
              Core.<*> (o Core..:? "oauthScopes")
              Core.<*> (o Core..:? "parallelWorkerSettings")
              Core.<*> (o Core..:? "streamingWorkerMainClass")
              Core.<*> (o Core..:? "taskGroup")
              Core.<*> (o Core..:? "taskUser")
              Core.<*> (o Core..:? "tempStoragePrefix")
              Core.<*> (o Core..:? "vmId")
              Core.<*> (o Core..:? "workflowFileName")
        )
  
  instance Core.ToJSON TaskRunnerSettings where
    toJSON TaskRunnerSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("alsologtostderr" Core..=) Core.<$> alsologtostderr,
              ("baseTaskDir" Core..=) Core.<$> baseTaskDir,
              ("baseUrl" Core..=) Core.<$> baseUrl,
              ("commandlinesFileName" Core..=) Core.<$> commandlinesFileName,
              ("continueOnException" Core..=) Core.<$> continueOnException,
              ("dataflowApiVersion" Core..=) Core.<$> dataflowApiVersion,
              ("harnessCommand" Core..=) Core.<$> harnessCommand,
              ("languageHint" Core..=) Core.<$> languageHint,
              ("logDir" Core..=) Core.<$> logDir,
              ("logToSerialconsole" Core..=) Core.<$> logToSerialconsole,
              ("logUploadLocation" Core..=) Core.<$> logUploadLocation,
              ("oauthScopes" Core..=) Core.<$> oauthScopes,
              ("parallelWorkerSettings" Core..=) Core.<$> parallelWorkerSettings,
              ("streamingWorkerMainClass" Core..=)
                Core.<$> streamingWorkerMainClass,
              ("taskGroup" Core..=) Core.<$> taskGroup,
              ("taskUser" Core..=) Core.<$> taskUser,
              ("tempStoragePrefix" Core..=) Core.<$> tempStoragePrefix,
              ("vmId" Core..=) Core.<$> vmId,
              ("workflowFileName" Core..=) Core.<$> workflowFileName
            ]
        )
  
  -- | Metadata describing a template.
  --
  -- /See:/ 'newTemplateMetadata' smart constructor.
  data TemplateMetadata = TemplateMetadata
    { -- | Optional. Indicates the default streaming mode for a streaming template. Only valid if both supports/at/least/once and supports/exactly/once are true. Possible values: UNSPECIFIED, EXACTLY/ONCE and AT/LEAST/ONCE
      defaultStreamingMode :: (Core.Maybe Core.Text),
      -- | Optional. A description of the template.
      description :: (Core.Maybe Core.Text),
      -- | Required. The name of the template.
      name :: (Core.Maybe Core.Text),
      -- | The parameters for the template.
      parameters :: (Core.Maybe [ParameterMetadata]),
      -- | Optional. Indicates if the template is streaming or not.
      streaming :: (Core.Maybe Core.Bool),
      -- | Optional. Indicates if the streaming template supports at least once mode.
      supportsAtLeastOnce :: (Core.Maybe Core.Bool),
      -- | Optional. Indicates if the streaming template supports exactly once mode.
      supportsExactlyOnce :: (Core.Maybe Core.Bool),
      -- | Optional. For future use.
      yamlDefinition :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TemplateMetadata' with the minimum fields required to make a request.
  newTemplateMetadata ::
    TemplateMetadata
  newTemplateMetadata =
    TemplateMetadata
      { defaultStreamingMode = Core.Nothing,
        description = Core.Nothing,
        name = Core.Nothing,
        parameters = Core.Nothing,
        streaming = Core.Nothing,
        supportsAtLeastOnce = Core.Nothing,
        supportsExactlyOnce = Core.Nothing,
        yamlDefinition = Core.Nothing
      }
  
  instance Core.FromJSON TemplateMetadata where
    parseJSON =
      Core.withObject
        "TemplateMetadata"
        ( \o ->
            TemplateMetadata
              Core.<$> (o Core..:? "defaultStreamingMode")
              Core.<*> (o Core..:? "description")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "parameters")
              Core.<*> (o Core..:? "streaming")
              Core.<*> (o Core..:? "supportsAtLeastOnce")
              Core.<*> (o Core..:? "supportsExactlyOnce")
              Core.<*> (o Core..:? "yamlDefinition")
        )
  
  instance Core.ToJSON TemplateMetadata where
    toJSON TemplateMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("defaultStreamingMode" Core..=) Core.<$> defaultStreamingMode,
              ("description" Core..=) Core.<$> description,
              ("name" Core..=) Core.<$> name,
              ("parameters" Core..=) Core.<$> parameters,
              ("streaming" Core..=) Core.<$> streaming,
              ("supportsAtLeastOnce" Core..=) Core.<$> supportsAtLeastOnce,
              ("supportsExactlyOnce" Core..=) Core.<$> supportsExactlyOnce,
              ("yamlDefinition" Core..=) Core.<$> yamlDefinition
            ]
        )
  
  -- | Global topology of the streaming Dataflow job, including all computations and their sharded locations.
  --
  -- /See:/ 'newTopologyConfig' smart constructor.
  data TopologyConfig = TopologyConfig
    { -- | The computations associated with a streaming Dataflow job.
      computations :: (Core.Maybe [ComputationTopology]),
      -- | The disks assigned to a streaming Dataflow job.
      dataDiskAssignments :: (Core.Maybe [DataDiskAssignment]),
      -- | The size (in bits) of keys that will be assigned to source messages.
      forwardingKeyBits :: (Core.Maybe Core.Int32),
      -- | Version number for persistent state.
      persistentStateVersion :: (Core.Maybe Core.Int32),
      -- | Maps user stage names to stable computation names.
      userStageToComputationNameMap :: (Core.Maybe TopologyConfig_UserStageToComputationNameMap)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TopologyConfig' with the minimum fields required to make a request.
  newTopologyConfig ::
    TopologyConfig
  newTopologyConfig =
    TopologyConfig
      { computations = Core.Nothing,
        dataDiskAssignments = Core.Nothing,
        forwardingKeyBits = Core.Nothing,
        persistentStateVersion = Core.Nothing,
        userStageToComputationNameMap = Core.Nothing
      }
  
  instance Core.FromJSON TopologyConfig where
    parseJSON =
      Core.withObject
        "TopologyConfig"
        ( \o ->
            TopologyConfig
              Core.<$> (o Core..:? "computations")
              Core.<*> (o Core..:? "dataDiskAssignments")
              Core.<*> (o Core..:? "forwardingKeyBits")
              Core.<*> (o Core..:? "persistentStateVersion")
              Core.<*> (o Core..:? "userStageToComputationNameMap")
        )
  
  instance Core.ToJSON TopologyConfig where
    toJSON TopologyConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("computations" Core..=) Core.<$> computations,
              ("dataDiskAssignments" Core..=) Core.<$> dataDiskAssignments,
              ("forwardingKeyBits" Core..=) Core.<$> forwardingKeyBits,
              ("persistentStateVersion" Core..=) Core.<$> persistentStateVersion,
              ("userStageToComputationNameMap" Core..=)
                Core.<$> userStageToComputationNameMap
            ]
        )
  
  -- | Maps user stage names to stable computation names.
  --
  -- /See:/ 'newTopologyConfig_UserStageToComputationNameMap' smart constructor.
  newtype TopologyConfig_UserStageToComputationNameMap = TopologyConfig_UserStageToComputationNameMap
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TopologyConfig_UserStageToComputationNameMap' with the minimum fields required to make a request.
  newTopologyConfig_UserStageToComputationNameMap ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    TopologyConfig_UserStageToComputationNameMap
  newTopologyConfig_UserStageToComputationNameMap additional =
    TopologyConfig_UserStageToComputationNameMap
      { additional =
          additional
      }
  
  instance Core.FromJSON TopologyConfig_UserStageToComputationNameMap where
    parseJSON =
      Core.withObject
        "TopologyConfig_UserStageToComputationNameMap"
        ( \o ->
            TopologyConfig_UserStageToComputationNameMap
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON TopologyConfig_UserStageToComputationNameMap where
    toJSON TopologyConfig_UserStageToComputationNameMap {..} =
      Core.toJSON additional
  
  -- | Description of the type, names\/ids, and input\/outputs for a transform.
  --
  -- /See:/ 'newTransformSummary' smart constructor.
  data TransformSummary = TransformSummary
    { -- | Transform-specific display data.
      displayData :: (Core.Maybe [DisplayData]),
      -- | SDK generated id of this transform instance.
      id :: (Core.Maybe Core.Text),
      -- | User names for all collection inputs to this transform.
      inputCollectionName :: (Core.Maybe [Core.Text]),
      -- | Type of transform.
      kind :: (Core.Maybe TransformSummary_Kind),
      -- | User provided name for this transform instance.
      name :: (Core.Maybe Core.Text),
      -- | User names for all collection outputs to this transform.
      outputCollectionName :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'TransformSummary' with the minimum fields required to make a request.
  newTransformSummary ::
    TransformSummary
  newTransformSummary =
    TransformSummary
      { displayData = Core.Nothing,
        id = Core.Nothing,
        inputCollectionName = Core.Nothing,
        kind = Core.Nothing,
        name = Core.Nothing,
        outputCollectionName = Core.Nothing
      }
  
  instance Core.FromJSON TransformSummary where
    parseJSON =
      Core.withObject
        "TransformSummary"
        ( \o ->
            TransformSummary
              Core.<$> (o Core..:? "displayData")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "inputCollectionName")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "outputCollectionName")
        )
  
  instance Core.ToJSON TransformSummary where
    toJSON TransformSummary {..} =
      Core.object
        ( Core.catMaybes
            [ ("displayData" Core..=) Core.<$> displayData,
              ("id" Core..=) Core.<$> id,
              ("inputCollectionName" Core..=) Core.<$> inputCollectionName,
              ("kind" Core..=) Core.<$> kind,
              ("name" Core..=) Core.<$> name,
              ("outputCollectionName" Core..=) Core.<$> outputCollectionName
            ]
        )
  
  -- | WorkItem represents basic information about a WorkItem to be executed in the cloud.
  --
  -- /See:/ 'newWorkItem' smart constructor.
  data WorkItem = WorkItem
    { -- | Work item-specific configuration as an opaque blob.
      configuration :: (Core.Maybe Core.Text),
      -- | Identifies this WorkItem.
      id :: (Core.Maybe Core.Int64),
      -- | The initial index to use when reporting the status of the WorkItem.
      initialReportIndex :: (Core.Maybe Core.Int64),
      -- | Identifies the workflow job this WorkItem belongs to.
      jobId :: (Core.Maybe Core.Text),
      -- | Time when the lease on this Work will expire.
      leaseExpireTime :: (Core.Maybe Core.DateTime),
      -- | Additional information for MapTask WorkItems.
      mapTask :: (Core.Maybe MapTask),
      -- | Any required packages that need to be fetched in order to execute this WorkItem.
      packages :: (Core.Maybe [Package]),
      -- | Identifies the cloud project this WorkItem belongs to.
      projectId :: (Core.Maybe Core.Text),
      -- | Recommended reporting interval.
      reportStatusInterval :: (Core.Maybe Core.Duration),
      -- | Additional information for SeqMapTask WorkItems.
      seqMapTask :: (Core.Maybe SeqMapTask),
      -- | Additional information for ShellTask WorkItems.
      shellTask :: (Core.Maybe ShellTask),
      -- | Additional information for source operation WorkItems.
      sourceOperationTask :: (Core.Maybe SourceOperationRequest),
      -- | Additional information for StreamingComputationTask WorkItems.
      streamingComputationTask :: (Core.Maybe StreamingComputationTask),
      -- | Additional information for StreamingConfigTask WorkItems.
      streamingConfigTask :: (Core.Maybe StreamingConfigTask),
      -- | Additional information for StreamingSetupTask WorkItems.
      streamingSetupTask :: (Core.Maybe StreamingSetupTask)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkItem' with the minimum fields required to make a request.
  newWorkItem ::
    WorkItem
  newWorkItem =
    WorkItem
      { configuration = Core.Nothing,
        id = Core.Nothing,
        initialReportIndex = Core.Nothing,
        jobId = Core.Nothing,
        leaseExpireTime = Core.Nothing,
        mapTask = Core.Nothing,
        packages = Core.Nothing,
        projectId = Core.Nothing,
        reportStatusInterval = Core.Nothing,
        seqMapTask = Core.Nothing,
        shellTask = Core.Nothing,
        sourceOperationTask = Core.Nothing,
        streamingComputationTask = Core.Nothing,
        streamingConfigTask = Core.Nothing,
        streamingSetupTask = Core.Nothing
      }
  
  instance Core.FromJSON WorkItem where
    parseJSON =
      Core.withObject
        "WorkItem"
        ( \o ->
            WorkItem
              Core.<$> (o Core..:? "configuration")
              Core.<*> (o Core..:? "id" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> ( o
                           Core..:? "initialReportIndex"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "jobId")
              Core.<*> (o Core..:? "leaseExpireTime")
              Core.<*> (o Core..:? "mapTask")
              Core.<*> (o Core..:? "packages")
              Core.<*> (o Core..:? "projectId")
              Core.<*> (o Core..:? "reportStatusInterval")
              Core.<*> (o Core..:? "seqMapTask")
              Core.<*> (o Core..:? "shellTask")
              Core.<*> (o Core..:? "sourceOperationTask")
              Core.<*> (o Core..:? "streamingComputationTask")
              Core.<*> (o Core..:? "streamingConfigTask")
              Core.<*> (o Core..:? "streamingSetupTask")
        )
  
  instance Core.ToJSON WorkItem where
    toJSON WorkItem {..} =
      Core.object
        ( Core.catMaybes
            [ ("configuration" Core..=) Core.<$> configuration,
              ("id" Core..=) Core.. Core.AsText Core.<$> id,
              ("initialReportIndex" Core..=)
                Core.. Core.AsText
                Core.<$> initialReportIndex,
              ("jobId" Core..=) Core.<$> jobId,
              ("leaseExpireTime" Core..=) Core.<$> leaseExpireTime,
              ("mapTask" Core..=) Core.<$> mapTask,
              ("packages" Core..=) Core.<$> packages,
              ("projectId" Core..=) Core.<$> projectId,
              ("reportStatusInterval" Core..=) Core.<$> reportStatusInterval,
              ("seqMapTask" Core..=) Core.<$> seqMapTask,
              ("shellTask" Core..=) Core.<$> shellTask,
              ("sourceOperationTask" Core..=) Core.<$> sourceOperationTask,
              ("streamingComputationTask" Core..=)
                Core.<$> streamingComputationTask,
              ("streamingConfigTask" Core..=) Core.<$> streamingConfigTask,
              ("streamingSetupTask" Core..=) Core.<$> streamingSetupTask
            ]
        )
  
  -- | Information about an individual work item execution.
  --
  -- /See:/ 'newWorkItemDetails' smart constructor.
  data WorkItemDetails = WorkItemDetails
    { -- | Attempt ID of this work item
      attemptId :: (Core.Maybe Core.Text),
      -- | End time of this work item attempt. If the work item is completed, this is the actual end time of the work item. Otherwise, it is the predicted end time.
      endTime :: (Core.Maybe Core.DateTime),
      -- | Metrics for this work item.
      metrics :: (Core.Maybe [MetricUpdate]),
      -- | Progress of this work item.
      progress :: (Core.Maybe ProgressTimeseries),
      -- | Start time of this work item attempt.
      startTime :: (Core.Maybe Core.DateTime),
      -- | State of this work item.
      state :: (Core.Maybe WorkItemDetails_State),
      -- | Information about straggler detections for this work item.
      stragglerInfo :: (Core.Maybe StragglerInfo),
      -- | Name of this work item.
      taskId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkItemDetails' with the minimum fields required to make a request.
  newWorkItemDetails ::
    WorkItemDetails
  newWorkItemDetails =
    WorkItemDetails
      { attemptId = Core.Nothing,
        endTime = Core.Nothing,
        metrics = Core.Nothing,
        progress = Core.Nothing,
        startTime = Core.Nothing,
        state = Core.Nothing,
        stragglerInfo = Core.Nothing,
        taskId = Core.Nothing
      }
  
  instance Core.FromJSON WorkItemDetails where
    parseJSON =
      Core.withObject
        "WorkItemDetails"
        ( \o ->
            WorkItemDetails
              Core.<$> (o Core..:? "attemptId")
              Core.<*> (o Core..:? "endTime")
              Core.<*> (o Core..:? "metrics")
              Core.<*> (o Core..:? "progress")
              Core.<*> (o Core..:? "startTime")
              Core.<*> (o Core..:? "state")
              Core.<*> (o Core..:? "stragglerInfo")
              Core.<*> (o Core..:? "taskId")
        )
  
  instance Core.ToJSON WorkItemDetails where
    toJSON WorkItemDetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("attemptId" Core..=) Core.<$> attemptId,
              ("endTime" Core..=) Core.<$> endTime,
              ("metrics" Core..=) Core.<$> metrics,
              ("progress" Core..=) Core.<$> progress,
              ("startTime" Core..=) Core.<$> startTime,
              ("state" Core..=) Core.<$> state,
              ("stragglerInfo" Core..=) Core.<$> stragglerInfo,
              ("taskId" Core..=) Core.<$> taskId
            ]
        )
  
  -- | The Dataflow service\'s idea of the current state of a WorkItem being processed by a worker.
  --
  -- /See:/ 'newWorkItemServiceState' smart constructor.
  data WorkItemServiceState = WorkItemServiceState
    { -- | If set, a request to complete the work item with the given status. This will not be set to OK, unless supported by the specific kind of WorkItem. It can be used for the backend to indicate a WorkItem must terminate, e.g., for aborting work.
      completeWorkStatus :: (Core.Maybe Status),
      -- | Other data returned by the service, specific to the particular worker harness.
      harnessData :: (Core.Maybe WorkItemServiceState_HarnessData),
      -- | A hot key is a symptom of poor data distribution in which there are enough elements mapped to a single key to impact pipeline performance. When present, this field includes metadata associated with any hot key.
      hotKeyDetection :: (Core.Maybe HotKeyDetection),
      -- | Time at which the current lease will expire.
      leaseExpireTime :: (Core.Maybe Core.DateTime),
      -- | The short ids that workers should use in subsequent metric updates. Workers should strive to use short ids whenever possible, but it is ok to request the short_id again if a worker lost track of it (e.g. if the worker is recovering from a crash). NOTE: it is possible that the response may have short ids for a subset of the metrics.
      metricShortId :: (Core.Maybe [MetricShortId]),
      -- | The index value to use for the next report sent by the worker. Note: If the report call fails for whatever reason, the worker should reuse this index for subsequent report attempts.
      nextReportIndex :: (Core.Maybe Core.Int64),
      -- | New recommended reporting interval.
      reportStatusInterval :: (Core.Maybe Core.Duration),
      -- | The progress point in the WorkItem where the Dataflow service suggests that the worker truncate the task.
      splitRequest :: (Core.Maybe ApproximateSplitRequest),
      -- | DEPRECATED in favor of split_request.
      suggestedStopPoint :: (Core.Maybe ApproximateProgress),
      -- | Obsolete, always empty.
      suggestedStopPosition :: (Core.Maybe Position)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkItemServiceState' with the minimum fields required to make a request.
  newWorkItemServiceState ::
    WorkItemServiceState
  newWorkItemServiceState =
    WorkItemServiceState
      { completeWorkStatus = Core.Nothing,
        harnessData = Core.Nothing,
        hotKeyDetection = Core.Nothing,
        leaseExpireTime = Core.Nothing,
        metricShortId = Core.Nothing,
        nextReportIndex = Core.Nothing,
        reportStatusInterval = Core.Nothing,
        splitRequest = Core.Nothing,
        suggestedStopPoint = Core.Nothing,
        suggestedStopPosition = Core.Nothing
      }
  
  instance Core.FromJSON WorkItemServiceState where
    parseJSON =
      Core.withObject
        "WorkItemServiceState"
        ( \o ->
            WorkItemServiceState
              Core.<$> (o Core..:? "completeWorkStatus")
              Core.<*> (o Core..:? "harnessData")
              Core.<*> (o Core..:? "hotKeyDetection")
              Core.<*> (o Core..:? "leaseExpireTime")
              Core.<*> (o Core..:? "metricShortId")
              Core.<*> (o Core..:? "nextReportIndex" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "reportStatusInterval")
              Core.<*> (o Core..:? "splitRequest")
              Core.<*> (o Core..:? "suggestedStopPoint")
              Core.<*> (o Core..:? "suggestedStopPosition")
        )
  
  instance Core.ToJSON WorkItemServiceState where
    toJSON WorkItemServiceState {..} =
      Core.object
        ( Core.catMaybes
            [ ("completeWorkStatus" Core..=) Core.<$> completeWorkStatus,
              ("harnessData" Core..=) Core.<$> harnessData,
              ("hotKeyDetection" Core..=) Core.<$> hotKeyDetection,
              ("leaseExpireTime" Core..=) Core.<$> leaseExpireTime,
              ("metricShortId" Core..=) Core.<$> metricShortId,
              ("nextReportIndex" Core..=)
                Core.. Core.AsText
                Core.<$> nextReportIndex,
              ("reportStatusInterval" Core..=) Core.<$> reportStatusInterval,
              ("splitRequest" Core..=) Core.<$> splitRequest,
              ("suggestedStopPoint" Core..=) Core.<$> suggestedStopPoint,
              ("suggestedStopPosition" Core..=) Core.<$> suggestedStopPosition
            ]
        )
  
  -- | Other data returned by the service, specific to the particular worker harness.
  --
  -- /See:/ 'newWorkItemServiceState_HarnessData' smart constructor.
  newtype WorkItemServiceState_HarnessData = WorkItemServiceState_HarnessData
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkItemServiceState_HarnessData' with the minimum fields required to make a request.
  newWorkItemServiceState_HarnessData ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    WorkItemServiceState_HarnessData
  newWorkItemServiceState_HarnessData additional =
    WorkItemServiceState_HarnessData {additional = additional}
  
  instance Core.FromJSON WorkItemServiceState_HarnessData where
    parseJSON =
      Core.withObject
        "WorkItemServiceState_HarnessData"
        ( \o ->
            WorkItemServiceState_HarnessData Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON WorkItemServiceState_HarnessData where
    toJSON WorkItemServiceState_HarnessData {..} =
      Core.toJSON additional
  
  -- | Conveys a worker\'s progress through the work described by a WorkItem.
  --
  -- /See:/ 'newWorkItemStatus' smart constructor.
  data WorkItemStatus = WorkItemStatus
    { -- | True if the WorkItem was completed (successfully or unsuccessfully).
      completed :: (Core.Maybe Core.Bool),
      -- | Worker output counters for this WorkItem.
      counterUpdates :: (Core.Maybe [CounterUpdate]),
      -- | See documentation of stop_position.
      dynamicSourceSplit :: (Core.Maybe DynamicSourceSplit),
      -- | Specifies errors which occurred during processing. If errors are provided, and completed = true, then the WorkItem is considered to have failed.
      errors :: (Core.Maybe [Status]),
      -- | DEPRECATED in favor of counter_updates.
      metricUpdates :: (Core.Maybe [MetricUpdate]),
      -- | DEPRECATED in favor of reported_progress.
      progress :: (Core.Maybe ApproximateProgress),
      -- | The report index. When a WorkItem is leased, the lease will contain an initial report index. When a WorkItem\'s status is reported to the system, the report should be sent with that report index, and the response will contain the index the worker should use for the next report. Reports received with unexpected index values will be rejected by the service. In order to preserve idempotency, the worker should not alter the contents of a report, even if the worker must submit the same report multiple times before getting back a response. The worker should not submit a subsequent report until the response for the previous report had been received from the service.
      reportIndex :: (Core.Maybe Core.Int64),
      -- | The worker\'s progress through this WorkItem.
      reportedProgress :: (Core.Maybe ApproximateReportedProgress),
      -- | Amount of time the worker requests for its lease.
      requestedLeaseDuration :: (Core.Maybe Core.Duration),
      -- | DEPRECATED in favor of dynamic/source/split.
      sourceFork :: (Core.Maybe SourceFork),
      -- | If the work item represented a SourceOperationRequest, and the work is completed, contains the result of the operation.
      sourceOperationResponse :: (Core.Maybe SourceOperationResponse),
      -- | A worker may split an active map task in two parts, \"primary\" and \"residual\", continuing to process the primary part and returning the residual part into the pool of available work. This event is called a \"dynamic split\" and is critical to the dynamic work rebalancing feature. The two obtained sub-tasks are called \"parts\" of the split. The parts, if concatenated, must represent the same input as would be read by the current task if the split did not happen. The exact way in which the original task is decomposed into the two parts is specified either as a position demarcating them (stop/position), or explicitly as two DerivedSources, if this task consumes a user-defined source type (dynamic/source/split). The \"current\" task is adjusted as a result of the split: after a task with range [A, B) sends a stop/position update at C, its range is considered to be [A, C), e.g.: * Progress should be interpreted relative to the new range, e.g. \"75% completed\" means \"75% of [A, C) completed\" * The worker
      -- should interpret proposed/stop/position relative to the new range, e.g. \"split at 68%\" should be interpreted as \"split at 68% of [A, C)\". * If the worker chooses to split again using stop/position, only stop/positions in [A, C) will be accepted. * Etc. dynamic/source/split has similar semantics: e.g., if a task with source S splits using dynamic/source/split into {P, R} (where P and R must be together equivalent to S), then subsequent progress and proposed/stop/position should be interpreted relative to P, and in a potential subsequent dynamic/source/split into {P\', R\'}, P\' and R\' must be together equivalent to P, etc.
      stopPosition :: (Core.Maybe Position),
      -- | Total time the worker spent being throttled by external systems.
      totalThrottlerWaitTimeSeconds :: (Core.Maybe Core.Double),
      -- | Identifies the WorkItem.
      workItemId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkItemStatus' with the minimum fields required to make a request.
  newWorkItemStatus ::
    WorkItemStatus
  newWorkItemStatus =
    WorkItemStatus
      { completed = Core.Nothing,
        counterUpdates = Core.Nothing,
        dynamicSourceSplit = Core.Nothing,
        errors = Core.Nothing,
        metricUpdates = Core.Nothing,
        progress = Core.Nothing,
        reportIndex = Core.Nothing,
        reportedProgress = Core.Nothing,
        requestedLeaseDuration = Core.Nothing,
        sourceFork = Core.Nothing,
        sourceOperationResponse = Core.Nothing,
        stopPosition = Core.Nothing,
        totalThrottlerWaitTimeSeconds = Core.Nothing,
        workItemId = Core.Nothing
      }
  
  instance Core.FromJSON WorkItemStatus where
    parseJSON =
      Core.withObject
        "WorkItemStatus"
        ( \o ->
            WorkItemStatus
              Core.<$> (o Core..:? "completed")
              Core.<*> (o Core..:? "counterUpdates")
              Core.<*> (o Core..:? "dynamicSourceSplit")
              Core.<*> (o Core..:? "errors")
              Core.<*> (o Core..:? "metricUpdates")
              Core.<*> (o Core..:? "progress")
              Core.<*> (o Core..:? "reportIndex" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "reportedProgress")
              Core.<*> (o Core..:? "requestedLeaseDuration")
              Core.<*> (o Core..:? "sourceFork")
              Core.<*> (o Core..:? "sourceOperationResponse")
              Core.<*> (o Core..:? "stopPosition")
              Core.<*> (o Core..:? "totalThrottlerWaitTimeSeconds")
              Core.<*> (o Core..:? "workItemId")
        )
  
  instance Core.ToJSON WorkItemStatus where
    toJSON WorkItemStatus {..} =
      Core.object
        ( Core.catMaybes
            [ ("completed" Core..=) Core.<$> completed,
              ("counterUpdates" Core..=) Core.<$> counterUpdates,
              ("dynamicSourceSplit" Core..=) Core.<$> dynamicSourceSplit,
              ("errors" Core..=) Core.<$> errors,
              ("metricUpdates" Core..=) Core.<$> metricUpdates,
              ("progress" Core..=) Core.<$> progress,
              ("reportIndex" Core..=) Core.. Core.AsText Core.<$> reportIndex,
              ("reportedProgress" Core..=) Core.<$> reportedProgress,
              ("requestedLeaseDuration" Core..=) Core.<$> requestedLeaseDuration,
              ("sourceFork" Core..=) Core.<$> sourceFork,
              ("sourceOperationResponse" Core..=)
                Core.<$> sourceOperationResponse,
              ("stopPosition" Core..=) Core.<$> stopPosition,
              ("totalThrottlerWaitTimeSeconds" Core..=)
                Core.<$> totalThrottlerWaitTimeSeconds,
              ("workItemId" Core..=) Core.<$> workItemId
            ]
        )
  
  -- | Information about a worker
  --
  -- /See:/ 'newWorkerDetails' smart constructor.
  data WorkerDetails = WorkerDetails
    { -- | Work items processed by this worker, sorted by time.
      workItems :: (Core.Maybe [WorkItemDetails]),
      -- | Name of this worker
      workerName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerDetails' with the minimum fields required to make a request.
  newWorkerDetails ::
    WorkerDetails
  newWorkerDetails =
    WorkerDetails
      { workItems = Core.Nothing,
        workerName = Core.Nothing
      }
  
  instance Core.FromJSON WorkerDetails where
    parseJSON =
      Core.withObject
        "WorkerDetails"
        ( \o ->
            WorkerDetails
              Core.<$> (o Core..:? "workItems")
              Core.<*> (o Core..:? "workerName")
        )
  
  instance Core.ToJSON WorkerDetails where
    toJSON WorkerDetails {..} =
      Core.object
        ( Core.catMaybes
            [ ("workItems" Core..=) Core.<$> workItems,
              ("workerName" Core..=) Core.<$> workerName
            ]
        )
  
  -- | WorkerHealthReport contains information about the health of a worker. The VM should be identified by the labels attached to the WorkerMessage that this health ping belongs to.
  --
  -- /See:/ 'newWorkerHealthReport' smart constructor.
  data WorkerHealthReport = WorkerHealthReport
    { -- | Message describing any unusual health reports.
      msg :: (Core.Maybe Core.Text),
      -- | The pods running on the worker. See: http:\/\/kubernetes.io\/v1.1\/docs\/api-reference\/v1\/definitions.html#/v1/pod This field is used by the worker to send the status of the indvidual containers running on each worker.
      pods :: (Core.Maybe [WorkerHealthReport_PodsItem]),
      -- | The interval at which the worker is sending health reports. The default value of 0 should be interpreted as the field is not being explicitly set by the worker.
      reportInterval :: (Core.Maybe Core.Duration),
      -- | Code to describe a specific reason, if known, that a VM has reported broken state.
      vmBrokenCode :: (Core.Maybe Core.Text),
      -- | Whether the VM is in a permanently broken state. Broken VMs should be abandoned or deleted ASAP to avoid assigning or completing any work.
      vmIsBroken :: (Core.Maybe Core.Bool),
      -- | Whether the VM is currently healthy.
      vmIsHealthy :: (Core.Maybe Core.Bool),
      -- | The time the VM was booted.
      vmStartupTime :: (Core.Maybe Core.DateTime)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerHealthReport' with the minimum fields required to make a request.
  newWorkerHealthReport ::
    WorkerHealthReport
  newWorkerHealthReport =
    WorkerHealthReport
      { msg = Core.Nothing,
        pods = Core.Nothing,
        reportInterval = Core.Nothing,
        vmBrokenCode = Core.Nothing,
        vmIsBroken = Core.Nothing,
        vmIsHealthy = Core.Nothing,
        vmStartupTime = Core.Nothing
      }
  
  instance Core.FromJSON WorkerHealthReport where
    parseJSON =
      Core.withObject
        "WorkerHealthReport"
        ( \o ->
            WorkerHealthReport
              Core.<$> (o Core..:? "msg")
              Core.<*> (o Core..:? "pods")
              Core.<*> (o Core..:? "reportInterval")
              Core.<*> (o Core..:? "vmBrokenCode")
              Core.<*> (o Core..:? "vmIsBroken")
              Core.<*> (o Core..:? "vmIsHealthy")
              Core.<*> (o Core..:? "vmStartupTime")
        )
  
  instance Core.ToJSON WorkerHealthReport where
    toJSON WorkerHealthReport {..} =
      Core.object
        ( Core.catMaybes
            [ ("msg" Core..=) Core.<$> msg,
              ("pods" Core..=) Core.<$> pods,
              ("reportInterval" Core..=) Core.<$> reportInterval,
              ("vmBrokenCode" Core..=) Core.<$> vmBrokenCode,
              ("vmIsBroken" Core..=) Core.<$> vmIsBroken,
              ("vmIsHealthy" Core..=) Core.<$> vmIsHealthy,
              ("vmStartupTime" Core..=) Core.<$> vmStartupTime
            ]
        )
  
  --
  -- /See:/ 'newWorkerHealthReport_PodsItem' smart constructor.
  newtype WorkerHealthReport_PodsItem = WorkerHealthReport_PodsItem
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerHealthReport_PodsItem' with the minimum fields required to make a request.
  newWorkerHealthReport_PodsItem ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    WorkerHealthReport_PodsItem
  newWorkerHealthReport_PodsItem additional =
    WorkerHealthReport_PodsItem {additional = additional}
  
  instance Core.FromJSON WorkerHealthReport_PodsItem where
    parseJSON =
      Core.withObject
        "WorkerHealthReport_PodsItem"
        ( \o ->
            WorkerHealthReport_PodsItem Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON WorkerHealthReport_PodsItem where
    toJSON WorkerHealthReport_PodsItem {..} = Core.toJSON additional
  
  -- | WorkerHealthReportResponse contains information returned to the worker in response to a health ping.
  --
  -- /See:/ 'newWorkerHealthReportResponse' smart constructor.
  newtype WorkerHealthReportResponse = WorkerHealthReportResponse
    { -- | A positive value indicates the worker should change its reporting interval to the specified value. The default value of zero means no change in report rate is requested by the server.
      reportInterval :: (Core.Maybe Core.Duration)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerHealthReportResponse' with the minimum fields required to make a request.
  newWorkerHealthReportResponse ::
    WorkerHealthReportResponse
  newWorkerHealthReportResponse =
    WorkerHealthReportResponse {reportInterval = Core.Nothing}
  
  instance Core.FromJSON WorkerHealthReportResponse where
    parseJSON =
      Core.withObject
        "WorkerHealthReportResponse"
        ( \o ->
            WorkerHealthReportResponse Core.<$> (o Core..:? "reportInterval")
        )
  
  instance Core.ToJSON WorkerHealthReportResponse where
    toJSON WorkerHealthReportResponse {..} =
      Core.object
        ( Core.catMaybes
            [("reportInterval" Core..=) Core.<$> reportInterval]
        )
  
  -- | A report of an event in a worker\'s lifecycle. The proto contains one event, because the worker is expected to asynchronously send each message immediately after the event. Due to this asynchrony, messages may arrive out of order (or missing), and it is up to the consumer to interpret. The timestamp of the event is in the enclosing WorkerMessage proto.
  --
  -- /See:/ 'newWorkerLifecycleEvent' smart constructor.
  data WorkerLifecycleEvent = WorkerLifecycleEvent
    { -- | The start time of this container. All events will report this so that events can be grouped together across container\/VM restarts.
      containerStartTime :: (Core.Maybe Core.DateTime),
      -- | The event being reported.
      event :: (Core.Maybe WorkerLifecycleEvent_Event),
      -- | Other stats that can accompany an event. E.g. { \"downloaded_bytes\" : \"123456\" }
      metadata :: (Core.Maybe WorkerLifecycleEvent_Metadata)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerLifecycleEvent' with the minimum fields required to make a request.
  newWorkerLifecycleEvent ::
    WorkerLifecycleEvent
  newWorkerLifecycleEvent =
    WorkerLifecycleEvent
      { containerStartTime = Core.Nothing,
        event = Core.Nothing,
        metadata = Core.Nothing
      }
  
  instance Core.FromJSON WorkerLifecycleEvent where
    parseJSON =
      Core.withObject
        "WorkerLifecycleEvent"
        ( \o ->
            WorkerLifecycleEvent
              Core.<$> (o Core..:? "containerStartTime")
              Core.<*> (o Core..:? "event")
              Core.<*> (o Core..:? "metadata")
        )
  
  instance Core.ToJSON WorkerLifecycleEvent where
    toJSON WorkerLifecycleEvent {..} =
      Core.object
        ( Core.catMaybes
            [ ("containerStartTime" Core..=) Core.<$> containerStartTime,
              ("event" Core..=) Core.<$> event,
              ("metadata" Core..=) Core.<$> metadata
            ]
        )
  
  -- | Other stats that can accompany an event. E.g. { \"downloaded_bytes\" : \"123456\" }
  --
  -- /See:/ 'newWorkerLifecycleEvent_Metadata' smart constructor.
  newtype WorkerLifecycleEvent_Metadata = WorkerLifecycleEvent_Metadata
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerLifecycleEvent_Metadata' with the minimum fields required to make a request.
  newWorkerLifecycleEvent_Metadata ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    WorkerLifecycleEvent_Metadata
  newWorkerLifecycleEvent_Metadata additional =
    WorkerLifecycleEvent_Metadata {additional = additional}
  
  instance Core.FromJSON WorkerLifecycleEvent_Metadata where
    parseJSON =
      Core.withObject
        "WorkerLifecycleEvent_Metadata"
        ( \o ->
            WorkerLifecycleEvent_Metadata Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON WorkerLifecycleEvent_Metadata where
    toJSON WorkerLifecycleEvent_Metadata {..} = Core.toJSON additional
  
  -- | WorkerMessage provides information to the backend about a worker.
  --
  -- /See:/ 'newWorkerMessage' smart constructor.
  data WorkerMessage = WorkerMessage
    { -- | Optional. Contains metrics related to go\/dataflow-data-sampling-telemetry.
      dataSamplingReport :: (Core.Maybe DataSamplingReport),
      -- | Labels are used to group WorkerMessages. For example, a worker/message about a particular container might have the labels: { \"JOB/ID\": \"2015-04-22\", \"WORKER/ID\": \"wordcount-vm-2015…\" \"CONTAINER/TYPE\": \"worker\", \"CONTAINER/ID\": \"ac1234def\"} Label tags typically correspond to Label enum values. However, for ease of development other strings can be used as tags. LABEL/UNSPECIFIED should not be used here.
      labels :: (Core.Maybe WorkerMessage_Labels),
      -- | System defined metrics for this worker.
      perWorkerMetrics :: (Core.Maybe PerWorkerMetrics),
      -- | Contains per-user worker telemetry used in streaming autoscaling.
      streamingScalingReport :: (Core.Maybe StreamingScalingReport),
      -- | The timestamp of the worker_message.
      time :: (Core.Maybe Core.DateTime),
      -- | The health of a worker.
      workerHealthReport :: (Core.Maybe WorkerHealthReport),
      -- | Record of worker lifecycle events.
      workerLifecycleEvent :: (Core.Maybe WorkerLifecycleEvent),
      -- | A worker message code.
      workerMessageCode :: (Core.Maybe WorkerMessageCode),
      -- | Resource metrics reported by workers.
      workerMetrics :: (Core.Maybe ResourceUtilizationReport),
      -- | Shutdown notice by workers.
      workerShutdownNotice :: (Core.Maybe WorkerShutdownNotice),
      -- | Thread scaling information reported by workers.
      workerThreadScalingReport :: (Core.Maybe WorkerThreadScalingReport)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerMessage' with the minimum fields required to make a request.
  newWorkerMessage ::
    WorkerMessage
  newWorkerMessage =
    WorkerMessage
      { dataSamplingReport = Core.Nothing,
        labels = Core.Nothing,
        perWorkerMetrics = Core.Nothing,
        streamingScalingReport = Core.Nothing,
        time = Core.Nothing,
        workerHealthReport = Core.Nothing,
        workerLifecycleEvent = Core.Nothing,
        workerMessageCode = Core.Nothing,
        workerMetrics = Core.Nothing,
        workerShutdownNotice = Core.Nothing,
        workerThreadScalingReport = Core.Nothing
      }
  
  instance Core.FromJSON WorkerMessage where
    parseJSON =
      Core.withObject
        "WorkerMessage"
        ( \o ->
            WorkerMessage
              Core.<$> (o Core..:? "dataSamplingReport")
              Core.<*> (o Core..:? "labels")
              Core.<*> (o Core..:? "perWorkerMetrics")
              Core.<*> (o Core..:? "streamingScalingReport")
              Core.<*> (o Core..:? "time")
              Core.<*> (o Core..:? "workerHealthReport")
              Core.<*> (o Core..:? "workerLifecycleEvent")
              Core.<*> (o Core..:? "workerMessageCode")
              Core.<*> (o Core..:? "workerMetrics")
              Core.<*> (o Core..:? "workerShutdownNotice")
              Core.<*> (o Core..:? "workerThreadScalingReport")
        )
  
  instance Core.ToJSON WorkerMessage where
    toJSON WorkerMessage {..} =
      Core.object
        ( Core.catMaybes
            [ ("dataSamplingReport" Core..=) Core.<$> dataSamplingReport,
              ("labels" Core..=) Core.<$> labels,
              ("perWorkerMetrics" Core..=) Core.<$> perWorkerMetrics,
              ("streamingScalingReport" Core..=) Core.<$> streamingScalingReport,
              ("time" Core..=) Core.<$> time,
              ("workerHealthReport" Core..=) Core.<$> workerHealthReport,
              ("workerLifecycleEvent" Core..=) Core.<$> workerLifecycleEvent,
              ("workerMessageCode" Core..=) Core.<$> workerMessageCode,
              ("workerMetrics" Core..=) Core.<$> workerMetrics,
              ("workerShutdownNotice" Core..=) Core.<$> workerShutdownNotice,
              ("workerThreadScalingReport" Core..=)
                Core.<$> workerThreadScalingReport
            ]
        )
  
  -- | Labels are used to group WorkerMessages. For example, a worker/message about a particular container might have the labels: { \"JOB/ID\": \"2015-04-22\", \"WORKER/ID\": \"wordcount-vm-2015…\" \"CONTAINER/TYPE\": \"worker\", \"CONTAINER/ID\": \"ac1234def\"} Label tags typically correspond to Label enum values. However, for ease of development other strings can be used as tags. LABEL/UNSPECIFIED should not be used here.
  --
  -- /See:/ 'newWorkerMessage_Labels' smart constructor.
  newtype WorkerMessage_Labels = WorkerMessage_Labels
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerMessage_Labels' with the minimum fields required to make a request.
  newWorkerMessage_Labels ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    WorkerMessage_Labels
  newWorkerMessage_Labels additional =
    WorkerMessage_Labels {additional = additional}
  
  instance Core.FromJSON WorkerMessage_Labels where
    parseJSON =
      Core.withObject
        "WorkerMessage_Labels"
        (\o -> WorkerMessage_Labels Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON WorkerMessage_Labels where
    toJSON WorkerMessage_Labels {..} = Core.toJSON additional
  
  -- | A message code is used to report status and error messages to the service. The message codes are intended to be machine readable. The service will take care of translating these into user understandable messages if necessary. Example use cases: 1. Worker processes reporting successful startup. 2. Worker processes reporting specific errors (e.g. package staging failure).
  --
  -- /See:/ 'newWorkerMessageCode' smart constructor.
  data WorkerMessageCode = WorkerMessageCode
    { -- | The code is a string intended for consumption by a machine that identifies the type of message being sent. Examples: 1. \"HARNESS/STARTED\" might be used to indicate the worker harness has started. 2. \"GCS/DOWNLOAD_ERROR\" might be used to indicate an error downloading a Cloud Storage file as part of the boot process of one of the worker containers. This is a string and not an enum to make it easy to add new codes without waiting for an API change.
      code :: (Core.Maybe Core.Text),
      -- | Parameters contains specific information about the code. This is a struct to allow parameters of different types. Examples: 1. For a \"HARNESS/STARTED\" message parameters might provide the name of the worker and additional data like timing information. 2. For a \"GCS/DOWNLOAD_ERROR\" parameters might contain fields listing the Cloud Storage objects being downloaded and fields containing errors. In general complex data structures should be avoided. If a worker needs to send a specific and complicated data structure then please consider defining a new proto and adding it to the data oneof in WorkerMessageResponse. Conventions: Parameters should only be used for information that isn\'t typically passed as a label. hostname and other worker identifiers should almost always be passed as labels since they will be included on most messages.
      parameters :: (Core.Maybe WorkerMessageCode_Parameters)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerMessageCode' with the minimum fields required to make a request.
  newWorkerMessageCode ::
    WorkerMessageCode
  newWorkerMessageCode =
    WorkerMessageCode {code = Core.Nothing, parameters = Core.Nothing}
  
  instance Core.FromJSON WorkerMessageCode where
    parseJSON =
      Core.withObject
        "WorkerMessageCode"
        ( \o ->
            WorkerMessageCode
              Core.<$> (o Core..:? "code")
              Core.<*> (o Core..:? "parameters")
        )
  
  instance Core.ToJSON WorkerMessageCode where
    toJSON WorkerMessageCode {..} =
      Core.object
        ( Core.catMaybes
            [ ("code" Core..=) Core.<$> code,
              ("parameters" Core..=) Core.<$> parameters
            ]
        )
  
  -- | Parameters contains specific information about the code. This is a struct to allow parameters of different types. Examples: 1. For a \"HARNESS/STARTED\" message parameters might provide the name of the worker and additional data like timing information. 2. For a \"GCS/DOWNLOAD_ERROR\" parameters might contain fields listing the Cloud Storage objects being downloaded and fields containing errors. In general complex data structures should be avoided. If a worker needs to send a specific and complicated data structure then please consider defining a new proto and adding it to the data oneof in WorkerMessageResponse. Conventions: Parameters should only be used for information that isn\'t typically passed as a label. hostname and other worker identifiers should almost always be passed as labels since they will be included on most messages.
  --
  -- /See:/ 'newWorkerMessageCode_Parameters' smart constructor.
  newtype WorkerMessageCode_Parameters = WorkerMessageCode_Parameters
    { -- | Properties of the object.
      additional :: (Core.HashMap Core.Text Core.Value)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerMessageCode_Parameters' with the minimum fields required to make a request.
  newWorkerMessageCode_Parameters ::
    -- |  Properties of the object. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    WorkerMessageCode_Parameters
  newWorkerMessageCode_Parameters additional =
    WorkerMessageCode_Parameters {additional = additional}
  
  instance Core.FromJSON WorkerMessageCode_Parameters where
    parseJSON =
      Core.withObject
        "WorkerMessageCode_Parameters"
        ( \o ->
            WorkerMessageCode_Parameters Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON WorkerMessageCode_Parameters where
    toJSON WorkerMessageCode_Parameters {..} = Core.toJSON additional
  
  -- | A worker_message response allows the server to pass information to the sender.
  --
  -- /See:/ 'newWorkerMessageResponse' smart constructor.
  data WorkerMessageResponse = WorkerMessageResponse
    { -- | Service\'s streaming scaling response for workers.
      streamingScalingReportResponse :: (Core.Maybe StreamingScalingReportResponse),
      -- | The service\'s response to a worker\'s health report.
      workerHealthReportResponse :: (Core.Maybe WorkerHealthReportResponse),
      -- | Service\'s response to reporting worker metrics (currently empty).
      workerMetricsResponse :: (Core.Maybe ResourceUtilizationReportResponse),
      -- | Service\'s response to shutdown notice (currently empty).
      workerShutdownNoticeResponse :: (Core.Maybe WorkerShutdownNoticeResponse),
      -- | Service\'s thread scaling recommendation for workers.
      workerThreadScalingReportResponse :: (Core.Maybe WorkerThreadScalingReportResponse)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerMessageResponse' with the minimum fields required to make a request.
  newWorkerMessageResponse ::
    WorkerMessageResponse
  newWorkerMessageResponse =
    WorkerMessageResponse
      { streamingScalingReportResponse =
          Core.Nothing,
        workerHealthReportResponse = Core.Nothing,
        workerMetricsResponse = Core.Nothing,
        workerShutdownNoticeResponse = Core.Nothing,
        workerThreadScalingReportResponse = Core.Nothing
      }
  
  instance Core.FromJSON WorkerMessageResponse where
    parseJSON =
      Core.withObject
        "WorkerMessageResponse"
        ( \o ->
            WorkerMessageResponse
              Core.<$> (o Core..:? "streamingScalingReportResponse")
              Core.<*> (o Core..:? "workerHealthReportResponse")
              Core.<*> (o Core..:? "workerMetricsResponse")
              Core.<*> (o Core..:? "workerShutdownNoticeResponse")
              Core.<*> (o Core..:? "workerThreadScalingReportResponse")
        )
  
  instance Core.ToJSON WorkerMessageResponse where
    toJSON WorkerMessageResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("streamingScalingReportResponse" Core..=)
                Core.<$> streamingScalingReportResponse,
              ("workerHealthReportResponse" Core..=)
                Core.<$> workerHealthReportResponse,
              ("workerMetricsResponse" Core..=) Core.<$> workerMetricsResponse,
              ("workerShutdownNoticeResponse" Core..=)
                Core.<$> workerShutdownNoticeResponse,
              ("workerThreadScalingReportResponse" Core..=)
                Core.<$> workerThreadScalingReportResponse
            ]
        )
  
  -- | Describes one particular pool of Cloud Dataflow workers to be instantiated by the Cloud Dataflow service in order to perform the computations required by a job. Note that a workflow job may use multiple pools, in order to match the various computational requirements of the various stages of the job.
  --
  -- /See:/ 'newWorkerPool' smart constructor.
  data WorkerPool = WorkerPool
    { -- | Settings for autoscaling of this WorkerPool.
      autoscalingSettings :: (Core.Maybe AutoscalingSettings),
      -- | Data disks that are used by a VM in this workflow.
      dataDisks :: (Core.Maybe [Disk]),
      -- | The default package set to install. This allows the service to select a default set of packages which are useful to worker harnesses written in a particular language.
      defaultPackageSet :: (Core.Maybe WorkerPool_DefaultPackageSet),
      -- | Size of root disk for VMs, in GB. If zero or unspecified, the service will attempt to choose a reasonable default.
      diskSizeGb :: (Core.Maybe Core.Int32),
      -- | Fully qualified source image for disks.
      diskSourceImage :: (Core.Maybe Core.Text),
      -- | Type of root disk for VMs. If empty or unspecified, the service will attempt to choose a reasonable default.
      diskType :: (Core.Maybe Core.Text),
      -- | Configuration for VM IPs.
      ipConfiguration :: (Core.Maybe WorkerPool_IpConfiguration),
      -- | The kind of the worker pool; currently only @harness@ and @shuffle@ are supported.
      kind :: (Core.Maybe Core.Text),
      -- | Machine type (e.g. \"n1-standard-1\"). If empty or unspecified, the service will attempt to choose a reasonable default.
      machineType :: (Core.Maybe Core.Text),
      -- | Metadata to set on the Google Compute Engine VMs.
      metadata :: (Core.Maybe WorkerPool_Metadata),
      -- | Network to which VMs will be assigned. If empty or unspecified, the service will use the network \"default\".
      network :: (Core.Maybe Core.Text),
      -- | The number of threads per worker harness. If empty or unspecified, the service will choose a number of threads (according to the number of cores on the selected machine type for batch, or 1 by convention for streaming).
      numThreadsPerWorker :: (Core.Maybe Core.Int32),
      -- | Number of Google Compute Engine workers in this pool needed to execute the job. If zero or unspecified, the service will attempt to choose a reasonable default.
      numWorkers :: (Core.Maybe Core.Int32),
      -- | The action to take on host maintenance, as defined by the Google Compute Engine API.
      onHostMaintenance :: (Core.Maybe Core.Text),
      -- | Packages to be installed on workers.
      packages :: (Core.Maybe [Package]),
      -- | Extra arguments for this worker pool.
      poolArgs :: (Core.Maybe WorkerPool_PoolArgs),
      -- | Set of SDK harness containers needed to execute this pipeline. This will only be set in the Fn API path. For non-cross-language pipelines this should have only one entry. Cross-language pipelines will have two or more entries.
      sdkHarnessContainerImages :: (Core.Maybe [SdkHarnessContainerImage]),
      -- | Subnetwork to which VMs will be assigned, if desired. Expected to be of the form \"regions\/REGION\/subnetworks\/SUBNETWORK\".
      subnetwork :: (Core.Maybe Core.Text),
      -- | Settings passed through to Google Compute Engine workers when using the standard Dataflow task runner. Users should ignore this field.
      taskrunnerSettings :: (Core.Maybe TaskRunnerSettings),
      -- | Sets the policy for determining when to turndown worker pool. Allowed values are: @TEARDOWN_ALWAYS@, @TEARDOWN_ON_SUCCESS@, and @TEARDOWN_NEVER@. @TEARDOWN_ALWAYS@ means workers are always torn down regardless of whether the job succeeds. @TEARDOWN_ON_SUCCESS@ means workers are torn down if the job succeeds. @TEARDOWN_NEVER@ means the workers are never torn down. If the workers are not torn down by the service, they will continue to run and use Google Compute Engine VM resources in the user\'s project until they are explicitly terminated by the user. Because of this, Google recommends using the @TEARDOWN_ALWAYS@ policy except for small, manually supervised test jobs. If unknown or unspecified, the service will attempt to choose a reasonable default.
      teardownPolicy :: (Core.Maybe WorkerPool_TeardownPolicy),
      -- | Required. Docker container image that executes the Cloud Dataflow worker harness, residing in Google Container Registry. Deprecated for the Fn API path. Use sdk/harness/container_images instead.
      workerHarnessContainerImage :: (Core.Maybe Core.Text),
      -- | Zone to run the worker pools in. If empty or unspecified, the service will attempt to choose a reasonable default.
      zone :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerPool' with the minimum fields required to make a request.
  newWorkerPool ::
    WorkerPool
  newWorkerPool =
    WorkerPool
      { autoscalingSettings = Core.Nothing,
        dataDisks = Core.Nothing,
        defaultPackageSet = Core.Nothing,
        diskSizeGb = Core.Nothing,
        diskSourceImage = Core.Nothing,
        diskType = Core.Nothing,
        ipConfiguration = Core.Nothing,
        kind = Core.Nothing,
        machineType = Core.Nothing,
        metadata = Core.Nothing,
        network = Core.Nothing,
        numThreadsPerWorker = Core.Nothing,
        numWorkers = Core.Nothing,
        onHostMaintenance = Core.Nothing,
        packages = Core.Nothing,
        poolArgs = Core.Nothing,
        sdkHarnessContainerImages = Core.Nothing,
        subnetwork = Core.Nothing,
        taskrunnerSettings = Core.Nothing,
        teardownPolicy = Core.Nothing,
        workerHarnessContainerImage = Core.Nothing,
        zone = Core.Nothing
      }
  
  instance Core.FromJSON WorkerPool where
    parseJSON =
      Core.withObject
        "WorkerPool"
        ( \o ->
            WorkerPool
              Core.<$> (o Core..:? "autoscalingSettings")
              Core.<*> (o Core..:? "dataDisks")
              Core.<*> (o Core..:? "defaultPackageSet")
              Core.<*> (o Core..:? "diskSizeGb")
              Core.<*> (o Core..:? "diskSourceImage")
              Core.<*> (o Core..:? "diskType")
              Core.<*> (o Core..:? "ipConfiguration")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "machineType")
              Core.<*> (o Core..:? "metadata")
              Core.<*> (o Core..:? "network")
              Core.<*> (o Core..:? "numThreadsPerWorker")
              Core.<*> (o Core..:? "numWorkers")
              Core.<*> (o Core..:? "onHostMaintenance")
              Core.<*> (o Core..:? "packages")
              Core.<*> (o Core..:? "poolArgs")
              Core.<*> (o Core..:? "sdkHarnessContainerImages")
              Core.<*> (o Core..:? "subnetwork")
              Core.<*> (o Core..:? "taskrunnerSettings")
              Core.<*> (o Core..:? "teardownPolicy")
              Core.<*> (o Core..:? "workerHarnessContainerImage")
              Core.<*> (o Core..:? "zone")
        )
  
  instance Core.ToJSON WorkerPool where
    toJSON WorkerPool {..} =
      Core.object
        ( Core.catMaybes
            [ ("autoscalingSettings" Core..=) Core.<$> autoscalingSettings,
              ("dataDisks" Core..=) Core.<$> dataDisks,
              ("defaultPackageSet" Core..=) Core.<$> defaultPackageSet,
              ("diskSizeGb" Core..=) Core.<$> diskSizeGb,
              ("diskSourceImage" Core..=) Core.<$> diskSourceImage,
              ("diskType" Core..=) Core.<$> diskType,
              ("ipConfiguration" Core..=) Core.<$> ipConfiguration,
              ("kind" Core..=) Core.<$> kind,
              ("machineType" Core..=) Core.<$> machineType,
              ("metadata" Core..=) Core.<$> metadata,
              ("network" Core..=) Core.<$> network,
              ("numThreadsPerWorker" Core..=) Core.<$> numThreadsPerWorker,
              ("numWorkers" Core..=) Core.<$> numWorkers,
              ("onHostMaintenance" Core..=) Core.<$> onHostMaintenance,
              ("packages" Core..=) Core.<$> packages,
              ("poolArgs" Core..=) Core.<$> poolArgs,
              ("sdkHarnessContainerImages" Core..=)
                Core.<$> sdkHarnessContainerImages,
              ("subnetwork" Core..=) Core.<$> subnetwork,
              ("taskrunnerSettings" Core..=) Core.<$> taskrunnerSettings,
              ("teardownPolicy" Core..=) Core.<$> teardownPolicy,
              ("workerHarnessContainerImage" Core..=)
                Core.<$> workerHarnessContainerImage,
              ("zone" Core..=) Core.<$> zone
            ]
        )
  
  -- | Metadata to set on the Google Compute Engine VMs.
  --
  -- /See:/ 'newWorkerPool_Metadata' smart constructor.
  newtype WorkerPool_Metadata = WorkerPool_Metadata
    { additional :: (Core.HashMap Core.Text Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerPool_Metadata' with the minimum fields required to make a request.
  newWorkerPool_Metadata ::
    -- |  See 'additional'.
    Core.HashMap Core.Text Core.Text ->
    WorkerPool_Metadata
  newWorkerPool_Metadata additional =
    WorkerPool_Metadata {additional = additional}
  
  instance Core.FromJSON WorkerPool_Metadata where
    parseJSON =
      Core.withObject
        "WorkerPool_Metadata"
        (\o -> WorkerPool_Metadata Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON WorkerPool_Metadata where
    toJSON WorkerPool_Metadata {..} = Core.toJSON additional
  
  -- | Extra arguments for this worker pool.
  --
  -- /See:/ 'newWorkerPool_PoolArgs' smart constructor.
  newtype WorkerPool_PoolArgs = WorkerPool_PoolArgs
    { -- | 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 'WorkerPool_PoolArgs' with the minimum fields required to make a request.
  newWorkerPool_PoolArgs ::
    -- |  Properties of the object. Contains field \@type with type URL. See 'additional'.
    Core.HashMap Core.Text Core.Value ->
    WorkerPool_PoolArgs
  newWorkerPool_PoolArgs additional =
    WorkerPool_PoolArgs {additional = additional}
  
  instance Core.FromJSON WorkerPool_PoolArgs where
    parseJSON =
      Core.withObject
        "WorkerPool_PoolArgs"
        (\o -> WorkerPool_PoolArgs Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON WorkerPool_PoolArgs where
    toJSON WorkerPool_PoolArgs {..} = Core.toJSON additional
  
  -- | Provides data to pass through to the worker harness.
  --
  -- /See:/ 'newWorkerSettings' smart constructor.
  data WorkerSettings = WorkerSettings
    { -- | The base URL for accessing Google Cloud APIs. When workers access Google Cloud APIs, they logically do so via relative URLs. If this field is specified, it supplies the base URL to use for resolving these relative URLs. The normative algorithm used is defined by RFC 1808, \"Relative Uniform Resource Locators\". If not specified, the default value is \"http:\/\/www.googleapis.com\/\"
      baseUrl :: (Core.Maybe Core.Text),
      -- | Whether to send work progress updates to the service.
      reportingEnabled :: (Core.Maybe Core.Bool),
      -- | The Cloud Dataflow service path relative to the root URL, for example, \"dataflow\/v1b3\/projects\".
      servicePath :: (Core.Maybe Core.Text),
      -- | The Shuffle service path relative to the root URL, for example, \"shuffle\/v1beta1\".
      shuffleServicePath :: (Core.Maybe Core.Text),
      -- | The prefix of the resources the system should use for temporary storage. The supported resource type is: Google Cloud Storage: storage.googleapis.com\/{bucket}\/{object} bucket.storage.googleapis.com\/{object}
      tempStoragePrefix :: (Core.Maybe Core.Text),
      -- | The ID of the worker running this pipeline.
      workerId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerSettings' with the minimum fields required to make a request.
  newWorkerSettings ::
    WorkerSettings
  newWorkerSettings =
    WorkerSettings
      { baseUrl = Core.Nothing,
        reportingEnabled = Core.Nothing,
        servicePath = Core.Nothing,
        shuffleServicePath = Core.Nothing,
        tempStoragePrefix = Core.Nothing,
        workerId = Core.Nothing
      }
  
  instance Core.FromJSON WorkerSettings where
    parseJSON =
      Core.withObject
        "WorkerSettings"
        ( \o ->
            WorkerSettings
              Core.<$> (o Core..:? "baseUrl")
              Core.<*> (o Core..:? "reportingEnabled")
              Core.<*> (o Core..:? "servicePath")
              Core.<*> (o Core..:? "shuffleServicePath")
              Core.<*> (o Core..:? "tempStoragePrefix")
              Core.<*> (o Core..:? "workerId")
        )
  
  instance Core.ToJSON WorkerSettings where
    toJSON WorkerSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("baseUrl" Core..=) Core.<$> baseUrl,
              ("reportingEnabled" Core..=) Core.<$> reportingEnabled,
              ("servicePath" Core..=) Core.<$> servicePath,
              ("shuffleServicePath" Core..=) Core.<$> shuffleServicePath,
              ("tempStoragePrefix" Core..=) Core.<$> tempStoragePrefix,
              ("workerId" Core..=) Core.<$> workerId
            ]
        )
  
  -- | Shutdown notification from workers. This is to be sent by the shutdown script of the worker VM so that the backend knows that the VM is being shut down.
  --
  -- /See:/ 'newWorkerShutdownNotice' smart constructor.
  newtype WorkerShutdownNotice = WorkerShutdownNotice
    { -- | The reason for the worker shutdown. Current possible values are: \"UNKNOWN\": shutdown reason is unknown. \"PREEMPTION\": shutdown reason is preemption. Other possible reasons may be added in the future.
      reason :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerShutdownNotice' with the minimum fields required to make a request.
  newWorkerShutdownNotice ::
    WorkerShutdownNotice
  newWorkerShutdownNotice =
    WorkerShutdownNotice {reason = Core.Nothing}
  
  instance Core.FromJSON WorkerShutdownNotice where
    parseJSON =
      Core.withObject
        "WorkerShutdownNotice"
        (\o -> WorkerShutdownNotice Core.<$> (o Core..:? "reason"))
  
  instance Core.ToJSON WorkerShutdownNotice where
    toJSON WorkerShutdownNotice {..} =
      Core.object (Core.catMaybes [("reason" Core..=) Core.<$> reason])
  
  -- | Service-side response to WorkerMessage issuing shutdown notice.
  --
  -- /See:/ 'newWorkerShutdownNoticeResponse' smart constructor.
  data WorkerShutdownNoticeResponse = WorkerShutdownNoticeResponse
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerShutdownNoticeResponse' with the minimum fields required to make a request.
  newWorkerShutdownNoticeResponse ::
    WorkerShutdownNoticeResponse
  newWorkerShutdownNoticeResponse = WorkerShutdownNoticeResponse
  
  instance Core.FromJSON WorkerShutdownNoticeResponse where
    parseJSON =
      Core.withObject
        "WorkerShutdownNoticeResponse"
        (\o -> Core.pure WorkerShutdownNoticeResponse)
  
  instance Core.ToJSON WorkerShutdownNoticeResponse where
    toJSON = Core.const Core.emptyObject
  
  -- | Contains information about the thread scaling information of a worker.
  --
  -- /See:/ 'newWorkerThreadScalingReport' smart constructor.
  newtype WorkerThreadScalingReport = WorkerThreadScalingReport
    { -- | Current number of active threads in a worker.
      currentThreadCount :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerThreadScalingReport' with the minimum fields required to make a request.
  newWorkerThreadScalingReport ::
    WorkerThreadScalingReport
  newWorkerThreadScalingReport =
    WorkerThreadScalingReport {currentThreadCount = Core.Nothing}
  
  instance Core.FromJSON WorkerThreadScalingReport where
    parseJSON =
      Core.withObject
        "WorkerThreadScalingReport"
        ( \o ->
            WorkerThreadScalingReport
              Core.<$> (o Core..:? "currentThreadCount")
        )
  
  instance Core.ToJSON WorkerThreadScalingReport where
    toJSON WorkerThreadScalingReport {..} =
      Core.object
        ( Core.catMaybes
            [("currentThreadCount" Core..=) Core.<$> currentThreadCount]
        )
  
  -- | Contains the thread scaling recommendation for a worker from the backend.
  --
  -- /See:/ 'newWorkerThreadScalingReportResponse' smart constructor.
  newtype WorkerThreadScalingReportResponse = WorkerThreadScalingReportResponse
    { -- | Recommended number of threads for a worker.
      recommendedThreadCount :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WorkerThreadScalingReportResponse' with the minimum fields required to make a request.
  newWorkerThreadScalingReportResponse ::
    WorkerThreadScalingReportResponse
  newWorkerThreadScalingReportResponse =
    WorkerThreadScalingReportResponse
      { recommendedThreadCount =
          Core.Nothing
      }
  
  instance Core.FromJSON WorkerThreadScalingReportResponse where
    parseJSON =
      Core.withObject
        "WorkerThreadScalingReportResponse"
        ( \o ->
            WorkerThreadScalingReportResponse
              Core.<$> (o Core..:? "recommendedThreadCount")
        )
  
  instance Core.ToJSON WorkerThreadScalingReportResponse where
    toJSON WorkerThreadScalingReportResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("recommendedThreadCount" Core..=)
                Core.<$> recommendedThreadCount
            ]
        )
  
  -- | An instruction that writes records. Takes one input, produces no outputs.
  --
  -- /See:/ 'newWriteInstruction' smart constructor.
  data WriteInstruction = WriteInstruction
    { -- | The input.
      input :: (Core.Maybe InstructionInput),
      -- | The sink to write to.
      sink :: (Core.Maybe Sink)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WriteInstruction' with the minimum fields required to make a request.
  newWriteInstruction ::
    WriteInstruction
  newWriteInstruction =
    WriteInstruction {input = Core.Nothing, sink = Core.Nothing}
  
  instance Core.FromJSON WriteInstruction where
    parseJSON =
      Core.withObject
        "WriteInstruction"
        ( \o ->
            WriteInstruction
              Core.<$> (o Core..:? "input")
              Core.<*> (o Core..:? "sink")
        )
  
  instance Core.ToJSON WriteInstruction where
    toJSON WriteInstruction {..} =
      Core.object
        ( Core.catMaybes
            [("input" Core..=) Core.<$> input, ("sink" Core..=) Core.<$> sink]
        )
  