CreateUserPoolClientRequest.h

 
#pragma once
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
#include <aws/cognito-idp/model/AnalyticsConfigurationType.h>
#include <aws/cognito-idp/model/ExplicitAuthFlowsType.h>
#include <aws/cognito-idp/model/OAuthFlowType.h>
#include <aws/cognito-idp/model/PreventUserExistenceErrorTypes.h>
#include <aws/cognito-idp/model/RefreshTokenRotationType.h>
#include <aws/cognito-idp/model/TokenValidityUnitsType.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace CognitoIdentityProvider {
namespace Model {
 
class CreateUserPoolClientRequest : public CognitoIdentityProviderRequest {
 public:
  AWS_COGNITOIDENTITYPROVIDER_API CreateUserPoolClientRequest() = 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 "CreateUserPoolClient"; }
 
  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>
  CreateUserPoolClientRequest& WithUserPoolId(UserPoolIdT&& value) {
    SetUserPoolId(std::forward<UserPoolIdT>(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>
  CreateUserPoolClientRequest& WithClientName(ClientNameT&& value) {
    SetClientName(std::forward<ClientNameT>(value));
    return *this;
  }
 
 
  inline bool GetGenerateSecret() const { return m_generateSecret; }
  inline bool GenerateSecretHasBeenSet() const { return m_generateSecretHasBeenSet; }
  inline void SetGenerateSecret(bool value) {
    m_generateSecretHasBeenSet = true;
    m_generateSecret = value;
  }
  inline CreateUserPoolClientRequest& WithGenerateSecret(bool value) {
    SetGenerateSecret(value);
    return *this;
  }
 
 
  inline const Aws::String& GetClientSecret() const { return m_clientSecret; }
  inline bool ClientSecretHasBeenSet() const { return m_clientSecretHasBeenSet; }
  template <typename ClientSecretT = Aws::String>
  void SetClientSecret(ClientSecretT&& value) {
    m_clientSecretHasBeenSet = true;
    m_clientSecret = std::forward<ClientSecretT>(value);
  }
  template <typename ClientSecretT = Aws::String>
  CreateUserPoolClientRequest& WithClientSecret(ClientSecretT&& value) {
    SetClientSecret(std::forward<ClientSecretT>(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 CreateUserPoolClientRequest& 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 CreateUserPoolClientRequest& 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 CreateUserPoolClientRequest& 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>
  CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithReadAttributes(ReadAttributesT&& value) {
    SetReadAttributes(std::forward<ReadAttributesT>(value));
    return *this;
  }
  template <typename ReadAttributesT = Aws::String>
  CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithWriteAttributes(WriteAttributesT&& value) {
    SetWriteAttributes(std::forward<WriteAttributesT>(value));
    return *this;
  }
  template <typename WriteAttributesT = Aws::String>
  CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithExplicitAuthFlows(ExplicitAuthFlowsT&& value) {
    SetExplicitAuthFlows(std::forward<ExplicitAuthFlowsT>(value));
    return *this;
  }
  inline CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithSupportedIdentityProviders(SupportedIdentityProvidersT&& value) {
    SetSupportedIdentityProviders(std::forward<SupportedIdentityProvidersT>(value));
    return *this;
  }
  template <typename SupportedIdentityProvidersT = Aws::String>
  CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithCallbackURLs(CallbackURLsT&& value) {
    SetCallbackURLs(std::forward<CallbackURLsT>(value));
    return *this;
  }
  template <typename CallbackURLsT = Aws::String>
  CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithLogoutURLs(LogoutURLsT&& value) {
    SetLogoutURLs(std::forward<LogoutURLsT>(value));
    return *this;
  }
  template <typename LogoutURLsT = Aws::String>
  CreateUserPoolClientRequest& 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>
  CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithAllowedOAuthFlows(AllowedOAuthFlowsT&& value) {
    SetAllowedOAuthFlows(std::forward<AllowedOAuthFlowsT>(value));
    return *this;
  }
  inline CreateUserPoolClientRequest& 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>>
  CreateUserPoolClientRequest& WithAllowedOAuthScopes(AllowedOAuthScopesT&& value) {
    SetAllowedOAuthScopes(std::forward<AllowedOAuthScopesT>(value));
    return *this;
  }
  template <typename AllowedOAuthScopesT = Aws::String>
  CreateUserPoolClientRequest& 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 CreateUserPoolClientRequest& 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>
  CreateUserPoolClientRequest& 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 CreateUserPoolClientRequest& 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 CreateUserPoolClientRequest& 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 CreateUserPoolClientRequest& 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 CreateUserPoolClientRequest& 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>
  CreateUserPoolClientRequest& WithRefreshTokenRotation(RefreshTokenRotationT&& value) {
    SetRefreshTokenRotation(std::forward<RefreshTokenRotationT>(value));
    return *this;
  }
 private:
  Aws::String m_userPoolId;
 
  Aws::String m_clientName;
 
  bool m_generateSecret{false};
 
  Aws::String m_clientSecret;
 
  int m_refreshTokenValidity{0};
 
  int m_accessTokenValidity{0};
 
  int m_idTokenValidity{0};
 
  TokenValidityUnitsType m_tokenValidityUnits;
 
  Aws::Vector<Aws::String> m_readAttributes;
 
  Aws::Vector<Aws::String> m_writeAttributes;
 
  Aws::Vector<ExplicitAuthFlowsType> m_explicitAuthFlows;
 
  Aws::Vector<Aws::String> m_supportedIdentityProviders;
 
  Aws::Vector<Aws::String> m_callbackURLs;
 
  Aws::Vector<Aws::String> m_logoutURLs;
 
  Aws::String m_defaultRedirectURI;
 
  Aws::Vector<OAuthFlowType> m_allowedOAuthFlows;
 
  Aws::Vector<Aws::String> m_allowedOAuthScopes;
 
  bool m_allowedOAuthFlowsUserPoolClient{false};
 
  AnalyticsConfigurationType m_analyticsConfiguration;
 
  PreventUserExistenceErrorTypes m_preventUserExistenceErrors{PreventUserExistenceErrorTypes::NOT_SET};
 
  bool m_enableTokenRevocation{false};
 
  bool m_enablePropagateAdditionalUserContextData{false};
 
  int m_authSessionValidity{0};
 
  RefreshTokenRotationType m_refreshTokenRotation;
  bool m_userPoolIdHasBeenSet = false;
  bool m_clientNameHasBeenSet = false;
  bool m_generateSecretHasBeenSet = false;
  bool m_clientSecretHasBeenSet = false;
  bool m_refreshTokenValidityHasBeenSet = false;
  bool m_accessTokenValidityHasBeenSet = false;
  bool m_idTokenValidityHasBeenSet = false;
  bool m_tokenValidityUnitsHasBeenSet = false;
  bool m_readAttributesHasBeenSet = false;
  bool m_writeAttributesHasBeenSet = false;
  bool m_explicitAuthFlowsHasBeenSet = false;
  bool m_supportedIdentityProvidersHasBeenSet = false;
  bool m_callbackURLsHasBeenSet = false;
  bool m_logoutURLsHasBeenSet = false;
  bool m_defaultRedirectURIHasBeenSet = false;
  bool m_allowedOAuthFlowsHasBeenSet = false;
  bool m_allowedOAuthScopesHasBeenSet = false;
  bool m_allowedOAuthFlowsUserPoolClientHasBeenSet = false;
  bool m_analyticsConfigurationHasBeenSet = false;
  bool m_preventUserExistenceErrorsHasBeenSet = false;
  bool m_enableTokenRevocationHasBeenSet = false;
  bool m_enablePropagateAdditionalUserContextDataHasBeenSet = false;
  bool m_authSessionValidityHasBeenSet = false;
  bool m_refreshTokenRotationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CognitoIdentityProvider
}  // namespace Aws