{-# LANGUAGE DuplicateRecordFields #-}
{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
module Temporal.Client.Namespace
  ( Temporal.Client.Namespace.listNamespaces
  , ListNamespacesRequest(..)
  , DescribeNamespaceResponse(..)
  , NamespaceFilter(..)
  , NamespaceState(..)
  , NamespaceInfo(..)
  , NamespaceCapabilities(..)
  , ArchivalState(..)
  , BadBinaryInfo(..)
  , BadBinaries(..)
  , NamespaceConfig(..)
  , NamespaceReplicationConfig(..)
  , FailoverStatus(..)
  ) where

import Control.Monad.IO.Class
import Conduit
import Data.Int (Int64, Int32)
import Data.Map.Strict (Map)
import Data.Text (Text)
import Data.Time.Clock.System (SystemTime)
import qualified Data.Vector as V
import Temporal.Duration (Duration, durationFromProto)
import Temporal.Client (HasWorkflowClient (..))
import Temporal.Core.Client.WorkflowService (listNamespaces)
import Lens.Family2
import qualified Proto.Temporal.Api.Workflowservice.V1.RequestResponse as RR
import qualified Proto.Temporal.Api.Workflowservice.V1.RequestResponse_Fields as RR
import qualified Proto.Temporal.Api.Namespace.V1.Message as M
import qualified Proto.Temporal.Api.Namespace.V1.Message_Fields as M
import qualified Proto.Temporal.Api.Enums.V1.Namespace as M
import qualified Proto.Temporal.Api.Replication.V1.Message as R
import qualified Proto.Temporal.Api.Replication.V1.Message_Fields as R
import Temporal.Client.Types

import UnliftIO
import Data.ProtoLens
import Control.Monad
import qualified Data.ByteString as BS
import Temporal.Common

data NamespaceFilter = NamespaceFilter
  { NamespaceFilter -> Bool
includeDeleted :: !Bool
  } deriving stock (Int -> NamespaceFilter -> ShowS
[NamespaceFilter] -> ShowS
NamespaceFilter -> String
(Int -> NamespaceFilter -> ShowS)
-> (NamespaceFilter -> String)
-> ([NamespaceFilter] -> ShowS)
-> Show NamespaceFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamespaceFilter -> ShowS
showsPrec :: Int -> NamespaceFilter -> ShowS
$cshow :: NamespaceFilter -> String
show :: NamespaceFilter -> String
$cshowList :: [NamespaceFilter] -> ShowS
showList :: [NamespaceFilter] -> ShowS
Show, NamespaceFilter -> NamespaceFilter -> Bool
(NamespaceFilter -> NamespaceFilter -> Bool)
-> (NamespaceFilter -> NamespaceFilter -> Bool)
-> Eq NamespaceFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceFilter -> NamespaceFilter -> Bool
== :: NamespaceFilter -> NamespaceFilter -> Bool
$c/= :: NamespaceFilter -> NamespaceFilter -> Bool
/= :: NamespaceFilter -> NamespaceFilter -> Bool
Eq, Eq NamespaceFilter
Eq NamespaceFilter =>
(NamespaceFilter -> NamespaceFilter -> Ordering)
-> (NamespaceFilter -> NamespaceFilter -> Bool)
-> (NamespaceFilter -> NamespaceFilter -> Bool)
-> (NamespaceFilter -> NamespaceFilter -> Bool)
-> (NamespaceFilter -> NamespaceFilter -> Bool)
-> (NamespaceFilter -> NamespaceFilter -> NamespaceFilter)
-> (NamespaceFilter -> NamespaceFilter -> NamespaceFilter)
-> Ord NamespaceFilter
NamespaceFilter -> NamespaceFilter -> Bool
NamespaceFilter -> NamespaceFilter -> Ordering
NamespaceFilter -> NamespaceFilter -> NamespaceFilter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceFilter -> NamespaceFilter -> Ordering
compare :: NamespaceFilter -> NamespaceFilter -> Ordering
$c< :: NamespaceFilter -> NamespaceFilter -> Bool
< :: NamespaceFilter -> NamespaceFilter -> Bool
$c<= :: NamespaceFilter -> NamespaceFilter -> Bool
<= :: NamespaceFilter -> NamespaceFilter -> Bool
$c> :: NamespaceFilter -> NamespaceFilter -> Bool
> :: NamespaceFilter -> NamespaceFilter -> Bool
$c>= :: NamespaceFilter -> NamespaceFilter -> Bool
>= :: NamespaceFilter -> NamespaceFilter -> Bool
$cmax :: NamespaceFilter -> NamespaceFilter -> NamespaceFilter
max :: NamespaceFilter -> NamespaceFilter -> NamespaceFilter
$cmin :: NamespaceFilter -> NamespaceFilter -> NamespaceFilter
min :: NamespaceFilter -> NamespaceFilter -> NamespaceFilter
Ord)

namespaceFilterToProto :: NamespaceFilter -> M.NamespaceFilter
namespaceFilterToProto :: NamespaceFilter -> NamespaceFilter
namespaceFilterToProto NamespaceFilter{Bool
includeDeleted :: NamespaceFilter -> Bool
includeDeleted :: Bool
..} = NamespaceFilter
forall msg. Message msg => msg
defMessage
  NamespaceFilter
-> (NamespaceFilter -> NamespaceFilter) -> NamespaceFilter
forall s t. s -> (s -> t) -> t
& LensLike' f NamespaceFilter Bool
forall {f :: * -> *}.
Identical f =>
LensLike' f NamespaceFilter Bool
forall (f :: * -> *) s a.
(Functor f, HasField s "includeDeleted" a) =>
LensLike' f s a
M.includeDeleted (forall {f :: * -> *}.
 Identical f =>
 LensLike' f NamespaceFilter Bool)
-> Bool -> NamespaceFilter -> NamespaceFilter
forall s t a b. Setter s t a b -> b -> s -> t
.~ Bool
includeDeleted

data NamespaceState
  = NamespaceStateUnspecified
  | NamespaceStateRegistered
  | NamespaceStateDeprecated
  | NamespaceStateDeleted
  | NamespaceStateUnrecognized
  deriving stock (Int -> NamespaceState -> ShowS
[NamespaceState] -> ShowS
NamespaceState -> String
(Int -> NamespaceState -> ShowS)
-> (NamespaceState -> String)
-> ([NamespaceState] -> ShowS)
-> Show NamespaceState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamespaceState -> ShowS
showsPrec :: Int -> NamespaceState -> ShowS
$cshow :: NamespaceState -> String
show :: NamespaceState -> String
$cshowList :: [NamespaceState] -> ShowS
showList :: [NamespaceState] -> ShowS
Show, NamespaceState -> NamespaceState -> Bool
(NamespaceState -> NamespaceState -> Bool)
-> (NamespaceState -> NamespaceState -> Bool) -> Eq NamespaceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceState -> NamespaceState -> Bool
== :: NamespaceState -> NamespaceState -> Bool
$c/= :: NamespaceState -> NamespaceState -> Bool
/= :: NamespaceState -> NamespaceState -> Bool
Eq, Eq NamespaceState
Eq NamespaceState =>
(NamespaceState -> NamespaceState -> Ordering)
-> (NamespaceState -> NamespaceState -> Bool)
-> (NamespaceState -> NamespaceState -> Bool)
-> (NamespaceState -> NamespaceState -> Bool)
-> (NamespaceState -> NamespaceState -> Bool)
-> (NamespaceState -> NamespaceState -> NamespaceState)
-> (NamespaceState -> NamespaceState -> NamespaceState)
-> Ord NamespaceState
NamespaceState -> NamespaceState -> Bool
NamespaceState -> NamespaceState -> Ordering
NamespaceState -> NamespaceState -> NamespaceState
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceState -> NamespaceState -> Ordering
compare :: NamespaceState -> NamespaceState -> Ordering
$c< :: NamespaceState -> NamespaceState -> Bool
< :: NamespaceState -> NamespaceState -> Bool
$c<= :: NamespaceState -> NamespaceState -> Bool
<= :: NamespaceState -> NamespaceState -> Bool
$c> :: NamespaceState -> NamespaceState -> Bool
> :: NamespaceState -> NamespaceState -> Bool
$c>= :: NamespaceState -> NamespaceState -> Bool
>= :: NamespaceState -> NamespaceState -> Bool
$cmax :: NamespaceState -> NamespaceState -> NamespaceState
max :: NamespaceState -> NamespaceState -> NamespaceState
$cmin :: NamespaceState -> NamespaceState -> NamespaceState
min :: NamespaceState -> NamespaceState -> NamespaceState
Ord)

namespaceStateFromProto :: M.NamespaceState -> NamespaceState
namespaceStateFromProto :: NamespaceState -> NamespaceState
namespaceStateFromProto = \case
  NamespaceState
M.NAMESPACE_STATE_UNSPECIFIED -> NamespaceState
NamespaceStateUnspecified
  NamespaceState
M.NAMESPACE_STATE_REGISTERED -> NamespaceState
NamespaceStateRegistered
  NamespaceState
M.NAMESPACE_STATE_DEPRECATED -> NamespaceState
NamespaceStateDeprecated
  NamespaceState
M.NAMESPACE_STATE_DELETED -> NamespaceState
NamespaceStateDeleted
  (M.NamespaceState'Unrecognized NamespaceState'UnrecognizedValue
_) -> NamespaceState
NamespaceStateUnrecognized

data NamespaceInfo = NamespaceInfo
  { NamespaceInfo -> Text
name :: !Text
  , NamespaceInfo -> NamespaceState
state :: !NamespaceState
  , NamespaceInfo -> Text
description :: !Text
  , NamespaceInfo -> Text
ownerEmail :: !Text
  , NamespaceInfo -> Text
id :: !Text
  , NamespaceInfo -> Map Text Text
data' :: !(Map Text Text)
  -- ^ A key-value map for any customized purpose.
  , NamespaceInfo -> Maybe NamespaceCapabilities
capabilities :: !(Maybe NamespaceCapabilities)
  , NamespaceInfo -> Bool
supportsSchedules :: !Bool
  } deriving stock (Int -> NamespaceInfo -> ShowS
[NamespaceInfo] -> ShowS
NamespaceInfo -> String
(Int -> NamespaceInfo -> ShowS)
-> (NamespaceInfo -> String)
-> ([NamespaceInfo] -> ShowS)
-> Show NamespaceInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamespaceInfo -> ShowS
showsPrec :: Int -> NamespaceInfo -> ShowS
$cshow :: NamespaceInfo -> String
show :: NamespaceInfo -> String
$cshowList :: [NamespaceInfo] -> ShowS
showList :: [NamespaceInfo] -> ShowS
Show, NamespaceInfo -> NamespaceInfo -> Bool
(NamespaceInfo -> NamespaceInfo -> Bool)
-> (NamespaceInfo -> NamespaceInfo -> Bool) -> Eq NamespaceInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceInfo -> NamespaceInfo -> Bool
== :: NamespaceInfo -> NamespaceInfo -> Bool
$c/= :: NamespaceInfo -> NamespaceInfo -> Bool
/= :: NamespaceInfo -> NamespaceInfo -> Bool
Eq, Eq NamespaceInfo
Eq NamespaceInfo =>
(NamespaceInfo -> NamespaceInfo -> Ordering)
-> (NamespaceInfo -> NamespaceInfo -> Bool)
-> (NamespaceInfo -> NamespaceInfo -> Bool)
-> (NamespaceInfo -> NamespaceInfo -> Bool)
-> (NamespaceInfo -> NamespaceInfo -> Bool)
-> (NamespaceInfo -> NamespaceInfo -> NamespaceInfo)
-> (NamespaceInfo -> NamespaceInfo -> NamespaceInfo)
-> Ord NamespaceInfo
NamespaceInfo -> NamespaceInfo -> Bool
NamespaceInfo -> NamespaceInfo -> Ordering
NamespaceInfo -> NamespaceInfo -> NamespaceInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceInfo -> NamespaceInfo -> Ordering
compare :: NamespaceInfo -> NamespaceInfo -> Ordering
$c< :: NamespaceInfo -> NamespaceInfo -> Bool
< :: NamespaceInfo -> NamespaceInfo -> Bool
$c<= :: NamespaceInfo -> NamespaceInfo -> Bool
<= :: NamespaceInfo -> NamespaceInfo -> Bool
$c> :: NamespaceInfo -> NamespaceInfo -> Bool
> :: NamespaceInfo -> NamespaceInfo -> Bool
$c>= :: NamespaceInfo -> NamespaceInfo -> Bool
>= :: NamespaceInfo -> NamespaceInfo -> Bool
$cmax :: NamespaceInfo -> NamespaceInfo -> NamespaceInfo
max :: NamespaceInfo -> NamespaceInfo -> NamespaceInfo
$cmin :: NamespaceInfo -> NamespaceInfo -> NamespaceInfo
min :: NamespaceInfo -> NamespaceInfo -> NamespaceInfo
Ord)

namespaceInfoFromProto :: M.NamespaceInfo -> NamespaceInfo
namespaceInfoFromProto :: NamespaceInfo -> NamespaceInfo
namespaceInfoFromProto NamespaceInfo
x = NamespaceInfo
  { name :: Text
name = NamespaceInfo
x NamespaceInfo
-> FoldLike Text NamespaceInfo NamespaceInfo Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text NamespaceInfo NamespaceInfo Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "name" a) =>
LensLike' f s a
M.name
  , state :: NamespaceState
state = NamespaceState -> NamespaceState
namespaceStateFromProto (NamespaceInfo
x NamespaceInfo
-> FoldLike
     NamespaceState
     NamespaceInfo
     NamespaceInfo
     NamespaceState
     NamespaceState
-> NamespaceState
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  NamespaceState
  NamespaceInfo
  NamespaceInfo
  NamespaceState
  NamespaceState
forall (f :: * -> *) s a.
(Functor f, HasField s "state" a) =>
LensLike' f s a
M.state)
  , description :: Text
description = NamespaceInfo
x NamespaceInfo
-> FoldLike Text NamespaceInfo NamespaceInfo Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text NamespaceInfo NamespaceInfo Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "description" a) =>
LensLike' f s a
M.description
  , ownerEmail :: Text
ownerEmail = NamespaceInfo
x NamespaceInfo
-> FoldLike Text NamespaceInfo NamespaceInfo Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text NamespaceInfo NamespaceInfo Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "ownerEmail" a) =>
LensLike' f s a
M.ownerEmail
  , id :: Text
id = NamespaceInfo
x NamespaceInfo
-> FoldLike Text NamespaceInfo NamespaceInfo Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text NamespaceInfo NamespaceInfo Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "id" a) =>
LensLike' f s a
M.id
  , data' :: Map Text Text
data' = NamespaceInfo
x NamespaceInfo
-> FoldLike
     (Map Text Text)
     NamespaceInfo
     NamespaceInfo
     (Map Text Text)
     (Map Text Text)
-> Map Text Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Map Text Text)
  NamespaceInfo
  NamespaceInfo
  (Map Text Text)
  (Map Text Text)
forall (f :: * -> *) s a.
(Functor f, HasField s "data'" a) =>
LensLike' f s a
M.data'
  , capabilities :: Maybe NamespaceCapabilities
capabilities = NamespaceInfo'Capabilities -> NamespaceCapabilities
namespaceCapabilitiesFromProto (NamespaceInfo'Capabilities -> NamespaceCapabilities)
-> Maybe NamespaceInfo'Capabilities -> Maybe NamespaceCapabilities
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NamespaceInfo
x NamespaceInfo
-> FoldLike
     (Maybe NamespaceInfo'Capabilities)
     NamespaceInfo
     NamespaceInfo
     (Maybe NamespaceInfo'Capabilities)
     (Maybe NamespaceInfo'Capabilities)
-> Maybe NamespaceInfo'Capabilities
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Maybe NamespaceInfo'Capabilities)
  NamespaceInfo
  NamespaceInfo
  (Maybe NamespaceInfo'Capabilities)
  (Maybe NamespaceInfo'Capabilities)
forall (f :: * -> *) s a.
(Functor f, HasField s "maybe'capabilities" a) =>
LensLike' f s a
M.maybe'capabilities)
  , supportsSchedules :: Bool
supportsSchedules = NamespaceInfo
x NamespaceInfo
-> FoldLike Bool NamespaceInfo NamespaceInfo Bool Bool -> Bool
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Bool NamespaceInfo NamespaceInfo Bool Bool
forall (f :: * -> *) s a.
(Functor f, HasField s "supportsSchedules" a) =>
LensLike' f s a
M.supportsSchedules
  }

data NamespaceCapabilities = NamespaceCapabilities
  { NamespaceCapabilities -> Bool
eagerWorkflowStart :: !Bool
  , NamespaceCapabilities -> Bool
syncUpdate :: !Bool
  , NamespaceCapabilities -> Bool
asyncUpdate :: !Bool
  } deriving stock (Int -> NamespaceCapabilities -> ShowS
[NamespaceCapabilities] -> ShowS
NamespaceCapabilities -> String
(Int -> NamespaceCapabilities -> ShowS)
-> (NamespaceCapabilities -> String)
-> ([NamespaceCapabilities] -> ShowS)
-> Show NamespaceCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamespaceCapabilities -> ShowS
showsPrec :: Int -> NamespaceCapabilities -> ShowS
$cshow :: NamespaceCapabilities -> String
show :: NamespaceCapabilities -> String
$cshowList :: [NamespaceCapabilities] -> ShowS
showList :: [NamespaceCapabilities] -> ShowS
Show, NamespaceCapabilities -> NamespaceCapabilities -> Bool
(NamespaceCapabilities -> NamespaceCapabilities -> Bool)
-> (NamespaceCapabilities -> NamespaceCapabilities -> Bool)
-> Eq NamespaceCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
== :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
$c/= :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
/= :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
Eq, Eq NamespaceCapabilities
Eq NamespaceCapabilities =>
(NamespaceCapabilities -> NamespaceCapabilities -> Ordering)
-> (NamespaceCapabilities -> NamespaceCapabilities -> Bool)
-> (NamespaceCapabilities -> NamespaceCapabilities -> Bool)
-> (NamespaceCapabilities -> NamespaceCapabilities -> Bool)
-> (NamespaceCapabilities -> NamespaceCapabilities -> Bool)
-> (NamespaceCapabilities
    -> NamespaceCapabilities -> NamespaceCapabilities)
-> (NamespaceCapabilities
    -> NamespaceCapabilities -> NamespaceCapabilities)
-> Ord NamespaceCapabilities
NamespaceCapabilities -> NamespaceCapabilities -> Bool
NamespaceCapabilities -> NamespaceCapabilities -> Ordering
NamespaceCapabilities
-> NamespaceCapabilities -> NamespaceCapabilities
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceCapabilities -> NamespaceCapabilities -> Ordering
compare :: NamespaceCapabilities -> NamespaceCapabilities -> Ordering
$c< :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
< :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
$c<= :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
<= :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
$c> :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
> :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
$c>= :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
>= :: NamespaceCapabilities -> NamespaceCapabilities -> Bool
$cmax :: NamespaceCapabilities
-> NamespaceCapabilities -> NamespaceCapabilities
max :: NamespaceCapabilities
-> NamespaceCapabilities -> NamespaceCapabilities
$cmin :: NamespaceCapabilities
-> NamespaceCapabilities -> NamespaceCapabilities
min :: NamespaceCapabilities
-> NamespaceCapabilities -> NamespaceCapabilities
Ord)

namespaceCapabilitiesFromProto :: M.NamespaceInfo'Capabilities -> NamespaceCapabilities
namespaceCapabilitiesFromProto :: NamespaceInfo'Capabilities -> NamespaceCapabilities
namespaceCapabilitiesFromProto NamespaceInfo'Capabilities
x = NamespaceCapabilities
  { eagerWorkflowStart :: Bool
eagerWorkflowStart = NamespaceInfo'Capabilities
x NamespaceInfo'Capabilities
-> FoldLike
     Bool
     NamespaceInfo'Capabilities
     NamespaceInfo'Capabilities
     Bool
     Bool
-> Bool
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Bool
  NamespaceInfo'Capabilities
  NamespaceInfo'Capabilities
  Bool
  Bool
forall (f :: * -> *) s a.
(Functor f, HasField s "eagerWorkflowStart" a) =>
LensLike' f s a
M.eagerWorkflowStart
  , syncUpdate :: Bool
syncUpdate = NamespaceInfo'Capabilities
x NamespaceInfo'Capabilities
-> FoldLike
     Bool
     NamespaceInfo'Capabilities
     NamespaceInfo'Capabilities
     Bool
     Bool
-> Bool
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Bool
  NamespaceInfo'Capabilities
  NamespaceInfo'Capabilities
  Bool
  Bool
forall (f :: * -> *) s a.
(Functor f, HasField s "syncUpdate" a) =>
LensLike' f s a
M.syncUpdate
  , asyncUpdate :: Bool
asyncUpdate = NamespaceInfo'Capabilities
x NamespaceInfo'Capabilities
-> FoldLike
     Bool
     NamespaceInfo'Capabilities
     NamespaceInfo'Capabilities
     Bool
     Bool
-> Bool
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Bool
  NamespaceInfo'Capabilities
  NamespaceInfo'Capabilities
  Bool
  Bool
forall (f :: * -> *) s a.
(Functor f, HasField s "asyncUpdate" a) =>
LensLike' f s a
M.asyncUpdate
  }

data ArchivalState
  = ArchivalStateUnspecified
  | ArchivalStateDisabled
  | ArchivalStateEnabled
  | ArchivalStateUnrecognized
  deriving stock (Int -> ArchivalState -> ShowS
[ArchivalState] -> ShowS
ArchivalState -> String
(Int -> ArchivalState -> ShowS)
-> (ArchivalState -> String)
-> ([ArchivalState] -> ShowS)
-> Show ArchivalState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArchivalState -> ShowS
showsPrec :: Int -> ArchivalState -> ShowS
$cshow :: ArchivalState -> String
show :: ArchivalState -> String
$cshowList :: [ArchivalState] -> ShowS
showList :: [ArchivalState] -> ShowS
Show, ArchivalState -> ArchivalState -> Bool
(ArchivalState -> ArchivalState -> Bool)
-> (ArchivalState -> ArchivalState -> Bool) -> Eq ArchivalState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArchivalState -> ArchivalState -> Bool
== :: ArchivalState -> ArchivalState -> Bool
$c/= :: ArchivalState -> ArchivalState -> Bool
/= :: ArchivalState -> ArchivalState -> Bool
Eq, Eq ArchivalState
Eq ArchivalState =>
(ArchivalState -> ArchivalState -> Ordering)
-> (ArchivalState -> ArchivalState -> Bool)
-> (ArchivalState -> ArchivalState -> Bool)
-> (ArchivalState -> ArchivalState -> Bool)
-> (ArchivalState -> ArchivalState -> Bool)
-> (ArchivalState -> ArchivalState -> ArchivalState)
-> (ArchivalState -> ArchivalState -> ArchivalState)
-> Ord ArchivalState
ArchivalState -> ArchivalState -> Bool
ArchivalState -> ArchivalState -> Ordering
ArchivalState -> ArchivalState -> ArchivalState
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ArchivalState -> ArchivalState -> Ordering
compare :: ArchivalState -> ArchivalState -> Ordering
$c< :: ArchivalState -> ArchivalState -> Bool
< :: ArchivalState -> ArchivalState -> Bool
$c<= :: ArchivalState -> ArchivalState -> Bool
<= :: ArchivalState -> ArchivalState -> Bool
$c> :: ArchivalState -> ArchivalState -> Bool
> :: ArchivalState -> ArchivalState -> Bool
$c>= :: ArchivalState -> ArchivalState -> Bool
>= :: ArchivalState -> ArchivalState -> Bool
$cmax :: ArchivalState -> ArchivalState -> ArchivalState
max :: ArchivalState -> ArchivalState -> ArchivalState
$cmin :: ArchivalState -> ArchivalState -> ArchivalState
min :: ArchivalState -> ArchivalState -> ArchivalState
Ord)

archivalStateFromProto :: M.ArchivalState -> ArchivalState
archivalStateFromProto :: ArchivalState -> ArchivalState
archivalStateFromProto = \case
  ArchivalState
M.ARCHIVAL_STATE_UNSPECIFIED -> ArchivalState
ArchivalStateUnspecified
  ArchivalState
M.ARCHIVAL_STATE_DISABLED -> ArchivalState
ArchivalStateDisabled
  ArchivalState
M.ARCHIVAL_STATE_ENABLED -> ArchivalState
ArchivalStateEnabled
  (M.ArchivalState'Unrecognized ArchivalState'UnrecognizedValue
_) -> ArchivalState
ArchivalStateUnrecognized

data BadBinaryInfo = BadBinaryInfo
  { BadBinaryInfo -> Text
reason :: !Text
  , BadBinaryInfo -> Text
operator :: !Text
  , BadBinaryInfo -> SystemTime
createTime :: !SystemTime
  } deriving stock (Int -> BadBinaryInfo -> ShowS
[BadBinaryInfo] -> ShowS
BadBinaryInfo -> String
(Int -> BadBinaryInfo -> ShowS)
-> (BadBinaryInfo -> String)
-> ([BadBinaryInfo] -> ShowS)
-> Show BadBinaryInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BadBinaryInfo -> ShowS
showsPrec :: Int -> BadBinaryInfo -> ShowS
$cshow :: BadBinaryInfo -> String
show :: BadBinaryInfo -> String
$cshowList :: [BadBinaryInfo] -> ShowS
showList :: [BadBinaryInfo] -> ShowS
Show, BadBinaryInfo -> BadBinaryInfo -> Bool
(BadBinaryInfo -> BadBinaryInfo -> Bool)
-> (BadBinaryInfo -> BadBinaryInfo -> Bool) -> Eq BadBinaryInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BadBinaryInfo -> BadBinaryInfo -> Bool
== :: BadBinaryInfo -> BadBinaryInfo -> Bool
$c/= :: BadBinaryInfo -> BadBinaryInfo -> Bool
/= :: BadBinaryInfo -> BadBinaryInfo -> Bool
Eq, Eq BadBinaryInfo
Eq BadBinaryInfo =>
(BadBinaryInfo -> BadBinaryInfo -> Ordering)
-> (BadBinaryInfo -> BadBinaryInfo -> Bool)
-> (BadBinaryInfo -> BadBinaryInfo -> Bool)
-> (BadBinaryInfo -> BadBinaryInfo -> Bool)
-> (BadBinaryInfo -> BadBinaryInfo -> Bool)
-> (BadBinaryInfo -> BadBinaryInfo -> BadBinaryInfo)
-> (BadBinaryInfo -> BadBinaryInfo -> BadBinaryInfo)
-> Ord BadBinaryInfo
BadBinaryInfo -> BadBinaryInfo -> Bool
BadBinaryInfo -> BadBinaryInfo -> Ordering
BadBinaryInfo -> BadBinaryInfo -> BadBinaryInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BadBinaryInfo -> BadBinaryInfo -> Ordering
compare :: BadBinaryInfo -> BadBinaryInfo -> Ordering
$c< :: BadBinaryInfo -> BadBinaryInfo -> Bool
< :: BadBinaryInfo -> BadBinaryInfo -> Bool
$c<= :: BadBinaryInfo -> BadBinaryInfo -> Bool
<= :: BadBinaryInfo -> BadBinaryInfo -> Bool
$c> :: BadBinaryInfo -> BadBinaryInfo -> Bool
> :: BadBinaryInfo -> BadBinaryInfo -> Bool
$c>= :: BadBinaryInfo -> BadBinaryInfo -> Bool
>= :: BadBinaryInfo -> BadBinaryInfo -> Bool
$cmax :: BadBinaryInfo -> BadBinaryInfo -> BadBinaryInfo
max :: BadBinaryInfo -> BadBinaryInfo -> BadBinaryInfo
$cmin :: BadBinaryInfo -> BadBinaryInfo -> BadBinaryInfo
min :: BadBinaryInfo -> BadBinaryInfo -> BadBinaryInfo
Ord)

badBinaryInfoFromProto :: M.BadBinaryInfo -> BadBinaryInfo
badBinaryInfoFromProto :: BadBinaryInfo -> BadBinaryInfo
badBinaryInfoFromProto BadBinaryInfo
x = BadBinaryInfo
  { reason :: Text
reason = BadBinaryInfo
x BadBinaryInfo
-> FoldLike Text BadBinaryInfo BadBinaryInfo Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text BadBinaryInfo BadBinaryInfo Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "reason" a) =>
LensLike' f s a
M.reason
  , operator :: Text
operator = BadBinaryInfo
x BadBinaryInfo
-> FoldLike Text BadBinaryInfo BadBinaryInfo Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text BadBinaryInfo BadBinaryInfo Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "operator" a) =>
LensLike' f s a
M.operator
  , createTime :: SystemTime
createTime = Timestamp -> SystemTime
timespecFromTimestamp (BadBinaryInfo
x BadBinaryInfo
-> FoldLike
     Timestamp BadBinaryInfo BadBinaryInfo Timestamp Timestamp
-> Timestamp
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Timestamp BadBinaryInfo BadBinaryInfo Timestamp Timestamp
forall (f :: * -> *) s a.
(Functor f, HasField s "createTime" a) =>
LensLike' f s a
M.createTime)
  }

data BadBinaries = BadBinaries
  { BadBinaries -> Map Text BadBinaryInfo
binaries :: !(Map Text BadBinaryInfo)
  } deriving stock (Int -> BadBinaries -> ShowS
[BadBinaries] -> ShowS
BadBinaries -> String
(Int -> BadBinaries -> ShowS)
-> (BadBinaries -> String)
-> ([BadBinaries] -> ShowS)
-> Show BadBinaries
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BadBinaries -> ShowS
showsPrec :: Int -> BadBinaries -> ShowS
$cshow :: BadBinaries -> String
show :: BadBinaries -> String
$cshowList :: [BadBinaries] -> ShowS
showList :: [BadBinaries] -> ShowS
Show, BadBinaries -> BadBinaries -> Bool
(BadBinaries -> BadBinaries -> Bool)
-> (BadBinaries -> BadBinaries -> Bool) -> Eq BadBinaries
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BadBinaries -> BadBinaries -> Bool
== :: BadBinaries -> BadBinaries -> Bool
$c/= :: BadBinaries -> BadBinaries -> Bool
/= :: BadBinaries -> BadBinaries -> Bool
Eq, Eq BadBinaries
Eq BadBinaries =>
(BadBinaries -> BadBinaries -> Ordering)
-> (BadBinaries -> BadBinaries -> Bool)
-> (BadBinaries -> BadBinaries -> Bool)
-> (BadBinaries -> BadBinaries -> Bool)
-> (BadBinaries -> BadBinaries -> Bool)
-> (BadBinaries -> BadBinaries -> BadBinaries)
-> (BadBinaries -> BadBinaries -> BadBinaries)
-> Ord BadBinaries
BadBinaries -> BadBinaries -> Bool
BadBinaries -> BadBinaries -> Ordering
BadBinaries -> BadBinaries -> BadBinaries
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BadBinaries -> BadBinaries -> Ordering
compare :: BadBinaries -> BadBinaries -> Ordering
$c< :: BadBinaries -> BadBinaries -> Bool
< :: BadBinaries -> BadBinaries -> Bool
$c<= :: BadBinaries -> BadBinaries -> Bool
<= :: BadBinaries -> BadBinaries -> Bool
$c> :: BadBinaries -> BadBinaries -> Bool
> :: BadBinaries -> BadBinaries -> Bool
$c>= :: BadBinaries -> BadBinaries -> Bool
>= :: BadBinaries -> BadBinaries -> Bool
$cmax :: BadBinaries -> BadBinaries -> BadBinaries
max :: BadBinaries -> BadBinaries -> BadBinaries
$cmin :: BadBinaries -> BadBinaries -> BadBinaries
min :: BadBinaries -> BadBinaries -> BadBinaries
Ord)

badBinariesFromProto :: M.BadBinaries -> BadBinaries
badBinariesFromProto :: BadBinaries -> BadBinaries
badBinariesFromProto BadBinaries
x = BadBinaries
  { binaries :: Map Text BadBinaryInfo
binaries = BadBinaryInfo -> BadBinaryInfo
badBinaryInfoFromProto (BadBinaryInfo -> BadBinaryInfo)
-> Map Text BadBinaryInfo -> Map Text BadBinaryInfo
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (BadBinaries
x BadBinaries
-> FoldLike
     (Map Text BadBinaryInfo)
     BadBinaries
     BadBinaries
     (Map Text BadBinaryInfo)
     (Map Text BadBinaryInfo)
-> Map Text BadBinaryInfo
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Map Text BadBinaryInfo)
  BadBinaries
  BadBinaries
  (Map Text BadBinaryInfo)
  (Map Text BadBinaryInfo)
forall (f :: * -> *) s a.
(Functor f, HasField s "binaries" a) =>
LensLike' f s a
M.binaries)
  }

data NamespaceConfig = NamespaceConfig
  { NamespaceConfig -> Maybe Duration
workflowExecutionRetentionTtl :: !(Maybe Duration)
  , NamespaceConfig -> Maybe BadBinaries
badBinaries :: !(Maybe BadBinaries)
  , NamespaceConfig -> ArchivalState
historyArchivalState :: !ArchivalState
  , NamespaceConfig -> Text
historyArchivalUri :: !Text
  , NamespaceConfig -> ArchivalState
visibilityArchivalState :: !ArchivalState
  , NamespaceConfig -> Text
visibilityArchivalUri :: !Text
  , NamespaceConfig -> Map Text Text
customSearchAttributeAliases :: !(Map Text Text)
  } deriving stock (Int -> NamespaceConfig -> ShowS
[NamespaceConfig] -> ShowS
NamespaceConfig -> String
(Int -> NamespaceConfig -> ShowS)
-> (NamespaceConfig -> String)
-> ([NamespaceConfig] -> ShowS)
-> Show NamespaceConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamespaceConfig -> ShowS
showsPrec :: Int -> NamespaceConfig -> ShowS
$cshow :: NamespaceConfig -> String
show :: NamespaceConfig -> String
$cshowList :: [NamespaceConfig] -> ShowS
showList :: [NamespaceConfig] -> ShowS
Show, NamespaceConfig -> NamespaceConfig -> Bool
(NamespaceConfig -> NamespaceConfig -> Bool)
-> (NamespaceConfig -> NamespaceConfig -> Bool)
-> Eq NamespaceConfig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceConfig -> NamespaceConfig -> Bool
== :: NamespaceConfig -> NamespaceConfig -> Bool
$c/= :: NamespaceConfig -> NamespaceConfig -> Bool
/= :: NamespaceConfig -> NamespaceConfig -> Bool
Eq, Eq NamespaceConfig
Eq NamespaceConfig =>
(NamespaceConfig -> NamespaceConfig -> Ordering)
-> (NamespaceConfig -> NamespaceConfig -> Bool)
-> (NamespaceConfig -> NamespaceConfig -> Bool)
-> (NamespaceConfig -> NamespaceConfig -> Bool)
-> (NamespaceConfig -> NamespaceConfig -> Bool)
-> (NamespaceConfig -> NamespaceConfig -> NamespaceConfig)
-> (NamespaceConfig -> NamespaceConfig -> NamespaceConfig)
-> Ord NamespaceConfig
NamespaceConfig -> NamespaceConfig -> Bool
NamespaceConfig -> NamespaceConfig -> Ordering
NamespaceConfig -> NamespaceConfig -> NamespaceConfig
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceConfig -> NamespaceConfig -> Ordering
compare :: NamespaceConfig -> NamespaceConfig -> Ordering
$c< :: NamespaceConfig -> NamespaceConfig -> Bool
< :: NamespaceConfig -> NamespaceConfig -> Bool
$c<= :: NamespaceConfig -> NamespaceConfig -> Bool
<= :: NamespaceConfig -> NamespaceConfig -> Bool
$c> :: NamespaceConfig -> NamespaceConfig -> Bool
> :: NamespaceConfig -> NamespaceConfig -> Bool
$c>= :: NamespaceConfig -> NamespaceConfig -> Bool
>= :: NamespaceConfig -> NamespaceConfig -> Bool
$cmax :: NamespaceConfig -> NamespaceConfig -> NamespaceConfig
max :: NamespaceConfig -> NamespaceConfig -> NamespaceConfig
$cmin :: NamespaceConfig -> NamespaceConfig -> NamespaceConfig
min :: NamespaceConfig -> NamespaceConfig -> NamespaceConfig
Ord)

namespaceConfigFromProto :: M.NamespaceConfig -> NamespaceConfig
namespaceConfigFromProto :: NamespaceConfig -> NamespaceConfig
namespaceConfigFromProto NamespaceConfig
x = NamespaceConfig
  { workflowExecutionRetentionTtl :: Maybe Duration
workflowExecutionRetentionTtl = Duration -> Duration
durationFromProto (Duration -> Duration) -> Maybe Duration -> Maybe Duration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NamespaceConfig
x NamespaceConfig
-> FoldLike
     (Maybe Duration)
     NamespaceConfig
     NamespaceConfig
     (Maybe Duration)
     (Maybe Duration)
-> Maybe Duration
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Maybe Duration)
  NamespaceConfig
  NamespaceConfig
  (Maybe Duration)
  (Maybe Duration)
forall (f :: * -> *) s a.
(Functor f, HasField s "maybe'workflowExecutionRetentionTtl" a) =>
LensLike' f s a
M.maybe'workflowExecutionRetentionTtl)
  , badBinaries :: Maybe BadBinaries
badBinaries = BadBinaries -> BadBinaries
badBinariesFromProto (BadBinaries -> BadBinaries)
-> Maybe BadBinaries -> Maybe BadBinaries
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NamespaceConfig
x NamespaceConfig
-> FoldLike
     (Maybe BadBinaries)
     NamespaceConfig
     NamespaceConfig
     (Maybe BadBinaries)
     (Maybe BadBinaries)
-> Maybe BadBinaries
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Maybe BadBinaries)
  NamespaceConfig
  NamespaceConfig
  (Maybe BadBinaries)
  (Maybe BadBinaries)
forall (f :: * -> *) s a.
(Functor f, HasField s "maybe'badBinaries" a) =>
LensLike' f s a
M.maybe'badBinaries)
  , historyArchivalState :: ArchivalState
historyArchivalState = ArchivalState -> ArchivalState
archivalStateFromProto (NamespaceConfig
x NamespaceConfig
-> FoldLike
     ArchivalState
     NamespaceConfig
     NamespaceConfig
     ArchivalState
     ArchivalState
-> ArchivalState
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  ArchivalState
  NamespaceConfig
  NamespaceConfig
  ArchivalState
  ArchivalState
forall (f :: * -> *) s a.
(Functor f, HasField s "historyArchivalState" a) =>
LensLike' f s a
M.historyArchivalState)
  , historyArchivalUri :: Text
historyArchivalUri = NamespaceConfig
x NamespaceConfig
-> FoldLike Text NamespaceConfig NamespaceConfig Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text NamespaceConfig NamespaceConfig Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "historyArchivalUri" a) =>
LensLike' f s a
M.historyArchivalUri
  , visibilityArchivalState :: ArchivalState
visibilityArchivalState = ArchivalState -> ArchivalState
archivalStateFromProto (NamespaceConfig
x NamespaceConfig
-> FoldLike
     ArchivalState
     NamespaceConfig
     NamespaceConfig
     ArchivalState
     ArchivalState
-> ArchivalState
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  ArchivalState
  NamespaceConfig
  NamespaceConfig
  ArchivalState
  ArchivalState
forall (f :: * -> *) s a.
(Functor f, HasField s "visibilityArchivalState" a) =>
LensLike' f s a
M.visibilityArchivalState)
  , visibilityArchivalUri :: Text
visibilityArchivalUri = NamespaceConfig
x NamespaceConfig
-> FoldLike Text NamespaceConfig NamespaceConfig Text Text -> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Text NamespaceConfig NamespaceConfig Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "visibilityArchivalUri" a) =>
LensLike' f s a
M.visibilityArchivalUri
  , customSearchAttributeAliases :: Map Text Text
customSearchAttributeAliases = NamespaceConfig
x NamespaceConfig
-> FoldLike
     (Map Text Text)
     NamespaceConfig
     NamespaceConfig
     (Map Text Text)
     (Map Text Text)
-> Map Text Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Map Text Text)
  NamespaceConfig
  NamespaceConfig
  (Map Text Text)
  (Map Text Text)
forall (f :: * -> *) s a.
(Functor f, HasField s "customSearchAttributeAliases" a) =>
LensLike' f s a
M.customSearchAttributeAliases
  }

data ReplicationState
  = ReplicationStateUnspecified
  | ReplicationStateNormal
  | ReplicationStateHandover
  | ReplicationStateUnrecognized
  deriving stock (Int -> ReplicationState -> ShowS
[ReplicationState] -> ShowS
ReplicationState -> String
(Int -> ReplicationState -> ShowS)
-> (ReplicationState -> String)
-> ([ReplicationState] -> ShowS)
-> Show ReplicationState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReplicationState -> ShowS
showsPrec :: Int -> ReplicationState -> ShowS
$cshow :: ReplicationState -> String
show :: ReplicationState -> String
$cshowList :: [ReplicationState] -> ShowS
showList :: [ReplicationState] -> ShowS
Show, ReplicationState -> ReplicationState -> Bool
(ReplicationState -> ReplicationState -> Bool)
-> (ReplicationState -> ReplicationState -> Bool)
-> Eq ReplicationState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReplicationState -> ReplicationState -> Bool
== :: ReplicationState -> ReplicationState -> Bool
$c/= :: ReplicationState -> ReplicationState -> Bool
/= :: ReplicationState -> ReplicationState -> Bool
Eq, Eq ReplicationState
Eq ReplicationState =>
(ReplicationState -> ReplicationState -> Ordering)
-> (ReplicationState -> ReplicationState -> Bool)
-> (ReplicationState -> ReplicationState -> Bool)
-> (ReplicationState -> ReplicationState -> Bool)
-> (ReplicationState -> ReplicationState -> Bool)
-> (ReplicationState -> ReplicationState -> ReplicationState)
-> (ReplicationState -> ReplicationState -> ReplicationState)
-> Ord ReplicationState
ReplicationState -> ReplicationState -> Bool
ReplicationState -> ReplicationState -> Ordering
ReplicationState -> ReplicationState -> ReplicationState
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ReplicationState -> ReplicationState -> Ordering
compare :: ReplicationState -> ReplicationState -> Ordering
$c< :: ReplicationState -> ReplicationState -> Bool
< :: ReplicationState -> ReplicationState -> Bool
$c<= :: ReplicationState -> ReplicationState -> Bool
<= :: ReplicationState -> ReplicationState -> Bool
$c> :: ReplicationState -> ReplicationState -> Bool
> :: ReplicationState -> ReplicationState -> Bool
$c>= :: ReplicationState -> ReplicationState -> Bool
>= :: ReplicationState -> ReplicationState -> Bool
$cmax :: ReplicationState -> ReplicationState -> ReplicationState
max :: ReplicationState -> ReplicationState -> ReplicationState
$cmin :: ReplicationState -> ReplicationState -> ReplicationState
min :: ReplicationState -> ReplicationState -> ReplicationState
Ord)

replicationStateFromProto :: M.ReplicationState -> ReplicationState
replicationStateFromProto :: ReplicationState -> ReplicationState
replicationStateFromProto = \case
  ReplicationState
M.REPLICATION_STATE_UNSPECIFIED -> ReplicationState
ReplicationStateUnspecified
  ReplicationState
M.REPLICATION_STATE_NORMAL -> ReplicationState
ReplicationStateNormal
  ReplicationState
M.REPLICATION_STATE_HANDOVER -> ReplicationState
ReplicationStateHandover
  (M.ReplicationState'Unrecognized ReplicationState'UnrecognizedValue
_) -> ReplicationState
ReplicationStateUnrecognized

data ClusterReplicationConfig = ClusterReplicationConfig
  { ClusterReplicationConfig -> Text
clusterName :: !Text
  } deriving stock (Int -> ClusterReplicationConfig -> ShowS
[ClusterReplicationConfig] -> ShowS
ClusterReplicationConfig -> String
(Int -> ClusterReplicationConfig -> ShowS)
-> (ClusterReplicationConfig -> String)
-> ([ClusterReplicationConfig] -> ShowS)
-> Show ClusterReplicationConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClusterReplicationConfig -> ShowS
showsPrec :: Int -> ClusterReplicationConfig -> ShowS
$cshow :: ClusterReplicationConfig -> String
show :: ClusterReplicationConfig -> String
$cshowList :: [ClusterReplicationConfig] -> ShowS
showList :: [ClusterReplicationConfig] -> ShowS
Show, ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
(ClusterReplicationConfig -> ClusterReplicationConfig -> Bool)
-> (ClusterReplicationConfig -> ClusterReplicationConfig -> Bool)
-> Eq ClusterReplicationConfig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
== :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
$c/= :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
/= :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
Eq, Eq ClusterReplicationConfig
Eq ClusterReplicationConfig =>
(ClusterReplicationConfig -> ClusterReplicationConfig -> Ordering)
-> (ClusterReplicationConfig -> ClusterReplicationConfig -> Bool)
-> (ClusterReplicationConfig -> ClusterReplicationConfig -> Bool)
-> (ClusterReplicationConfig -> ClusterReplicationConfig -> Bool)
-> (ClusterReplicationConfig -> ClusterReplicationConfig -> Bool)
-> (ClusterReplicationConfig
    -> ClusterReplicationConfig -> ClusterReplicationConfig)
-> (ClusterReplicationConfig
    -> ClusterReplicationConfig -> ClusterReplicationConfig)
-> Ord ClusterReplicationConfig
ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
ClusterReplicationConfig -> ClusterReplicationConfig -> Ordering
ClusterReplicationConfig
-> ClusterReplicationConfig -> ClusterReplicationConfig
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ClusterReplicationConfig -> ClusterReplicationConfig -> Ordering
compare :: ClusterReplicationConfig -> ClusterReplicationConfig -> Ordering
$c< :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
< :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
$c<= :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
<= :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
$c> :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
> :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
$c>= :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
>= :: ClusterReplicationConfig -> ClusterReplicationConfig -> Bool
$cmax :: ClusterReplicationConfig
-> ClusterReplicationConfig -> ClusterReplicationConfig
max :: ClusterReplicationConfig
-> ClusterReplicationConfig -> ClusterReplicationConfig
$cmin :: ClusterReplicationConfig
-> ClusterReplicationConfig -> ClusterReplicationConfig
min :: ClusterReplicationConfig
-> ClusterReplicationConfig -> ClusterReplicationConfig
Ord)

clusterReplicationConfigFromProto :: R.ClusterReplicationConfig -> ClusterReplicationConfig
clusterReplicationConfigFromProto :: ClusterReplicationConfig -> ClusterReplicationConfig
clusterReplicationConfigFromProto ClusterReplicationConfig
x = ClusterReplicationConfig
  { clusterName :: Text
clusterName = ClusterReplicationConfig
x ClusterReplicationConfig
-> FoldLike
     Text ClusterReplicationConfig ClusterReplicationConfig Text Text
-> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Text ClusterReplicationConfig ClusterReplicationConfig Text Text
forall (f :: * -> *) s a.
(Functor f, HasField s "clusterName" a) =>
LensLike' f s a
R.clusterName
  }

data NamespaceReplicationConfig = NamespaceReplicationConfig
  { NamespaceReplicationConfig -> Text
activeClusterName :: !Text
  , NamespaceReplicationConfig -> Vector ClusterReplicationConfig
clusters :: !(V.Vector ClusterReplicationConfig)
  , NamespaceReplicationConfig -> ReplicationState
state :: !ReplicationState
  } deriving stock (Int -> NamespaceReplicationConfig -> ShowS
[NamespaceReplicationConfig] -> ShowS
NamespaceReplicationConfig -> String
(Int -> NamespaceReplicationConfig -> ShowS)
-> (NamespaceReplicationConfig -> String)
-> ([NamespaceReplicationConfig] -> ShowS)
-> Show NamespaceReplicationConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NamespaceReplicationConfig -> ShowS
showsPrec :: Int -> NamespaceReplicationConfig -> ShowS
$cshow :: NamespaceReplicationConfig -> String
show :: NamespaceReplicationConfig -> String
$cshowList :: [NamespaceReplicationConfig] -> ShowS
showList :: [NamespaceReplicationConfig] -> ShowS
Show, NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
(NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool)
-> (NamespaceReplicationConfig
    -> NamespaceReplicationConfig -> Bool)
-> Eq NamespaceReplicationConfig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
== :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
$c/= :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
/= :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
Eq, Eq NamespaceReplicationConfig
Eq NamespaceReplicationConfig =>
(NamespaceReplicationConfig
 -> NamespaceReplicationConfig -> Ordering)
-> (NamespaceReplicationConfig
    -> NamespaceReplicationConfig -> Bool)
-> (NamespaceReplicationConfig
    -> NamespaceReplicationConfig -> Bool)
-> (NamespaceReplicationConfig
    -> NamespaceReplicationConfig -> Bool)
-> (NamespaceReplicationConfig
    -> NamespaceReplicationConfig -> Bool)
-> (NamespaceReplicationConfig
    -> NamespaceReplicationConfig -> NamespaceReplicationConfig)
-> (NamespaceReplicationConfig
    -> NamespaceReplicationConfig -> NamespaceReplicationConfig)
-> Ord NamespaceReplicationConfig
NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
NamespaceReplicationConfig
-> NamespaceReplicationConfig -> Ordering
NamespaceReplicationConfig
-> NamespaceReplicationConfig -> NamespaceReplicationConfig
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceReplicationConfig
-> NamespaceReplicationConfig -> Ordering
compare :: NamespaceReplicationConfig
-> NamespaceReplicationConfig -> Ordering
$c< :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
< :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
$c<= :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
<= :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
$c> :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
> :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
$c>= :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
>= :: NamespaceReplicationConfig -> NamespaceReplicationConfig -> Bool
$cmax :: NamespaceReplicationConfig
-> NamespaceReplicationConfig -> NamespaceReplicationConfig
max :: NamespaceReplicationConfig
-> NamespaceReplicationConfig -> NamespaceReplicationConfig
$cmin :: NamespaceReplicationConfig
-> NamespaceReplicationConfig -> NamespaceReplicationConfig
min :: NamespaceReplicationConfig
-> NamespaceReplicationConfig -> NamespaceReplicationConfig
Ord)

namespaceReplicationConfigFromProto :: R.NamespaceReplicationConfig -> NamespaceReplicationConfig
namespaceReplicationConfigFromProto :: NamespaceReplicationConfig -> NamespaceReplicationConfig
namespaceReplicationConfigFromProto NamespaceReplicationConfig
x = NamespaceReplicationConfig
  { activeClusterName :: Text
activeClusterName = NamespaceReplicationConfig
x NamespaceReplicationConfig
-> FoldLike
     Text
     NamespaceReplicationConfig
     NamespaceReplicationConfig
     Text
     Text
-> Text
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Text
  NamespaceReplicationConfig
  NamespaceReplicationConfig
  Text
  Text
forall (f :: * -> *) s a.
(Functor f, HasField s "activeClusterName" a) =>
LensLike' f s a
R.activeClusterName
  , clusters :: Vector ClusterReplicationConfig
clusters = ClusterReplicationConfig -> ClusterReplicationConfig
clusterReplicationConfigFromProto (ClusterReplicationConfig -> ClusterReplicationConfig)
-> Vector ClusterReplicationConfig
-> Vector ClusterReplicationConfig
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NamespaceReplicationConfig
x NamespaceReplicationConfig
-> FoldLike
     (Vector ClusterReplicationConfig)
     NamespaceReplicationConfig
     NamespaceReplicationConfig
     (Vector ClusterReplicationConfig)
     (Vector ClusterReplicationConfig)
-> Vector ClusterReplicationConfig
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Vector ClusterReplicationConfig)
  NamespaceReplicationConfig
  NamespaceReplicationConfig
  (Vector ClusterReplicationConfig)
  (Vector ClusterReplicationConfig)
forall (f :: * -> *) s a.
(Functor f, HasField s "vec'clusters" a) =>
LensLike' f s a
R.vec'clusters)
  , state :: ReplicationState
state = ReplicationState -> ReplicationState
replicationStateFromProto (NamespaceReplicationConfig
x NamespaceReplicationConfig
-> FoldLike
     ReplicationState
     NamespaceReplicationConfig
     NamespaceReplicationConfig
     ReplicationState
     ReplicationState
-> ReplicationState
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  ReplicationState
  NamespaceReplicationConfig
  NamespaceReplicationConfig
  ReplicationState
  ReplicationState
forall (f :: * -> *) s a.
(Functor f, HasField s "state" a) =>
LensLike' f s a
M.state)
  }

data FailoverStatus = FailoverStatus
  { FailoverStatus -> SystemTime
failoverTime :: !SystemTime
  , FailoverStatus -> Int64
failoverVersion :: !Int64
  } deriving stock (Int -> FailoverStatus -> ShowS
[FailoverStatus] -> ShowS
FailoverStatus -> String
(Int -> FailoverStatus -> ShowS)
-> (FailoverStatus -> String)
-> ([FailoverStatus] -> ShowS)
-> Show FailoverStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FailoverStatus -> ShowS
showsPrec :: Int -> FailoverStatus -> ShowS
$cshow :: FailoverStatus -> String
show :: FailoverStatus -> String
$cshowList :: [FailoverStatus] -> ShowS
showList :: [FailoverStatus] -> ShowS
Show, FailoverStatus -> FailoverStatus -> Bool
(FailoverStatus -> FailoverStatus -> Bool)
-> (FailoverStatus -> FailoverStatus -> Bool) -> Eq FailoverStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FailoverStatus -> FailoverStatus -> Bool
== :: FailoverStatus -> FailoverStatus -> Bool
$c/= :: FailoverStatus -> FailoverStatus -> Bool
/= :: FailoverStatus -> FailoverStatus -> Bool
Eq, Eq FailoverStatus
Eq FailoverStatus =>
(FailoverStatus -> FailoverStatus -> Ordering)
-> (FailoverStatus -> FailoverStatus -> Bool)
-> (FailoverStatus -> FailoverStatus -> Bool)
-> (FailoverStatus -> FailoverStatus -> Bool)
-> (FailoverStatus -> FailoverStatus -> Bool)
-> (FailoverStatus -> FailoverStatus -> FailoverStatus)
-> (FailoverStatus -> FailoverStatus -> FailoverStatus)
-> Ord FailoverStatus
FailoverStatus -> FailoverStatus -> Bool
FailoverStatus -> FailoverStatus -> Ordering
FailoverStatus -> FailoverStatus -> FailoverStatus
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FailoverStatus -> FailoverStatus -> Ordering
compare :: FailoverStatus -> FailoverStatus -> Ordering
$c< :: FailoverStatus -> FailoverStatus -> Bool
< :: FailoverStatus -> FailoverStatus -> Bool
$c<= :: FailoverStatus -> FailoverStatus -> Bool
<= :: FailoverStatus -> FailoverStatus -> Bool
$c> :: FailoverStatus -> FailoverStatus -> Bool
> :: FailoverStatus -> FailoverStatus -> Bool
$c>= :: FailoverStatus -> FailoverStatus -> Bool
>= :: FailoverStatus -> FailoverStatus -> Bool
$cmax :: FailoverStatus -> FailoverStatus -> FailoverStatus
max :: FailoverStatus -> FailoverStatus -> FailoverStatus
$cmin :: FailoverStatus -> FailoverStatus -> FailoverStatus
min :: FailoverStatus -> FailoverStatus -> FailoverStatus
Ord)

failoverStatusFromProto :: R.FailoverStatus -> FailoverStatus
failoverStatusFromProto :: FailoverStatus -> FailoverStatus
failoverStatusFromProto FailoverStatus
x = FailoverStatus
  { failoverTime :: SystemTime
failoverTime = Timestamp -> SystemTime
timespecFromTimestamp (FailoverStatus
x FailoverStatus
-> FoldLike
     Timestamp FailoverStatus FailoverStatus Timestamp Timestamp
-> Timestamp
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Timestamp FailoverStatus FailoverStatus Timestamp Timestamp
forall (f :: * -> *) s a.
(Functor f, HasField s "failoverTime" a) =>
LensLike' f s a
R.failoverTime)
  , failoverVersion :: Int64
failoverVersion = FailoverStatus
x FailoverStatus
-> FoldLike Int64 FailoverStatus FailoverStatus Int64 Int64
-> Int64
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike Int64 FailoverStatus FailoverStatus Int64 Int64
forall (f :: * -> *) s a.
(Functor f, HasField s "failoverVersion" a) =>
LensLike' f s a
R.failoverVersion
  }

data DescribeNamespaceResponse = DescribeNamespaceResponse
  { DescribeNamespaceResponse -> NamespaceInfo
namespaceInfo :: !NamespaceInfo
  , DescribeNamespaceResponse -> NamespaceConfig
config :: !NamespaceConfig
  , DescribeNamespaceResponse -> NamespaceReplicationConfig
replicationConfig :: !NamespaceReplicationConfig
  , DescribeNamespaceResponse -> Int64
failoverVersion :: !Int64
  , DescribeNamespaceResponse -> Bool
isGlobalNamespace :: !Bool
  , DescribeNamespaceResponse -> Vector FailoverStatus
failoverHistory :: !(V.Vector FailoverStatus)
  } deriving stock (Int -> DescribeNamespaceResponse -> ShowS
[DescribeNamespaceResponse] -> ShowS
DescribeNamespaceResponse -> String
(Int -> DescribeNamespaceResponse -> ShowS)
-> (DescribeNamespaceResponse -> String)
-> ([DescribeNamespaceResponse] -> ShowS)
-> Show DescribeNamespaceResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DescribeNamespaceResponse -> ShowS
showsPrec :: Int -> DescribeNamespaceResponse -> ShowS
$cshow :: DescribeNamespaceResponse -> String
show :: DescribeNamespaceResponse -> String
$cshowList :: [DescribeNamespaceResponse] -> ShowS
showList :: [DescribeNamespaceResponse] -> ShowS
Show, DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
(DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool)
-> (DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool)
-> Eq DescribeNamespaceResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
== :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
$c/= :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
/= :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
Eq, Eq DescribeNamespaceResponse
Eq DescribeNamespaceResponse =>
(DescribeNamespaceResponse
 -> DescribeNamespaceResponse -> Ordering)
-> (DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool)
-> (DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool)
-> (DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool)
-> (DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool)
-> (DescribeNamespaceResponse
    -> DescribeNamespaceResponse -> DescribeNamespaceResponse)
-> (DescribeNamespaceResponse
    -> DescribeNamespaceResponse -> DescribeNamespaceResponse)
-> Ord DescribeNamespaceResponse
DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
DescribeNamespaceResponse -> DescribeNamespaceResponse -> Ordering
DescribeNamespaceResponse
-> DescribeNamespaceResponse -> DescribeNamespaceResponse
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Ordering
compare :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Ordering
$c< :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
< :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
$c<= :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
<= :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
$c> :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
> :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
$c>= :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
>= :: DescribeNamespaceResponse -> DescribeNamespaceResponse -> Bool
$cmax :: DescribeNamespaceResponse
-> DescribeNamespaceResponse -> DescribeNamespaceResponse
max :: DescribeNamespaceResponse
-> DescribeNamespaceResponse -> DescribeNamespaceResponse
$cmin :: DescribeNamespaceResponse
-> DescribeNamespaceResponse -> DescribeNamespaceResponse
min :: DescribeNamespaceResponse
-> DescribeNamespaceResponse -> DescribeNamespaceResponse
Ord)

describeNamespaceResponseFromProto :: RR.DescribeNamespaceResponse -> DescribeNamespaceResponse
describeNamespaceResponseFromProto :: DescribeNamespaceResponse -> DescribeNamespaceResponse
describeNamespaceResponseFromProto DescribeNamespaceResponse
x = DescribeNamespaceResponse
  { namespaceInfo :: NamespaceInfo
namespaceInfo = NamespaceInfo -> NamespaceInfo
namespaceInfoFromProto (DescribeNamespaceResponse
x DescribeNamespaceResponse
-> FoldLike
     NamespaceInfo
     DescribeNamespaceResponse
     DescribeNamespaceResponse
     NamespaceInfo
     NamespaceInfo
-> NamespaceInfo
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  NamespaceInfo
  DescribeNamespaceResponse
  DescribeNamespaceResponse
  NamespaceInfo
  NamespaceInfo
forall (f :: * -> *) s a.
(Functor f, HasField s "namespaceInfo" a) =>
LensLike' f s a
RR.namespaceInfo)
  , config :: NamespaceConfig
config = NamespaceConfig -> NamespaceConfig
namespaceConfigFromProto (DescribeNamespaceResponse
x DescribeNamespaceResponse
-> FoldLike
     NamespaceConfig
     DescribeNamespaceResponse
     DescribeNamespaceResponse
     NamespaceConfig
     NamespaceConfig
-> NamespaceConfig
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  NamespaceConfig
  DescribeNamespaceResponse
  DescribeNamespaceResponse
  NamespaceConfig
  NamespaceConfig
forall (f :: * -> *) s a.
(Functor f, HasField s "config" a) =>
LensLike' f s a
RR.config)
  , replicationConfig :: NamespaceReplicationConfig
replicationConfig = NamespaceReplicationConfig -> NamespaceReplicationConfig
namespaceReplicationConfigFromProto (DescribeNamespaceResponse
x DescribeNamespaceResponse
-> FoldLike
     NamespaceReplicationConfig
     DescribeNamespaceResponse
     DescribeNamespaceResponse
     NamespaceReplicationConfig
     NamespaceReplicationConfig
-> NamespaceReplicationConfig
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  NamespaceReplicationConfig
  DescribeNamespaceResponse
  DescribeNamespaceResponse
  NamespaceReplicationConfig
  NamespaceReplicationConfig
forall (f :: * -> *) s a.
(Functor f, HasField s "replicationConfig" a) =>
LensLike' f s a
RR.replicationConfig)
  , failoverVersion :: Int64
failoverVersion = DescribeNamespaceResponse
x DescribeNamespaceResponse
-> FoldLike
     Int64
     DescribeNamespaceResponse
     DescribeNamespaceResponse
     Int64
     Int64
-> Int64
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Int64
  DescribeNamespaceResponse
  DescribeNamespaceResponse
  Int64
  Int64
forall (f :: * -> *) s a.
(Functor f, HasField s "failoverVersion" a) =>
LensLike' f s a
RR.failoverVersion
  , isGlobalNamespace :: Bool
isGlobalNamespace = DescribeNamespaceResponse
x DescribeNamespaceResponse
-> FoldLike
     Bool DescribeNamespaceResponse DescribeNamespaceResponse Bool Bool
-> Bool
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  Bool DescribeNamespaceResponse DescribeNamespaceResponse Bool Bool
forall (f :: * -> *) s a.
(Functor f, HasField s "isGlobalNamespace" a) =>
LensLike' f s a
RR.isGlobalNamespace
  , failoverHistory :: Vector FailoverStatus
failoverHistory = FailoverStatus -> FailoverStatus
failoverStatusFromProto (FailoverStatus -> FailoverStatus)
-> Vector FailoverStatus -> Vector FailoverStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DescribeNamespaceResponse
x DescribeNamespaceResponse
-> FoldLike
     (Vector FailoverStatus)
     DescribeNamespaceResponse
     DescribeNamespaceResponse
     (Vector FailoverStatus)
     (Vector FailoverStatus)
-> Vector FailoverStatus
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Vector FailoverStatus)
  DescribeNamespaceResponse
  DescribeNamespaceResponse
  (Vector FailoverStatus)
  (Vector FailoverStatus)
forall (f :: * -> *) s a.
(Functor f, HasField s "vec'failoverHistory" a) =>
LensLike' f s a
RR.vec'failoverHistory)
  }

data ListNamespacesRequest = ListNamespacesRequest
  { ListNamespacesRequest -> Maybe NamespaceFilter
filter :: !(Maybe NamespaceFilter)
  , ListNamespacesRequest -> Int32
pageSize :: !Int32
  } deriving stock (Int -> ListNamespacesRequest -> ShowS
[ListNamespacesRequest] -> ShowS
ListNamespacesRequest -> String
(Int -> ListNamespacesRequest -> ShowS)
-> (ListNamespacesRequest -> String)
-> ([ListNamespacesRequest] -> ShowS)
-> Show ListNamespacesRequest
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListNamespacesRequest -> ShowS
showsPrec :: Int -> ListNamespacesRequest -> ShowS
$cshow :: ListNamespacesRequest -> String
show :: ListNamespacesRequest -> String
$cshowList :: [ListNamespacesRequest] -> ShowS
showList :: [ListNamespacesRequest] -> ShowS
Show, ListNamespacesRequest -> ListNamespacesRequest -> Bool
(ListNamespacesRequest -> ListNamespacesRequest -> Bool)
-> (ListNamespacesRequest -> ListNamespacesRequest -> Bool)
-> Eq ListNamespacesRequest
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
== :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
$c/= :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
/= :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
Eq, Eq ListNamespacesRequest
Eq ListNamespacesRequest =>
(ListNamespacesRequest -> ListNamespacesRequest -> Ordering)
-> (ListNamespacesRequest -> ListNamespacesRequest -> Bool)
-> (ListNamespacesRequest -> ListNamespacesRequest -> Bool)
-> (ListNamespacesRequest -> ListNamespacesRequest -> Bool)
-> (ListNamespacesRequest -> ListNamespacesRequest -> Bool)
-> (ListNamespacesRequest
    -> ListNamespacesRequest -> ListNamespacesRequest)
-> (ListNamespacesRequest
    -> ListNamespacesRequest -> ListNamespacesRequest)
-> Ord ListNamespacesRequest
ListNamespacesRequest -> ListNamespacesRequest -> Bool
ListNamespacesRequest -> ListNamespacesRequest -> Ordering
ListNamespacesRequest
-> ListNamespacesRequest -> ListNamespacesRequest
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListNamespacesRequest -> ListNamespacesRequest -> Ordering
compare :: ListNamespacesRequest -> ListNamespacesRequest -> Ordering
$c< :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
< :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
$c<= :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
<= :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
$c> :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
> :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
$c>= :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
>= :: ListNamespacesRequest -> ListNamespacesRequest -> Bool
$cmax :: ListNamespacesRequest
-> ListNamespacesRequest -> ListNamespacesRequest
max :: ListNamespacesRequest
-> ListNamespacesRequest -> ListNamespacesRequest
$cmin :: ListNamespacesRequest
-> ListNamespacesRequest -> ListNamespacesRequest
min :: ListNamespacesRequest
-> ListNamespacesRequest -> ListNamespacesRequest
Ord)

listNamespacesRequestToProto :: ListNamespacesRequest -> RR.ListNamespacesRequest
listNamespacesRequestToProto :: ListNamespacesRequest -> ListNamespacesRequest
listNamespacesRequestToProto ListNamespacesRequest{Int32
Maybe NamespaceFilter
filter :: ListNamespacesRequest -> Maybe NamespaceFilter
pageSize :: ListNamespacesRequest -> Int32
filter :: Maybe NamespaceFilter
pageSize :: Int32
..} = ListNamespacesRequest
forall msg. Message msg => msg
defMessage
  ListNamespacesRequest
-> (ListNamespacesRequest -> ListNamespacesRequest)
-> ListNamespacesRequest
forall s t. s -> (s -> t) -> t
& LensLike' f ListNamespacesRequest (Maybe NamespaceFilter)
forall {f :: * -> *}.
Identical f =>
LensLike' f ListNamespacesRequest (Maybe NamespaceFilter)
forall (f :: * -> *) s a.
(Functor f, HasField s "maybe'namespaceFilter" a) =>
LensLike' f s a
RR.maybe'namespaceFilter (forall {f :: * -> *}.
 Identical f =>
 LensLike' f ListNamespacesRequest (Maybe NamespaceFilter))
-> Maybe NamespaceFilter
-> ListNamespacesRequest
-> ListNamespacesRequest
forall s t a b. Setter s t a b -> b -> s -> t
.~ (NamespaceFilter -> NamespaceFilter
namespaceFilterToProto (NamespaceFilter -> NamespaceFilter)
-> Maybe NamespaceFilter -> Maybe NamespaceFilter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe NamespaceFilter
filter)
  ListNamespacesRequest
-> (ListNamespacesRequest -> ListNamespacesRequest)
-> ListNamespacesRequest
forall s t. s -> (s -> t) -> t
& LensLike' f ListNamespacesRequest Int32
forall {f :: * -> *}.
Identical f =>
LensLike' f ListNamespacesRequest Int32
forall (f :: * -> *) s a.
(Functor f, HasField s "pageSize" a) =>
LensLike' f s a
RR.pageSize (forall {f :: * -> *}.
 Identical f =>
 LensLike' f ListNamespacesRequest Int32)
-> Int32 -> ListNamespacesRequest -> ListNamespacesRequest
forall s t a b. Setter s t a b -> b -> s -> t
.~ Int32
pageSize

-- | Returns the information and configuration for all namespaces.
listNamespaces :: (MonadIO m, HasWorkflowClient m) => ListNamespacesRequest -> ConduitT () DescribeNamespaceResponse m ()
listNamespaces :: forall (m :: * -> *).
(MonadIO m, HasWorkflowClient m) =>
ListNamespacesRequest -> ConduitT () DescribeNamespaceResponse m ()
listNamespaces ListNamespacesRequest
req = do
  client <- ConduitT () DescribeNamespaceResponse m WorkflowClient
forall (m :: * -> *). HasWorkflowClient m => m WorkflowClient
askWorkflowClient
  let go ListNamespacesRequest
reqMsg = do
        res <- IO (Either RpcError ListNamespacesResponse)
-> ConduitT
     ()
     DescribeNamespaceResponse
     m
     (Either RpcError ListNamespacesResponse)
forall a. IO a -> ConduitT () DescribeNamespaceResponse m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Either RpcError ListNamespacesResponse)
 -> ConduitT
      ()
      DescribeNamespaceResponse
      m
      (Either RpcError ListNamespacesResponse))
-> IO (Either RpcError ListNamespacesResponse)
-> ConduitT
     ()
     DescribeNamespaceResponse
     m
     (Either RpcError ListNamespacesResponse)
forall a b. (a -> b) -> a -> b
$ Client
-> ListNamespacesRequest
-> IO (Either RpcError ListNamespacesResponse)
Temporal.Core.Client.WorkflowService.listNamespaces WorkflowClient
client.clientCore ListNamespacesRequest
reqMsg
        case res of
          Left RpcError
err -> RpcError -> ConduitT () DescribeNamespaceResponse m ()
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO RpcError
err
          Right ListNamespacesResponse
x -> do
            let namespaces :: Vector DescribeNamespaceResponse
namespaces = ListNamespacesResponse
x ListNamespacesResponse
-> FoldLike
     (Vector DescribeNamespaceResponse)
     ListNamespacesResponse
     ListNamespacesResponse
     (Vector DescribeNamespaceResponse)
     (Vector DescribeNamespaceResponse)
-> Vector DescribeNamespaceResponse
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Vector DescribeNamespaceResponse)
  ListNamespacesResponse
  ListNamespacesResponse
  (Vector DescribeNamespaceResponse)
  (Vector DescribeNamespaceResponse)
forall (f :: * -> *) s a.
(Functor f, HasField s "vec'namespaces" a) =>
LensLike' f s a
RR.vec'namespaces
            Vector DescribeNamespaceResponse
-> ConduitT () (Element (Vector DescribeNamespaceResponse)) m ()
forall (m :: * -> *) mono i.
(Monad m, MonoFoldable mono) =>
mono -> ConduitT i (Element mono) m ()
yieldMany (Vector DescribeNamespaceResponse
 -> ConduitT () (Element (Vector DescribeNamespaceResponse)) m ())
-> Vector DescribeNamespaceResponse
-> ConduitT () (Element (Vector DescribeNamespaceResponse)) m ()
forall a b. (a -> b) -> a -> b
$ DescribeNamespaceResponse -> DescribeNamespaceResponse
describeNamespaceResponseFromProto (DescribeNamespaceResponse -> DescribeNamespaceResponse)
-> Vector DescribeNamespaceResponse
-> Vector DescribeNamespaceResponse
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Vector DescribeNamespaceResponse
namespaces
            Bool
-> ConduitT () DescribeNamespaceResponse m ()
-> ConduitT () DescribeNamespaceResponse m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ByteString -> Bool
BS.null (ListNamespacesResponse
x ListNamespacesResponse
-> FoldLike
     ByteString
     ListNamespacesResponse
     ListNamespacesResponse
     ByteString
     ByteString
-> ByteString
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  ByteString
  ListNamespacesResponse
  ListNamespacesResponse
  ByteString
  ByteString
forall (f :: * -> *) s a.
(Functor f, HasField s "nextPageToken" a) =>
LensLike' f s a
RR.nextPageToken) Bool -> Bool -> Bool
|| Vector DescribeNamespaceResponse -> Bool
forall a. Vector a -> Bool
V.null (ListNamespacesResponse
x ListNamespacesResponse
-> FoldLike
     (Vector DescribeNamespaceResponse)
     ListNamespacesResponse
     ListNamespacesResponse
     (Vector DescribeNamespaceResponse)
     (Vector DescribeNamespaceResponse)
-> Vector DescribeNamespaceResponse
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  (Vector DescribeNamespaceResponse)
  ListNamespacesResponse
  ListNamespacesResponse
  (Vector DescribeNamespaceResponse)
  (Vector DescribeNamespaceResponse)
forall (f :: * -> *) s a.
(Functor f, HasField s "vec'namespaces" a) =>
LensLike' f s a
RR.vec'namespaces)) do
              let reqMsg' :: ListNamespacesRequest
reqMsg' = ListNamespacesRequest
forall msg. Message msg => msg
defMessage
                    ListNamespacesRequest
-> (ListNamespacesRequest -> ListNamespacesRequest)
-> ListNamespacesRequest
forall s t. s -> (s -> t) -> t
& LensLike' f ListNamespacesRequest ByteString
forall {f :: * -> *}.
Identical f =>
LensLike' f ListNamespacesRequest ByteString
forall (f :: * -> *) s a.
(Functor f, HasField s "nextPageToken" a) =>
LensLike' f s a
RR.nextPageToken (forall {f :: * -> *}.
 Identical f =>
 LensLike' f ListNamespacesRequest ByteString)
-> ByteString -> ListNamespacesRequest -> ListNamespacesRequest
forall s t a b. Setter s t a b -> b -> s -> t
.~ (ListNamespacesResponse
x ListNamespacesResponse
-> FoldLike
     ByteString
     ListNamespacesResponse
     ListNamespacesResponse
     ByteString
     ByteString
-> ByteString
forall s a t b. s -> FoldLike a s t a b -> a
^. FoldLike
  ByteString
  ListNamespacesResponse
  ListNamespacesResponse
  ByteString
  ByteString
forall (f :: * -> *) s a.
(Functor f, HasField s "nextPageToken" a) =>
LensLike' f s a
RR.nextPageToken)
              ListNamespacesRequest -> ConduitT () DescribeNamespaceResponse m ()
go ListNamespacesRequest
reqMsg'
  go $ listNamespacesRequestToProto req