{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.AppSync.Types.Resolver
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.AppSync.Types.Resolver where

import Amazonka.AppSync.Types.AppSyncRuntime
import Amazonka.AppSync.Types.CachingConfig
import Amazonka.AppSync.Types.PipelineConfig
import Amazonka.AppSync.Types.ResolverKind
import Amazonka.AppSync.Types.SyncConfig
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude

-- | Describes a resolver.
--
-- /See:/ 'newResolver' smart constructor.
data Resolver = Resolver'
  { -- | The caching configuration for the resolver.
    Resolver -> Maybe CachingConfig
cachingConfig :: Prelude.Maybe CachingConfig,
    -- | The @resolver@ code that contains the request and response functions.
    -- When code is used, the @runtime@ is required. The @runtime@ value must
    -- be @APPSYNC_JS@.
    Resolver -> Maybe Text
code :: Prelude.Maybe Prelude.Text,
    -- | The resolver data source name.
    Resolver -> Maybe Text
dataSourceName :: Prelude.Maybe Prelude.Text,
    -- | The resolver field name.
    Resolver -> Maybe Text
fieldName :: Prelude.Maybe Prelude.Text,
    -- | The resolver type.
    --
    -- -   __UNIT__: A UNIT resolver type. A UNIT resolver is the default
    --     resolver type. You can use a UNIT resolver to run a GraphQL query
    --     against a single data source.
    --
    -- -   __PIPELINE__: A PIPELINE resolver type. You can use a PIPELINE
    --     resolver to invoke a series of @Function@ objects in a serial
    --     manner. You can use a pipeline resolver to run a GraphQL query
    --     against multiple data sources.
    Resolver -> Maybe ResolverKind
kind :: Prelude.Maybe ResolverKind,
    -- | The maximum batching size for a resolver.
    Resolver -> Maybe Natural
maxBatchSize :: Prelude.Maybe Prelude.Natural,
    -- | The @PipelineConfig@.
    Resolver -> Maybe PipelineConfig
pipelineConfig :: Prelude.Maybe PipelineConfig,
    -- | The request mapping template.
    Resolver -> Maybe Text
requestMappingTemplate :: Prelude.Maybe Prelude.Text,
    -- | The resolver Amazon Resource Name (ARN).
    Resolver -> Maybe Text
resolverArn :: Prelude.Maybe Prelude.Text,
    -- | The response mapping template.
    Resolver -> Maybe Text
responseMappingTemplate :: Prelude.Maybe Prelude.Text,
    Resolver -> Maybe AppSyncRuntime
runtime :: Prelude.Maybe AppSyncRuntime,
    -- | The @SyncConfig@ for a resolver attached to a versioned data source.
    Resolver -> Maybe SyncConfig
syncConfig :: Prelude.Maybe SyncConfig,
    -- | The resolver type name.
    Resolver -> Maybe Text
typeName :: Prelude.Maybe Prelude.Text
  }
  deriving (Resolver -> Resolver -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Resolver -> Resolver -> Bool
$c/= :: Resolver -> Resolver -> Bool
== :: Resolver -> Resolver -> Bool
$c== :: Resolver -> Resolver -> Bool
Prelude.Eq, ReadPrec [Resolver]
ReadPrec Resolver
Int -> ReadS Resolver
ReadS [Resolver]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Resolver]
$creadListPrec :: ReadPrec [Resolver]
readPrec :: ReadPrec Resolver
$creadPrec :: ReadPrec Resolver
readList :: ReadS [Resolver]
$creadList :: ReadS [Resolver]
readsPrec :: Int -> ReadS Resolver
$creadsPrec :: Int -> ReadS Resolver
Prelude.Read, Int -> Resolver -> ShowS
[Resolver] -> ShowS
Resolver -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Resolver] -> ShowS
$cshowList :: [Resolver] -> ShowS
show :: Resolver -> String
$cshow :: Resolver -> String
showsPrec :: Int -> Resolver -> ShowS
$cshowsPrec :: Int -> Resolver -> ShowS
Prelude.Show, forall x. Rep Resolver x -> Resolver
forall x. Resolver -> Rep Resolver x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Resolver x -> Resolver
$cfrom :: forall x. Resolver -> Rep Resolver x
Prelude.Generic)

-- |
-- Create a value of 'Resolver' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'cachingConfig', 'resolver_cachingConfig' - The caching configuration for the resolver.
--
-- 'code', 'resolver_code' - The @resolver@ code that contains the request and response functions.
-- When code is used, the @runtime@ is required. The @runtime@ value must
-- be @APPSYNC_JS@.
--
-- 'dataSourceName', 'resolver_dataSourceName' - The resolver data source name.
--
-- 'fieldName', 'resolver_fieldName' - The resolver field name.
--
-- 'kind', 'resolver_kind' - The resolver type.
--
-- -   __UNIT__: A UNIT resolver type. A UNIT resolver is the default
--     resolver type. You can use a UNIT resolver to run a GraphQL query
--     against a single data source.
--
-- -   __PIPELINE__: A PIPELINE resolver type. You can use a PIPELINE
--     resolver to invoke a series of @Function@ objects in a serial
--     manner. You can use a pipeline resolver to run a GraphQL query
--     against multiple data sources.
--
-- 'maxBatchSize', 'resolver_maxBatchSize' - The maximum batching size for a resolver.
--
-- 'pipelineConfig', 'resolver_pipelineConfig' - The @PipelineConfig@.
--
-- 'requestMappingTemplate', 'resolver_requestMappingTemplate' - The request mapping template.
--
-- 'resolverArn', 'resolver_resolverArn' - The resolver Amazon Resource Name (ARN).
--
-- 'responseMappingTemplate', 'resolver_responseMappingTemplate' - The response mapping template.
--
-- 'runtime', 'resolver_runtime' - Undocumented member.
--
-- 'syncConfig', 'resolver_syncConfig' - The @SyncConfig@ for a resolver attached to a versioned data source.
--
-- 'typeName', 'resolver_typeName' - The resolver type name.
newResolver ::
  Resolver
newResolver :: Resolver
newResolver =
  Resolver'
    { $sel:cachingConfig:Resolver' :: Maybe CachingConfig
cachingConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:code:Resolver' :: Maybe Text
code = forall a. Maybe a
Prelude.Nothing,
      $sel:dataSourceName:Resolver' :: Maybe Text
dataSourceName = forall a. Maybe a
Prelude.Nothing,
      $sel:fieldName:Resolver' :: Maybe Text
fieldName = forall a. Maybe a
Prelude.Nothing,
      $sel:kind:Resolver' :: Maybe ResolverKind
kind = forall a. Maybe a
Prelude.Nothing,
      $sel:maxBatchSize:Resolver' :: Maybe Natural
maxBatchSize = forall a. Maybe a
Prelude.Nothing,
      $sel:pipelineConfig:Resolver' :: Maybe PipelineConfig
pipelineConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:requestMappingTemplate:Resolver' :: Maybe Text
requestMappingTemplate = forall a. Maybe a
Prelude.Nothing,
      $sel:resolverArn:Resolver' :: Maybe Text
resolverArn = forall a. Maybe a
Prelude.Nothing,
      $sel:responseMappingTemplate:Resolver' :: Maybe Text
responseMappingTemplate = forall a. Maybe a
Prelude.Nothing,
      $sel:runtime:Resolver' :: Maybe AppSyncRuntime
runtime = forall a. Maybe a
Prelude.Nothing,
      $sel:syncConfig:Resolver' :: Maybe SyncConfig
syncConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:typeName:Resolver' :: Maybe Text
typeName = forall a. Maybe a
Prelude.Nothing
    }

-- | The caching configuration for the resolver.
resolver_cachingConfig :: Lens.Lens' Resolver (Prelude.Maybe CachingConfig)
resolver_cachingConfig :: Lens' Resolver (Maybe CachingConfig)
resolver_cachingConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe CachingConfig
cachingConfig :: Maybe CachingConfig
$sel:cachingConfig:Resolver' :: Resolver -> Maybe CachingConfig
cachingConfig} -> Maybe CachingConfig
cachingConfig) (\s :: Resolver
s@Resolver' {} Maybe CachingConfig
a -> Resolver
s {$sel:cachingConfig:Resolver' :: Maybe CachingConfig
cachingConfig = Maybe CachingConfig
a} :: Resolver)

-- | The @resolver@ code that contains the request and response functions.
-- When code is used, the @runtime@ is required. The @runtime@ value must
-- be @APPSYNC_JS@.
resolver_code :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Text)
resolver_code :: Lens' Resolver (Maybe Text)
resolver_code = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Text
code :: Maybe Text
$sel:code:Resolver' :: Resolver -> Maybe Text
code} -> Maybe Text
code) (\s :: Resolver
s@Resolver' {} Maybe Text
a -> Resolver
s {$sel:code:Resolver' :: Maybe Text
code = Maybe Text
a} :: Resolver)

-- | The resolver data source name.
resolver_dataSourceName :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Text)
resolver_dataSourceName :: Lens' Resolver (Maybe Text)
resolver_dataSourceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Text
dataSourceName :: Maybe Text
$sel:dataSourceName:Resolver' :: Resolver -> Maybe Text
dataSourceName} -> Maybe Text
dataSourceName) (\s :: Resolver
s@Resolver' {} Maybe Text
a -> Resolver
s {$sel:dataSourceName:Resolver' :: Maybe Text
dataSourceName = Maybe Text
a} :: Resolver)

-- | The resolver field name.
resolver_fieldName :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Text)
resolver_fieldName :: Lens' Resolver (Maybe Text)
resolver_fieldName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Text
fieldName :: Maybe Text
$sel:fieldName:Resolver' :: Resolver -> Maybe Text
fieldName} -> Maybe Text
fieldName) (\s :: Resolver
s@Resolver' {} Maybe Text
a -> Resolver
s {$sel:fieldName:Resolver' :: Maybe Text
fieldName = Maybe Text
a} :: Resolver)

-- | The resolver type.
--
-- -   __UNIT__: A UNIT resolver type. A UNIT resolver is the default
--     resolver type. You can use a UNIT resolver to run a GraphQL query
--     against a single data source.
--
-- -   __PIPELINE__: A PIPELINE resolver type. You can use a PIPELINE
--     resolver to invoke a series of @Function@ objects in a serial
--     manner. You can use a pipeline resolver to run a GraphQL query
--     against multiple data sources.
resolver_kind :: Lens.Lens' Resolver (Prelude.Maybe ResolverKind)
resolver_kind :: Lens' Resolver (Maybe ResolverKind)
resolver_kind = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe ResolverKind
kind :: Maybe ResolverKind
$sel:kind:Resolver' :: Resolver -> Maybe ResolverKind
kind} -> Maybe ResolverKind
kind) (\s :: Resolver
s@Resolver' {} Maybe ResolverKind
a -> Resolver
s {$sel:kind:Resolver' :: Maybe ResolverKind
kind = Maybe ResolverKind
a} :: Resolver)

-- | The maximum batching size for a resolver.
resolver_maxBatchSize :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Natural)
resolver_maxBatchSize :: Lens' Resolver (Maybe Natural)
resolver_maxBatchSize = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Natural
maxBatchSize :: Maybe Natural
$sel:maxBatchSize:Resolver' :: Resolver -> Maybe Natural
maxBatchSize} -> Maybe Natural
maxBatchSize) (\s :: Resolver
s@Resolver' {} Maybe Natural
a -> Resolver
s {$sel:maxBatchSize:Resolver' :: Maybe Natural
maxBatchSize = Maybe Natural
a} :: Resolver)

-- | The @PipelineConfig@.
resolver_pipelineConfig :: Lens.Lens' Resolver (Prelude.Maybe PipelineConfig)
resolver_pipelineConfig :: Lens' Resolver (Maybe PipelineConfig)
resolver_pipelineConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe PipelineConfig
pipelineConfig :: Maybe PipelineConfig
$sel:pipelineConfig:Resolver' :: Resolver -> Maybe PipelineConfig
pipelineConfig} -> Maybe PipelineConfig
pipelineConfig) (\s :: Resolver
s@Resolver' {} Maybe PipelineConfig
a -> Resolver
s {$sel:pipelineConfig:Resolver' :: Maybe PipelineConfig
pipelineConfig = Maybe PipelineConfig
a} :: Resolver)

-- | The request mapping template.
resolver_requestMappingTemplate :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Text)
resolver_requestMappingTemplate :: Lens' Resolver (Maybe Text)
resolver_requestMappingTemplate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Text
requestMappingTemplate :: Maybe Text
$sel:requestMappingTemplate:Resolver' :: Resolver -> Maybe Text
requestMappingTemplate} -> Maybe Text
requestMappingTemplate) (\s :: Resolver
s@Resolver' {} Maybe Text
a -> Resolver
s {$sel:requestMappingTemplate:Resolver' :: Maybe Text
requestMappingTemplate = Maybe Text
a} :: Resolver)

-- | The resolver Amazon Resource Name (ARN).
resolver_resolverArn :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Text)
resolver_resolverArn :: Lens' Resolver (Maybe Text)
resolver_resolverArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Text
resolverArn :: Maybe Text
$sel:resolverArn:Resolver' :: Resolver -> Maybe Text
resolverArn} -> Maybe Text
resolverArn) (\s :: Resolver
s@Resolver' {} Maybe Text
a -> Resolver
s {$sel:resolverArn:Resolver' :: Maybe Text
resolverArn = Maybe Text
a} :: Resolver)

-- | The response mapping template.
resolver_responseMappingTemplate :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Text)
resolver_responseMappingTemplate :: Lens' Resolver (Maybe Text)
resolver_responseMappingTemplate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Text
responseMappingTemplate :: Maybe Text
$sel:responseMappingTemplate:Resolver' :: Resolver -> Maybe Text
responseMappingTemplate} -> Maybe Text
responseMappingTemplate) (\s :: Resolver
s@Resolver' {} Maybe Text
a -> Resolver
s {$sel:responseMappingTemplate:Resolver' :: Maybe Text
responseMappingTemplate = Maybe Text
a} :: Resolver)

-- | Undocumented member.
resolver_runtime :: Lens.Lens' Resolver (Prelude.Maybe AppSyncRuntime)
resolver_runtime :: Lens' Resolver (Maybe AppSyncRuntime)
resolver_runtime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe AppSyncRuntime
runtime :: Maybe AppSyncRuntime
$sel:runtime:Resolver' :: Resolver -> Maybe AppSyncRuntime
runtime} -> Maybe AppSyncRuntime
runtime) (\s :: Resolver
s@Resolver' {} Maybe AppSyncRuntime
a -> Resolver
s {$sel:runtime:Resolver' :: Maybe AppSyncRuntime
runtime = Maybe AppSyncRuntime
a} :: Resolver)

-- | The @SyncConfig@ for a resolver attached to a versioned data source.
resolver_syncConfig :: Lens.Lens' Resolver (Prelude.Maybe SyncConfig)
resolver_syncConfig :: Lens' Resolver (Maybe SyncConfig)
resolver_syncConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe SyncConfig
syncConfig :: Maybe SyncConfig
$sel:syncConfig:Resolver' :: Resolver -> Maybe SyncConfig
syncConfig} -> Maybe SyncConfig
syncConfig) (\s :: Resolver
s@Resolver' {} Maybe SyncConfig
a -> Resolver
s {$sel:syncConfig:Resolver' :: Maybe SyncConfig
syncConfig = Maybe SyncConfig
a} :: Resolver)

-- | The resolver type name.
resolver_typeName :: Lens.Lens' Resolver (Prelude.Maybe Prelude.Text)
resolver_typeName :: Lens' Resolver (Maybe Text)
resolver_typeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Resolver' {Maybe Text
typeName :: Maybe Text
$sel:typeName:Resolver' :: Resolver -> Maybe Text
typeName} -> Maybe Text
typeName) (\s :: Resolver
s@Resolver' {} Maybe Text
a -> Resolver
s {$sel:typeName:Resolver' :: Maybe Text
typeName = Maybe Text
a} :: Resolver)

instance Data.FromJSON Resolver where
  parseJSON :: Value -> Parser Resolver
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Resolver"
      ( \Object
x ->
          Maybe CachingConfig
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe ResolverKind
-> Maybe Natural
-> Maybe PipelineConfig
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe AppSyncRuntime
-> Maybe SyncConfig
-> Maybe Text
-> Resolver
Resolver'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"cachingConfig")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"code")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"dataSourceName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"fieldName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"kind")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"maxBatchSize")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"pipelineConfig")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"requestMappingTemplate")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"resolverArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"responseMappingTemplate")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"runtime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"syncConfig")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"typeName")
      )

instance Prelude.Hashable Resolver where
  hashWithSalt :: Int -> Resolver -> Int
hashWithSalt Int
_salt Resolver' {Maybe Natural
Maybe Text
Maybe CachingConfig
Maybe PipelineConfig
Maybe ResolverKind
Maybe AppSyncRuntime
Maybe SyncConfig
typeName :: Maybe Text
syncConfig :: Maybe SyncConfig
runtime :: Maybe AppSyncRuntime
responseMappingTemplate :: Maybe Text
resolverArn :: Maybe Text
requestMappingTemplate :: Maybe Text
pipelineConfig :: Maybe PipelineConfig
maxBatchSize :: Maybe Natural
kind :: Maybe ResolverKind
fieldName :: Maybe Text
dataSourceName :: Maybe Text
code :: Maybe Text
cachingConfig :: Maybe CachingConfig
$sel:typeName:Resolver' :: Resolver -> Maybe Text
$sel:syncConfig:Resolver' :: Resolver -> Maybe SyncConfig
$sel:runtime:Resolver' :: Resolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:Resolver' :: Resolver -> Maybe Text
$sel:resolverArn:Resolver' :: Resolver -> Maybe Text
$sel:requestMappingTemplate:Resolver' :: Resolver -> Maybe Text
$sel:pipelineConfig:Resolver' :: Resolver -> Maybe PipelineConfig
$sel:maxBatchSize:Resolver' :: Resolver -> Maybe Natural
$sel:kind:Resolver' :: Resolver -> Maybe ResolverKind
$sel:fieldName:Resolver' :: Resolver -> Maybe Text
$sel:dataSourceName:Resolver' :: Resolver -> Maybe Text
$sel:code:Resolver' :: Resolver -> Maybe Text
$sel:cachingConfig:Resolver' :: Resolver -> Maybe CachingConfig
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CachingConfig
cachingConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
code
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dataSourceName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
fieldName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ResolverKind
kind
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxBatchSize
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PipelineConfig
pipelineConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
requestMappingTemplate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
resolverArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
responseMappingTemplate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AppSyncRuntime
runtime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SyncConfig
syncConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
typeName

instance Prelude.NFData Resolver where
  rnf :: Resolver -> ()
rnf Resolver' {Maybe Natural
Maybe Text
Maybe CachingConfig
Maybe PipelineConfig
Maybe ResolverKind
Maybe AppSyncRuntime
Maybe SyncConfig
typeName :: Maybe Text
syncConfig :: Maybe SyncConfig
runtime :: Maybe AppSyncRuntime
responseMappingTemplate :: Maybe Text
resolverArn :: Maybe Text
requestMappingTemplate :: Maybe Text
pipelineConfig :: Maybe PipelineConfig
maxBatchSize :: Maybe Natural
kind :: Maybe ResolverKind
fieldName :: Maybe Text
dataSourceName :: Maybe Text
code :: Maybe Text
cachingConfig :: Maybe CachingConfig
$sel:typeName:Resolver' :: Resolver -> Maybe Text
$sel:syncConfig:Resolver' :: Resolver -> Maybe SyncConfig
$sel:runtime:Resolver' :: Resolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:Resolver' :: Resolver -> Maybe Text
$sel:resolverArn:Resolver' :: Resolver -> Maybe Text
$sel:requestMappingTemplate:Resolver' :: Resolver -> Maybe Text
$sel:pipelineConfig:Resolver' :: Resolver -> Maybe PipelineConfig
$sel:maxBatchSize:Resolver' :: Resolver -> Maybe Natural
$sel:kind:Resolver' :: Resolver -> Maybe ResolverKind
$sel:fieldName:Resolver' :: Resolver -> Maybe Text
$sel:dataSourceName:Resolver' :: Resolver -> Maybe Text
$sel:code:Resolver' :: Resolver -> Maybe Text
$sel:cachingConfig:Resolver' :: Resolver -> Maybe CachingConfig
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CachingConfig
cachingConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
code
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dataSourceName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
fieldName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ResolverKind
kind
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxBatchSize
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PipelineConfig
pipelineConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
requestMappingTemplate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
resolverArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
responseMappingTemplate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AppSyncRuntime
runtime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SyncConfig
syncConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
typeName