UpdateUserPoolClientRequest.h

 
#pragma once
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/cognito-idp/model/TokenValidityUnitsType.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/cognito-idp/model/AnalyticsConfigurationType.h>
#include <aws/cognito-idp/model/PreventUserExistenceErrorTypes.h>
#include <aws/cognito-idp/model/RefreshTokenRotationType.h>
#include <aws/cognito-idp/model/ExplicitAuthFlowsType.h>
#include <aws/cognito-idp/model/OAuthFlowType.h>
#include <utility>
 
namespace Aws
{
namespace CognitoIdentityProvider
{
namespace Model
{
 
  class UpdateUserPoolClientRequest : public CognitoIdentityProviderRequest
  {
  public:
    AWS_COGNITOIDENTITYPROVIDER_API UpdateUserPoolClientRequest() = default;
 
    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "UpdateUserPoolClient"; }
 
    AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
 
    AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
 
    inline const Aws::String& GetUserPoolId() const { return m_userPoolId; }
    inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
    template<typename UserPoolIdT = Aws::String>
    void SetUserPoolId(UserPoolIdT&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::forward<UserPoolIdT>(value); }
    template<typename UserPoolIdT = Aws::String>
    UpdateUserPoolClientRequest& WithUserPoolId(UserPoolIdT&& value) { SetUserPoolId(std::forward<UserPoolIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetClientId() const { return m_clientId; }
    inline bool ClientIdHasBeenSet() const { return m_clientIdHasBeenSet; }
    template<typename ClientIdT = Aws::String>
    void SetClientId(ClientIdT&& value) { m_clientIdHasBeenSet = true; m_clientId = std::forward<ClientIdT>(value); }
    template<typename ClientIdT = Aws::String>
    UpdateUserPoolClientRequest& WithClientId(ClientIdT&& value) { SetClientId(std::forward<ClientIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetClientName() const { return m_clientName; }
    inline bool ClientNameHasBeenSet() const { return m_clientNameHasBeenSet; }
    template<typename ClientNameT = Aws::String>
    void SetClientName(ClientNameT&& value) { m_clientNameHasBeenSet = true; m_clientName = std::forward<ClientNameT>(value); }
    template<typename ClientNameT = Aws::String>
    UpdateUserPoolClientRequest& WithClientName(ClientNameT&& value) { SetClientName(std::forward<ClientNameT>(value)); return *this;}
 
 
    inline int GetRefreshTokenValidity() const { return m_refreshTokenValidity; }
    inline bool RefreshTokenValidityHasBeenSet() const { return m_refreshTokenValidityHasBeenSet; }
    inline void SetRefreshTokenValidity(int value) { m_refreshTokenValidityHasBeenSet = true; m_refreshTokenValidity = value; }
    inline UpdateUserPoolClientRequest& WithRefreshTokenValidity(int value) { SetRefreshTokenValidity(value); return *this;}
 
 
    inline int GetAccessTokenValidity() const { return m_accessTokenValidity; }
    inline bool AccessTokenValidityHasBeenSet() const { return m_accessTokenValidityHasBeenSet; }
    inline void SetAccessTokenValidity(int value) { m_accessTokenValidityHasBeenSet = true; m_accessTokenValidity = value; }
    inline UpdateUserPoolClientRequest& WithAccessTokenValidity(int value) { SetAccessTokenValidity(value); return *this;}
 
 
    inline int GetIdTokenValidity() const { return m_idTokenValidity; }
    inline bool IdTokenValidityHasBeenSet() const { return m_idTokenValidityHasBeenSet; }
    inline void SetIdTokenValidity(int value) { m_idTokenValidityHasBeenSet = true; m_idTokenValidity = value; }
    inline UpdateUserPoolClientRequest& WithIdTokenValidity(int value) { SetIdTokenValidity(value); return *this;}
 
 
    inline const TokenValidityUnitsType& GetTokenValidityUnits() const { return m_tokenValidityUnits; }
    inline bool TokenValidityUnitsHasBeenSet() const { return m_tokenValidityUnitsHasBeenSet; }
    template<typename TokenValidityUnitsT = TokenValidityUnitsType>
    void SetTokenValidityUnits(TokenValidityUnitsT&& value) { m_tokenValidityUnitsHasBeenSet = true; m_tokenValidityUnits = std::forward<TokenValidityUnitsT>(value); }
    template<typename TokenValidityUnitsT = TokenValidityUnitsType>
    UpdateUserPoolClientRequest& WithTokenValidityUnits(TokenValidityUnitsT&& value) { SetTokenValidityUnits(std::forward<TokenValidityUnitsT>(value)); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetReadAttributes() const { return m_readAttributes; }
    inline bool ReadAttributesHasBeenSet() const { return m_readAttributesHasBeenSet; }
    template<typename ReadAttributesT = Aws::Vector<Aws::String>>
    void SetReadAttributes(ReadAttributesT&& value) { m_readAttributesHasBeenSet = true; m_readAttributes = std::forward<ReadAttributesT>(value); }
    template<typename ReadAttributesT = Aws::Vector<Aws::String>>
    UpdateUserPoolClientRequest& WithReadAttributes(ReadAttributesT&& value) { SetReadAttributes(std::forward<ReadAttributesT>(value)); return *this;}
    template<typename ReadAttributesT = Aws::String>
    UpdateUserPoolClientRequest& AddReadAttributes(ReadAttributesT&& value) { m_readAttributesHasBeenSet = true; m_readAttributes.emplace_back(std::forward<ReadAttributesT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetWriteAttributes() const { return m_writeAttributes; }
    inline bool WriteAttributesHasBeenSet() const { return m_writeAttributesHasBeenSet; }
    template<typename WriteAttributesT = Aws::Vector<Aws::String>>
    void SetWriteAttributes(WriteAttributesT&& value) { m_writeAttributesHasBeenSet = true; m_writeAttributes = std::forward<WriteAttributesT>(value); }
    template<typename WriteAttributesT = Aws::Vector<Aws::String>>
    UpdateUserPoolClientRequest& WithWriteAttributes(WriteAttributesT&& value) { SetWriteAttributes(std::forward<WriteAttributesT>(value)); return *this;}
    template<typename WriteAttributesT = Aws::String>
    UpdateUserPoolClientRequest& AddWriteAttributes(WriteAttributesT&& value) { m_writeAttributesHasBeenSet = true; m_writeAttributes.emplace_back(std::forward<WriteAttributesT>(value)); return *this; }
 
 
    inline const Aws::Vector<ExplicitAuthFlowsType>& GetExplicitAuthFlows() const { return m_explicitAuthFlows; }
    inline bool ExplicitAuthFlowsHasBeenSet() const { return m_explicitAuthFlowsHasBeenSet; }
    template<typename ExplicitAuthFlowsT = Aws::Vector<ExplicitAuthFlowsType>>
    void SetExplicitAuthFlows(ExplicitAuthFlowsT&& value) { m_explicitAuthFlowsHasBeenSet = true; m_explicitAuthFlows = std::forward<ExplicitAuthFlowsT>(value); }
    template<typename ExplicitAuthFlowsT = Aws::Vector<ExplicitAuthFlowsType>>
    UpdateUserPoolClientRequest& WithExplicitAuthFlows(ExplicitAuthFlowsT&& value) { SetExplicitAuthFlows(std::forward<ExplicitAuthFlowsT>(value)); return *this;}
    inline UpdateUserPoolClientRequest& AddExplicitAuthFlows(ExplicitAuthFlowsType value) { m_explicitAuthFlowsHasBeenSet = true; m_explicitAuthFlows.push_back(value); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetSupportedIdentityProviders() const { return m_supportedIdentityProviders; }
    inline bool SupportedIdentityProvidersHasBeenSet() const { return m_supportedIdentityProvidersHasBeenSet; }
    template<typename SupportedIdentityProvidersT = Aws::Vector<Aws::String>>
    void SetSupportedIdentityProviders(SupportedIdentityProvidersT&& value) { m_supportedIdentityProvidersHasBeenSet = true; m_supportedIdentityProviders = std::forward<SupportedIdentityProvidersT>(value); }
    template<typename SupportedIdentityProvidersT = Aws::Vector<Aws::String>>
    UpdateUserPoolClientRequest& WithSupportedIdentityProviders(SupportedIdentityProvidersT&& value) { SetSupportedIdentityProviders(std::forward<SupportedIdentityProvidersT>(value)); return *this;}
    template<typename SupportedIdentityProvidersT = Aws::String>
    UpdateUserPoolClientRequest& AddSupportedIdentityProviders(SupportedIdentityProvidersT&& value) { m_supportedIdentityProvidersHasBeenSet = true; m_supportedIdentityProviders.emplace_back(std::forward<SupportedIdentityProvidersT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetCallbackURLs() const { return m_callbackURLs; }
    inline bool CallbackURLsHasBeenSet() const { return m_callbackURLsHasBeenSet; }
    template<typename CallbackURLsT = Aws::Vector<Aws::String>>
    void SetCallbackURLs(CallbackURLsT&& value) { m_callbackURLsHasBeenSet = true; m_callbackURLs = std::forward<CallbackURLsT>(value); }
    template<typename CallbackURLsT = Aws::Vector<Aws::String>>
    UpdateUserPoolClientRequest& WithCallbackURLs(CallbackURLsT&& value) { SetCallbackURLs(std::forward<CallbackURLsT>(value)); return *this;}
    template<typename CallbackURLsT = Aws::String>
    UpdateUserPoolClientRequest& AddCallbackURLs(CallbackURLsT&& value) { m_callbackURLsHasBeenSet = true; m_callbackURLs.emplace_back(std::forward<CallbackURLsT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetLogoutURLs() const { return m_logoutURLs; }
    inline bool LogoutURLsHasBeenSet() const { return m_logoutURLsHasBeenSet; }
    template<typename LogoutURLsT = Aws::Vector<Aws::String>>
    void SetLogoutURLs(LogoutURLsT&& value) { m_logoutURLsHasBeenSet = true; m_logoutURLs = std::forward<LogoutURLsT>(value); }
    template<typename LogoutURLsT = Aws::Vector<Aws::String>>
    UpdateUserPoolClientRequest& WithLogoutURLs(LogoutURLsT&& value) { SetLogoutURLs(std::forward<LogoutURLsT>(value)); return *this;}
    template<typename LogoutURLsT = Aws::String>
    UpdateUserPoolClientRequest& AddLogoutURLs(LogoutURLsT&& value) { m_logoutURLsHasBeenSet = true; m_logoutURLs.emplace_back(std::forward<LogoutURLsT>(value)); return *this; }
 
 
    inline const Aws::String& GetDefaultRedirectURI() const { return m_defaultRedirectURI; }
    inline bool DefaultRedirectURIHasBeenSet() const { return m_defaultRedirectURIHasBeenSet; }
    template<typename DefaultRedirectURIT = Aws::String>
    void SetDefaultRedirectURI(DefaultRedirectURIT&& value) { m_defaultRedirectURIHasBeenSet = true; m_defaultRedirectURI = std::forward<DefaultRedirectURIT>(value); }
    template<typename DefaultRedirectURIT = Aws::String>
    UpdateUserPoolClientRequest& WithDefaultRedirectURI(DefaultRedirectURIT&& value) { SetDefaultRedirectURI(std::forward<DefaultRedirectURIT>(value)); return *this;}
 
 
    inline const Aws::Vector<OAuthFlowType>& GetAllowedOAuthFlows() const { return m_allowedOAuthFlows; }
    inline bool AllowedOAuthFlowsHasBeenSet() const { return m_allowedOAuthFlowsHasBeenSet; }
    template<typename AllowedOAuthFlowsT = Aws::Vector<OAuthFlowType>>
    void SetAllowedOAuthFlows(AllowedOAuthFlowsT&& value) { m_allowedOAuthFlowsHasBeenSet = true; m_allowedOAuthFlows = std::forward<AllowedOAuthFlowsT>(value); }
    template<typename AllowedOAuthFlowsT = Aws::Vector<OAuthFlowType>>
    UpdateUserPoolClientRequest& WithAllowedOAuthFlows(AllowedOAuthFlowsT&& value) { SetAllowedOAuthFlows(std::forward<AllowedOAuthFlowsT>(value)); return *this;}
    inline UpdateUserPoolClientRequest& AddAllowedOAuthFlows(OAuthFlowType value) { m_allowedOAuthFlowsHasBeenSet = true; m_allowedOAuthFlows.push_back(value); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetAllowedOAuthScopes() const { return m_allowedOAuthScopes; }
    inline bool AllowedOAuthScopesHasBeenSet() const { return m_allowedOAuthScopesHasBeenSet; }
    template<typename AllowedOAuthScopesT = Aws::Vector<Aws::String>>
    void SetAllowedOAuthScopes(AllowedOAuthScopesT&& value) { m_allowedOAuthScopesHasBeenSet = true; m_allowedOAuthScopes = std::forward<AllowedOAuthScopesT>(value); }
    template<typename AllowedOAuthScopesT = Aws::Vector<Aws::String>>
    UpdateUserPoolClientRequest& WithAllowedOAuthScopes(AllowedOAuthScopesT&& value) { SetAllowedOAuthScopes(std::forward<AllowedOAuthScopesT>(value)); return *this;}
    template<typename AllowedOAuthScopesT = Aws::String>
    UpdateUserPoolClientRequest& AddAllowedOAuthScopes(AllowedOAuthScopesT&& value) { m_allowedOAuthScopesHasBeenSet = true; m_allowedOAuthScopes.emplace_back(std::forward<AllowedOAuthScopesT>(value)); return *this; }
 
 
    inline bool GetAllowedOAuthFlowsUserPoolClient() const { return m_allowedOAuthFlowsUserPoolClient; }
    inline bool AllowedOAuthFlowsUserPoolClientHasBeenSet() const { return m_allowedOAuthFlowsUserPoolClientHasBeenSet; }
    inline void SetAllowedOAuthFlowsUserPoolClient(bool value) { m_allowedOAuthFlowsUserPoolClientHasBeenSet = true; m_allowedOAuthFlowsUserPoolClient = value; }
    inline UpdateUserPoolClientRequest& WithAllowedOAuthFlowsUserPoolClient(bool value) { SetAllowedOAuthFlowsUserPoolClient(value); return *this;}
 
 
    inline const AnalyticsConfigurationType& GetAnalyticsConfiguration() const { return m_analyticsConfiguration; }
    inline bool AnalyticsConfigurationHasBeenSet() const { return m_analyticsConfigurationHasBeenSet; }
    template<typename AnalyticsConfigurationT = AnalyticsConfigurationType>
    void SetAnalyticsConfiguration(AnalyticsConfigurationT&& value) { m_analyticsConfigurationHasBeenSet = true; m_analyticsConfiguration = std::forward<AnalyticsConfigurationT>(value); }
    template<typename AnalyticsConfigurationT = AnalyticsConfigurationType>
    UpdateUserPoolClientRequest& WithAnalyticsConfiguration(AnalyticsConfigurationT&& value) { SetAnalyticsConfiguration(std::forward<AnalyticsConfigurationT>(value)); return *this;}
 
 
    inline PreventUserExistenceErrorTypes GetPreventUserExistenceErrors() const { return m_preventUserExistenceErrors; }
    inline bool PreventUserExistenceErrorsHasBeenSet() const { return m_preventUserExistenceErrorsHasBeenSet; }
    inline void SetPreventUserExistenceErrors(PreventUserExistenceErrorTypes value) { m_preventUserExistenceErrorsHasBeenSet = true; m_preventUserExistenceErrors = value; }
    inline UpdateUserPoolClientRequest& WithPreventUserExistenceErrors(PreventUserExistenceErrorTypes value) { SetPreventUserExistenceErrors(value); return *this;}
 
 
    inline bool GetEnableTokenRevocation() const { return m_enableTokenRevocation; }
    inline bool EnableTokenRevocationHasBeenSet() const { return m_enableTokenRevocationHasBeenSet; }
    inline void SetEnableTokenRevocation(bool value) { m_enableTokenRevocationHasBeenSet = true; m_enableTokenRevocation = value; }
    inline UpdateUserPoolClientRequest& WithEnableTokenRevocation(bool value) { SetEnableTokenRevocation(value); return *this;}
 
 
    inline bool GetEnablePropagateAdditionalUserContextData() const { return m_enablePropagateAdditionalUserContextData; }
    inline bool EnablePropagateAdditionalUserContextDataHasBeenSet() const { return m_enablePropagateAdditionalUserContextDataHasBeenSet; }
    inline void SetEnablePropagateAdditionalUserContextData(bool value) { m_enablePropagateAdditionalUserContextDataHasBeenSet = true; m_enablePropagateAdditionalUserContextData = value; }
    inline UpdateUserPoolClientRequest& WithEnablePropagateAdditionalUserContextData(bool value) { SetEnablePropagateAdditionalUserContextData(value); return *this;}
 
 
    inline int GetAuthSessionValidity() const { return m_authSessionValidity; }
    inline bool AuthSessionValidityHasBeenSet() const { return m_authSessionValidityHasBeenSet; }
    inline void SetAuthSessionValidity(int value) { m_authSessionValidityHasBeenSet = true; m_authSessionValidity = value; }
    inline UpdateUserPoolClientRequest& WithAuthSessionValidity(int value) { SetAuthSessionValidity(value); return *this;}
 
 
    inline const RefreshTokenRotationType& GetRefreshTokenRotation() const { return m_refreshTokenRotation; }
    inline bool RefreshTokenRotationHasBeenSet() const { return m_refreshTokenRotationHasBeenSet; }
    template<typename RefreshTokenRotationT = RefreshTokenRotationType>
    void SetRefreshTokenRotation(RefreshTokenRotationT&& value) { m_refreshTokenRotationHasBeenSet = true; m_refreshTokenRotation = std::forward<RefreshTokenRotationT>(value); }
    template<typename RefreshTokenRotationT = RefreshTokenRotationType>
    UpdateUserPoolClientRequest& WithRefreshTokenRotation(RefreshTokenRotationT&& value) { SetRefreshTokenRotation(std::forward<RefreshTokenRotationT>(value)); return *this;}
  private:
 
    Aws::String m_userPoolId;
    bool m_userPoolIdHasBeenSet = false;
 
    Aws::String m_clientId;
    bool m_clientIdHasBeenSet = false;
 
    Aws::String m_clientName;
    bool m_clientNameHasBeenSet = false;
 
    int m_refreshTokenValidity{0};
    bool m_refreshTokenValidityHasBeenSet = false;
 
    int m_accessTokenValidity{0};
    bool m_accessTokenValidityHasBeenSet = false;
 
    int m_idTokenValidity{0};
    bool m_idTokenValidityHasBeenSet = false;
 
    TokenValidityUnitsType m_tokenValidityUnits;
    bool m_tokenValidityUnitsHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_readAttributes;
    bool m_readAttributesHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_writeAttributes;
    bool m_writeAttributesHasBeenSet = false;
 
    Aws::Vector<ExplicitAuthFlowsType> m_explicitAuthFlows;
    bool m_explicitAuthFlowsHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_supportedIdentityProviders;
    bool m_supportedIdentityProvidersHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_callbackURLs;
    bool m_callbackURLsHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_logoutURLs;
    bool m_logoutURLsHasBeenSet = false;
 
    Aws::String m_defaultRedirectURI;
    bool m_defaultRedirectURIHasBeenSet = false;
 
    Aws::Vector<OAuthFlowType> m_allowedOAuthFlows;
    bool m_allowedOAuthFlowsHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_allowedOAuthScopes;
    bool m_allowedOAuthScopesHasBeenSet = false;
 
    bool m_allowedOAuthFlowsUserPoolClient{false};
    bool m_allowedOAuthFlowsUserPoolClientHasBeenSet = false;
 
    AnalyticsConfigurationType m_analyticsConfiguration;
    bool m_analyticsConfigurationHasBeenSet = false;
 
    PreventUserExistenceErrorTypes m_preventUserExistenceErrors{PreventUserExistenceErrorTypes::NOT_SET};
    bool m_preventUserExistenceErrorsHasBeenSet = false;
 
    bool m_enableTokenRevocation{false};
    bool m_enableTokenRevocationHasBeenSet = false;
 
    bool m_enablePropagateAdditionalUserContextData{false};
    bool m_enablePropagateAdditionalUserContextDataHasBeenSet = false;
 
    int m_authSessionValidity{0};
    bool m_authSessionValidityHasBeenSet = false;
 
    RefreshTokenRotationType m_refreshTokenRotation;
    bool m_refreshTokenRotationHasBeenSet = false;
  };
 
} // namespace Model
} // namespace CognitoIdentityProvider
} // namespace Aws