Container for the parameters to the CreateAlias operation. Creates a display name for a customer master key. An alias can be used to identify a key and should be unique. The console enforces a one-to-one mapping between the alias and a key. An alias name can contain only alphanumeric characters, forward slashes (/), underscores (_), and dashes (-). An alias must start with the word "alias" followed by a forward slash (alias/). An alias that begins with "aws" after the forward slash (alias/aws...) is reserved by Amazon Web Services (AWS).

The alias and the key it is mapped to must be in the same AWS account and the same region.

To map an alias to a different key, call UpdateAlias.

Inheritance: AmazonKeyManagementServiceRequest
        public object Execute(ExecutorContext context)
        {
            var cmdletContext = context as CmdletContext;
            // create request
            var request = new Amazon.KeyManagementService.Model.CreateAliasRequest();

            if (cmdletContext.AliasName != null)
            {
                request.AliasName = cmdletContext.AliasName;
            }
            if (cmdletContext.TargetKeyId != null)
            {
                request.TargetKeyId = cmdletContext.TargetKeyId;
            }

            CmdletOutput output;

            // issue call
            var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);

            try
            {
                var    response       = CallAWSServiceOperation(client, request);
                object pipelineOutput = null;
                pipelineOutput = cmdletContext.Select(response, this);
                output         = new CmdletOutput
                {
                    PipelineOutput  = pipelineOutput,
                    ServiceResponse = response
                };
            }
            catch (Exception e)
            {
                output = new CmdletOutput {
                    ErrorResponse = e
                };
            }

            return(output);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the CreateAlias operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateAlias operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateAliasResponse> CreateAliasAsync(CreateAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateAliasRequestMarshaller();
            var unmarshaller = CreateAliasResponseUnmarshaller.Instance;

            return InvokeAsync<CreateAliasRequest,CreateAliasResponse>(request, marshaller, 
                unmarshaller, cancellationToken);
        }
 /// <summary>
 /// Creates a display name for a customer master key. An alias can be used to identify
 /// a key and should be unique. The console enforces a one-to-one mapping between the
 /// alias and a key. An alias name can contain only alphanumeric characters, forward slashes
 /// (/), underscores (_), and dashes (-). An alias must start with the word "alias" followed
 /// by a forward slash (alias/). An alias that begins with "aws" after the forward slash
 /// (alias/aws...) is reserved by Amazon Web Services (AWS). 
 /// 
 ///  
 /// <para>
 /// To associate an alias with a different key, call <a>UpdateAlias</a>.
 /// </para>
 ///  
 /// <para>
 /// Note that you cannot create or update an alias that represents a key in another account.
 /// </para>
 /// </summary>
 /// <param name="aliasName">String that contains the display name. The name must start with the word "alias" followed by a forward slash (alias/). Aliases that begin with "alias/AWS" are reserved. </param>
 /// <param name="targetKeyId">An identifier of the key for which you are creating the alias. This value cannot be another alias but can be a globally unique identifier or a fully specified ARN to a key. <ul> <li>Key ARN Example - arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</li> <li>Globally Unique Key ID Example - 12345678-1234-1234-1234-123456789012</li> </ul> </param>
 /// <param name="cancellationToken">
 ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
 /// </param>
 /// 
 /// <returns>The response from the CreateAlias service method, as returned by KeyManagementService.</returns>
 /// <exception cref="Amazon.KeyManagementService.Model.AlreadyExistsException">
 /// The request was rejected because it attempted to create a resource that already exists.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.DependencyTimeoutException">
 /// The system timed out while trying to fulfill the request.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.InvalidAliasNameException">
 /// The request was rejected because the specified alias name is not valid.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.KMSInternalException">
 /// The request was rejected because an internal exception occurred. This error can be
 /// retried.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.LimitExceededException">
 /// The request was rejected because a quota was exceeded.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.NotFoundException">
 /// The request was rejected because the specified entity or resource could not be found.
 /// </exception>
 public Task<CreateAliasResponse> CreateAliasAsync(string aliasName, string targetKeyId, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
 {
     var request = new CreateAliasRequest();
     request.AliasName = aliasName;
     request.TargetKeyId = targetKeyId;
     return CreateAliasAsync(request, cancellationToken);
 }
        /// <summary>
        /// Creates a display name for a customer master key. An alias can be used to identify
        /// a key and should be unique. The console enforces a one-to-one mapping between the
        /// alias and a key. An alias name can contain only alphanumeric characters, forward slashes
        /// (/), underscores (_), and dashes (-). An alias must start with the word "alias" followed
        /// by a forward slash (alias/). An alias that begins with "aws" after the forward slash
        /// (alias/aws...) is reserved by Amazon Web Services (AWS). 
        /// 
        ///  
        /// <para>
        /// To associate an alias with a different key, call <a>UpdateAlias</a>.
        /// </para>
        ///  
        /// <para>
        /// Note that you cannot create or update an alias that represents a key in another account.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateAlias service method.</param>
        /// 
        /// <returns>The response from the CreateAlias service method, as returned by KeyManagementService.</returns>
        /// <exception cref="Amazon.KeyManagementService.Model.AlreadyExistsException">
        /// The request was rejected because it attempted to create a resource that already exists.
        /// </exception>
        /// <exception cref="Amazon.KeyManagementService.Model.DependencyTimeoutException">
        /// The system timed out while trying to fulfill the request.
        /// </exception>
        /// <exception cref="Amazon.KeyManagementService.Model.InvalidAliasNameException">
        /// The request was rejected because the specified alias name is not valid.
        /// </exception>
        /// <exception cref="Amazon.KeyManagementService.Model.KMSInternalException">
        /// The request was rejected because an internal exception occurred. This error can be
        /// retried.
        /// </exception>
        /// <exception cref="Amazon.KeyManagementService.Model.LimitExceededException">
        /// The request was rejected because a quota was exceeded.
        /// </exception>
        /// <exception cref="Amazon.KeyManagementService.Model.NotFoundException">
        /// The request was rejected because the specified entity or resource could not be found.
        /// </exception>
        public CreateAliasResponse CreateAlias(CreateAliasRequest request)
        {
            var marshaller = new CreateAliasRequestMarshaller();
            var unmarshaller = CreateAliasResponseUnmarshaller.Instance;

            return Invoke<CreateAliasRequest,CreateAliasResponse>(request, marshaller, unmarshaller);
        }
 /// <summary>
 /// Creates a display name for a customer master key. An alias can be used to identify
 /// a key and should be unique. The console enforces a one-to-one mapping between the
 /// alias and a key. An alias name can contain only alphanumeric characters, forward slashes
 /// (/), underscores (_), and dashes (-). An alias must start with the word "alias" followed
 /// by a forward slash (alias/). An alias that begins with "aws" after the forward slash
 /// (alias/aws...) is reserved by Amazon Web Services (AWS). 
 /// 
 ///  
 /// <para>
 /// To associate an alias with a different key, call <a>UpdateAlias</a>.
 /// </para>
 ///  
 /// <para>
 /// Note that you cannot create or update an alias that represents a key in another account.
 /// </para>
 /// </summary>
 /// <param name="aliasName">String that contains the display name. The name must start with the word "alias" followed by a forward slash (alias/). Aliases that begin with "alias/AWS" are reserved. </param>
 /// <param name="targetKeyId">An identifier of the key for which you are creating the alias. This value cannot be another alias but can be a globally unique identifier or a fully specified ARN to a key. <ul> <li>Key ARN Example - arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</li> <li>Globally Unique Key ID Example - 12345678-1234-1234-1234-123456789012</li> </ul> </param>
 /// 
 /// <returns>The response from the CreateAlias service method, as returned by KeyManagementService.</returns>
 /// <exception cref="Amazon.KeyManagementService.Model.AlreadyExistsException">
 /// The request was rejected because it attempted to create a resource that already exists.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.DependencyTimeoutException">
 /// The system timed out while trying to fulfill the request.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.InvalidAliasNameException">
 /// The request was rejected because the specified alias name is not valid.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.KMSInternalException">
 /// The request was rejected because an internal exception occurred. This error can be
 /// retried.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.LimitExceededException">
 /// The request was rejected because a quota was exceeded.
 /// </exception>
 /// <exception cref="Amazon.KeyManagementService.Model.NotFoundException">
 /// The request was rejected because the specified entity or resource could not be found.
 /// </exception>
 public CreateAliasResponse CreateAlias(string aliasName, string targetKeyId)
 {
     var request = new CreateAliasRequest();
     request.AliasName = aliasName;
     request.TargetKeyId = targetKeyId;
     return CreateAlias(request);
 }
 private Amazon.KeyManagementService.Model.CreateAliasResponse CallAWSServiceOperation(IAmazonKeyManagementService client, Amazon.KeyManagementService.Model.CreateAliasRequest request)
 {
     Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "AWS Key Management Service", "CreateAlias");
     try
     {
         #if DESKTOP
         return(client.CreateAlias(request));
         #elif CORECLR
         return(client.CreateAliasAsync(request).GetAwaiter().GetResult());
         #else
                 #error "Unknown build edition"
         #endif
     }
     catch (AmazonServiceException exc)
     {
         var webException = exc.InnerException as System.Net.WebException;
         if (webException != null)
         {
             throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
         }
         throw;
     }
 }
        /// <summary>
        /// Initiates the asynchronous execution of the CreateAlias operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateAlias operation on AmazonKeyManagementServiceClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAlias
        ///         operation.</returns>
        public IAsyncResult BeginCreateAlias(CreateAliasRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new CreateAliasRequestMarshaller();
            var unmarshaller = CreateAliasResponseUnmarshaller.Instance;

            return BeginInvoke<CreateAliasRequest>(request, marshaller, unmarshaller,
                callback, state);
        }