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

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

-- |
-- Module      : Amazonka.FSx.AssociateFileSystemAliases
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Use this action to associate one or more Domain Name Server (DNS)
-- aliases with an existing Amazon FSx for Windows File Server file system.
-- A file system can have a maximum of 50 DNS aliases associated with it at
-- any one time. If you try to associate a DNS alias that is already
-- associated with the file system, FSx takes no action on that alias in
-- the request. For more information, see
-- <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/managing-dns-aliases.html Working with DNS Aliases>
-- and
-- <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/walkthrough05-file-system-custom-CNAME.html Walkthrough 5: Using DNS aliases to access your file system>,
-- including additional steps you must take to be able to access your file
-- system using a DNS alias.
--
-- The system response shows the DNS aliases that Amazon FSx is attempting
-- to associate with the file system. Use the API operation to monitor the
-- status of the aliases Amazon FSx is associating with the file system.
module Amazonka.FSx.AssociateFileSystemAliases
  ( -- * Creating a Request
    AssociateFileSystemAliases (..),
    newAssociateFileSystemAliases,

    -- * Request Lenses
    associateFileSystemAliases_clientRequestToken,
    associateFileSystemAliases_fileSystemId,
    associateFileSystemAliases_aliases,

    -- * Destructuring the Response
    AssociateFileSystemAliasesResponse (..),
    newAssociateFileSystemAliasesResponse,

    -- * Response Lenses
    associateFileSystemAliasesResponse_aliases,
    associateFileSystemAliasesResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.FSx.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | The request object specifying one or more DNS alias names to associate
-- with an Amazon FSx for Windows File Server file system.
--
-- /See:/ 'newAssociateFileSystemAliases' smart constructor.
data AssociateFileSystemAliases = AssociateFileSystemAliases'
  { AssociateFileSystemAliases -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | Specifies the file system with which you want to associate one or more
    -- DNS aliases.
    AssociateFileSystemAliases -> Text
fileSystemId :: Prelude.Text,
    -- | An array of one or more DNS alias names to associate with the file
    -- system. The alias name has to comply with the following formatting
    -- requirements:
    --
    -- -   Formatted as a fully-qualified domain name (FQDN),
    --     /@hostname.domain@/ , for example, @accounting.corp.example.com@.
    --
    -- -   Can contain alphanumeric characters and the hyphen (-).
    --
    -- -   Cannot start or end with a hyphen.
    --
    -- -   Can start with a numeric.
    --
    -- For DNS alias names, Amazon FSx stores alphabetic characters as
    -- lowercase letters (a-z), regardless of how you specify them: as
    -- uppercase letters, lowercase letters, or the corresponding letters in
    -- escape codes.
    AssociateFileSystemAliases -> [Text]
aliases :: [Prelude.Text]
  }
  deriving (AssociateFileSystemAliases -> AssociateFileSystemAliases -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssociateFileSystemAliases -> AssociateFileSystemAliases -> Bool
$c/= :: AssociateFileSystemAliases -> AssociateFileSystemAliases -> Bool
== :: AssociateFileSystemAliases -> AssociateFileSystemAliases -> Bool
$c== :: AssociateFileSystemAliases -> AssociateFileSystemAliases -> Bool
Prelude.Eq, ReadPrec [AssociateFileSystemAliases]
ReadPrec AssociateFileSystemAliases
Int -> ReadS AssociateFileSystemAliases
ReadS [AssociateFileSystemAliases]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssociateFileSystemAliases]
$creadListPrec :: ReadPrec [AssociateFileSystemAliases]
readPrec :: ReadPrec AssociateFileSystemAliases
$creadPrec :: ReadPrec AssociateFileSystemAliases
readList :: ReadS [AssociateFileSystemAliases]
$creadList :: ReadS [AssociateFileSystemAliases]
readsPrec :: Int -> ReadS AssociateFileSystemAliases
$creadsPrec :: Int -> ReadS AssociateFileSystemAliases
Prelude.Read, Int -> AssociateFileSystemAliases -> ShowS
[AssociateFileSystemAliases] -> ShowS
AssociateFileSystemAliases -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssociateFileSystemAliases] -> ShowS
$cshowList :: [AssociateFileSystemAliases] -> ShowS
show :: AssociateFileSystemAliases -> String
$cshow :: AssociateFileSystemAliases -> String
showsPrec :: Int -> AssociateFileSystemAliases -> ShowS
$cshowsPrec :: Int -> AssociateFileSystemAliases -> ShowS
Prelude.Show, forall x.
Rep AssociateFileSystemAliases x -> AssociateFileSystemAliases
forall x.
AssociateFileSystemAliases -> Rep AssociateFileSystemAliases x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AssociateFileSystemAliases x -> AssociateFileSystemAliases
$cfrom :: forall x.
AssociateFileSystemAliases -> Rep AssociateFileSystemAliases x
Prelude.Generic)

-- |
-- Create a value of 'AssociateFileSystemAliases' 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:
--
-- 'clientRequestToken', 'associateFileSystemAliases_clientRequestToken' - Undocumented member.
--
-- 'fileSystemId', 'associateFileSystemAliases_fileSystemId' - Specifies the file system with which you want to associate one or more
-- DNS aliases.
--
-- 'aliases', 'associateFileSystemAliases_aliases' - An array of one or more DNS alias names to associate with the file
-- system. The alias name has to comply with the following formatting
-- requirements:
--
-- -   Formatted as a fully-qualified domain name (FQDN),
--     /@hostname.domain@/ , for example, @accounting.corp.example.com@.
--
-- -   Can contain alphanumeric characters and the hyphen (-).
--
-- -   Cannot start or end with a hyphen.
--
-- -   Can start with a numeric.
--
-- For DNS alias names, Amazon FSx stores alphabetic characters as
-- lowercase letters (a-z), regardless of how you specify them: as
-- uppercase letters, lowercase letters, or the corresponding letters in
-- escape codes.
newAssociateFileSystemAliases ::
  -- | 'fileSystemId'
  Prelude.Text ->
  AssociateFileSystemAliases
newAssociateFileSystemAliases :: Text -> AssociateFileSystemAliases
newAssociateFileSystemAliases Text
pFileSystemId_ =
  AssociateFileSystemAliases'
    { $sel:clientRequestToken:AssociateFileSystemAliases' :: Maybe Text
clientRequestToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:fileSystemId:AssociateFileSystemAliases' :: Text
fileSystemId = Text
pFileSystemId_,
      $sel:aliases:AssociateFileSystemAliases' :: [Text]
aliases = forall a. Monoid a => a
Prelude.mempty
    }

-- | Undocumented member.
associateFileSystemAliases_clientRequestToken :: Lens.Lens' AssociateFileSystemAliases (Prelude.Maybe Prelude.Text)
associateFileSystemAliases_clientRequestToken :: Lens' AssociateFileSystemAliases (Maybe Text)
associateFileSystemAliases_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateFileSystemAliases' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: AssociateFileSystemAliases
s@AssociateFileSystemAliases' {} Maybe Text
a -> AssociateFileSystemAliases
s {$sel:clientRequestToken:AssociateFileSystemAliases' :: Maybe Text
clientRequestToken = Maybe Text
a} :: AssociateFileSystemAliases)

-- | Specifies the file system with which you want to associate one or more
-- DNS aliases.
associateFileSystemAliases_fileSystemId :: Lens.Lens' AssociateFileSystemAliases Prelude.Text
associateFileSystemAliases_fileSystemId :: Lens' AssociateFileSystemAliases Text
associateFileSystemAliases_fileSystemId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateFileSystemAliases' {Text
fileSystemId :: Text
$sel:fileSystemId:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Text
fileSystemId} -> Text
fileSystemId) (\s :: AssociateFileSystemAliases
s@AssociateFileSystemAliases' {} Text
a -> AssociateFileSystemAliases
s {$sel:fileSystemId:AssociateFileSystemAliases' :: Text
fileSystemId = Text
a} :: AssociateFileSystemAliases)

-- | An array of one or more DNS alias names to associate with the file
-- system. The alias name has to comply with the following formatting
-- requirements:
--
-- -   Formatted as a fully-qualified domain name (FQDN),
--     /@hostname.domain@/ , for example, @accounting.corp.example.com@.
--
-- -   Can contain alphanumeric characters and the hyphen (-).
--
-- -   Cannot start or end with a hyphen.
--
-- -   Can start with a numeric.
--
-- For DNS alias names, Amazon FSx stores alphabetic characters as
-- lowercase letters (a-z), regardless of how you specify them: as
-- uppercase letters, lowercase letters, or the corresponding letters in
-- escape codes.
associateFileSystemAliases_aliases :: Lens.Lens' AssociateFileSystemAliases [Prelude.Text]
associateFileSystemAliases_aliases :: Lens' AssociateFileSystemAliases [Text]
associateFileSystemAliases_aliases = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateFileSystemAliases' {[Text]
aliases :: [Text]
$sel:aliases:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> [Text]
aliases} -> [Text]
aliases) (\s :: AssociateFileSystemAliases
s@AssociateFileSystemAliases' {} [Text]
a -> AssociateFileSystemAliases
s {$sel:aliases:AssociateFileSystemAliases' :: [Text]
aliases = [Text]
a} :: AssociateFileSystemAliases) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest AssociateFileSystemAliases where
  type
    AWSResponse AssociateFileSystemAliases =
      AssociateFileSystemAliasesResponse
  request :: (Service -> Service)
-> AssociateFileSystemAliases -> Request AssociateFileSystemAliases
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy AssociateFileSystemAliases
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse AssociateFileSystemAliases)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe [Alias] -> Int -> AssociateFileSystemAliasesResponse
AssociateFileSystemAliasesResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Aliases" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable AssociateFileSystemAliases where
  hashWithSalt :: Int -> AssociateFileSystemAliases -> Int
hashWithSalt Int
_salt AssociateFileSystemAliases' {[Text]
Maybe Text
Text
aliases :: [Text]
fileSystemId :: Text
clientRequestToken :: Maybe Text
$sel:aliases:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> [Text]
$sel:fileSystemId:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Text
$sel:clientRequestToken:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
fileSystemId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
aliases

instance Prelude.NFData AssociateFileSystemAliases where
  rnf :: AssociateFileSystemAliases -> ()
rnf AssociateFileSystemAliases' {[Text]
Maybe Text
Text
aliases :: [Text]
fileSystemId :: Text
clientRequestToken :: Maybe Text
$sel:aliases:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> [Text]
$sel:fileSystemId:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Text
$sel:clientRequestToken:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
fileSystemId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
aliases

instance Data.ToHeaders AssociateFileSystemAliases where
  toHeaders :: AssociateFileSystemAliases -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AWSSimbaAPIService_v20180301.AssociateFileSystemAliases" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON AssociateFileSystemAliases where
  toJSON :: AssociateFileSystemAliases -> Value
toJSON AssociateFileSystemAliases' {[Text]
Maybe Text
Text
aliases :: [Text]
fileSystemId :: Text
clientRequestToken :: Maybe Text
$sel:aliases:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> [Text]
$sel:fileSystemId:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Text
$sel:clientRequestToken:AssociateFileSystemAliases' :: AssociateFileSystemAliases -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientRequestToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
clientRequestToken,
            forall a. a -> Maybe a
Prelude.Just (Key
"FileSystemId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
fileSystemId),
            forall a. a -> Maybe a
Prelude.Just (Key
"Aliases" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Text]
aliases)
          ]
      )

instance Data.ToPath AssociateFileSystemAliases where
  toPath :: AssociateFileSystemAliases -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery AssociateFileSystemAliases where
  toQuery :: AssociateFileSystemAliases -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | The system generated response showing the DNS aliases that Amazon FSx is
-- attempting to associate with the file system. Use the API operation to
-- monitor the status of the aliases Amazon FSx is associating with the
-- file system. It can take up to 2.5 minutes for the alias status to
-- change from @CREATING@ to @AVAILABLE@.
--
-- /See:/ 'newAssociateFileSystemAliasesResponse' smart constructor.
data AssociateFileSystemAliasesResponse = AssociateFileSystemAliasesResponse'
  { -- | An array of the DNS aliases that Amazon FSx is associating with the file
    -- system.
    AssociateFileSystemAliasesResponse -> Maybe [Alias]
aliases :: Prelude.Maybe [Alias],
    -- | The response's http status code.
    AssociateFileSystemAliasesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (AssociateFileSystemAliasesResponse
-> AssociateFileSystemAliasesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssociateFileSystemAliasesResponse
-> AssociateFileSystemAliasesResponse -> Bool
$c/= :: AssociateFileSystemAliasesResponse
-> AssociateFileSystemAliasesResponse -> Bool
== :: AssociateFileSystemAliasesResponse
-> AssociateFileSystemAliasesResponse -> Bool
$c== :: AssociateFileSystemAliasesResponse
-> AssociateFileSystemAliasesResponse -> Bool
Prelude.Eq, ReadPrec [AssociateFileSystemAliasesResponse]
ReadPrec AssociateFileSystemAliasesResponse
Int -> ReadS AssociateFileSystemAliasesResponse
ReadS [AssociateFileSystemAliasesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssociateFileSystemAliasesResponse]
$creadListPrec :: ReadPrec [AssociateFileSystemAliasesResponse]
readPrec :: ReadPrec AssociateFileSystemAliasesResponse
$creadPrec :: ReadPrec AssociateFileSystemAliasesResponse
readList :: ReadS [AssociateFileSystemAliasesResponse]
$creadList :: ReadS [AssociateFileSystemAliasesResponse]
readsPrec :: Int -> ReadS AssociateFileSystemAliasesResponse
$creadsPrec :: Int -> ReadS AssociateFileSystemAliasesResponse
Prelude.Read, Int -> AssociateFileSystemAliasesResponse -> ShowS
[AssociateFileSystemAliasesResponse] -> ShowS
AssociateFileSystemAliasesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssociateFileSystemAliasesResponse] -> ShowS
$cshowList :: [AssociateFileSystemAliasesResponse] -> ShowS
show :: AssociateFileSystemAliasesResponse -> String
$cshow :: AssociateFileSystemAliasesResponse -> String
showsPrec :: Int -> AssociateFileSystemAliasesResponse -> ShowS
$cshowsPrec :: Int -> AssociateFileSystemAliasesResponse -> ShowS
Prelude.Show, forall x.
Rep AssociateFileSystemAliasesResponse x
-> AssociateFileSystemAliasesResponse
forall x.
AssociateFileSystemAliasesResponse
-> Rep AssociateFileSystemAliasesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AssociateFileSystemAliasesResponse x
-> AssociateFileSystemAliasesResponse
$cfrom :: forall x.
AssociateFileSystemAliasesResponse
-> Rep AssociateFileSystemAliasesResponse x
Prelude.Generic)

-- |
-- Create a value of 'AssociateFileSystemAliasesResponse' 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:
--
-- 'aliases', 'associateFileSystemAliasesResponse_aliases' - An array of the DNS aliases that Amazon FSx is associating with the file
-- system.
--
-- 'httpStatus', 'associateFileSystemAliasesResponse_httpStatus' - The response's http status code.
newAssociateFileSystemAliasesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  AssociateFileSystemAliasesResponse
newAssociateFileSystemAliasesResponse :: Int -> AssociateFileSystemAliasesResponse
newAssociateFileSystemAliasesResponse Int
pHttpStatus_ =
  AssociateFileSystemAliasesResponse'
    { $sel:aliases:AssociateFileSystemAliasesResponse' :: Maybe [Alias]
aliases =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:AssociateFileSystemAliasesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | An array of the DNS aliases that Amazon FSx is associating with the file
-- system.
associateFileSystemAliasesResponse_aliases :: Lens.Lens' AssociateFileSystemAliasesResponse (Prelude.Maybe [Alias])
associateFileSystemAliasesResponse_aliases :: Lens' AssociateFileSystemAliasesResponse (Maybe [Alias])
associateFileSystemAliasesResponse_aliases = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateFileSystemAliasesResponse' {Maybe [Alias]
aliases :: Maybe [Alias]
$sel:aliases:AssociateFileSystemAliasesResponse' :: AssociateFileSystemAliasesResponse -> Maybe [Alias]
aliases} -> Maybe [Alias]
aliases) (\s :: AssociateFileSystemAliasesResponse
s@AssociateFileSystemAliasesResponse' {} Maybe [Alias]
a -> AssociateFileSystemAliasesResponse
s {$sel:aliases:AssociateFileSystemAliasesResponse' :: Maybe [Alias]
aliases = Maybe [Alias]
a} :: AssociateFileSystemAliasesResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The response's http status code.
associateFileSystemAliasesResponse_httpStatus :: Lens.Lens' AssociateFileSystemAliasesResponse Prelude.Int
associateFileSystemAliasesResponse_httpStatus :: Lens' AssociateFileSystemAliasesResponse Int
associateFileSystemAliasesResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateFileSystemAliasesResponse' {Int
httpStatus :: Int
$sel:httpStatus:AssociateFileSystemAliasesResponse' :: AssociateFileSystemAliasesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: AssociateFileSystemAliasesResponse
s@AssociateFileSystemAliasesResponse' {} Int
a -> AssociateFileSystemAliasesResponse
s {$sel:httpStatus:AssociateFileSystemAliasesResponse' :: Int
httpStatus = Int
a} :: AssociateFileSystemAliasesResponse)

instance
  Prelude.NFData
    AssociateFileSystemAliasesResponse
  where
  rnf :: AssociateFileSystemAliasesResponse -> ()
rnf AssociateFileSystemAliasesResponse' {Int
Maybe [Alias]
httpStatus :: Int
aliases :: Maybe [Alias]
$sel:httpStatus:AssociateFileSystemAliasesResponse' :: AssociateFileSystemAliasesResponse -> Int
$sel:aliases:AssociateFileSystemAliasesResponse' :: AssociateFileSystemAliasesResponse -> Maybe [Alias]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Alias]
aliases
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus