/// <summary>
/// Upload data to Amazon S3 using HTTP POST.
/// </summary>
/// <remarks>
/// For more information, <see href="http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingHTTPPOST.html"/>
/// </remarks>
/// <param name="request">Request object which describes the data to POST</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void PostObjectAsync(PostObjectRequest request, AmazonServiceCallback<PostObjectRequest, PostObjectResponse> callback, AsyncOptions options = null)
{
options = options == null ? new AsyncOptions() : options;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper
= (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) =>
{
AmazonServiceResult<PostObjectRequest, PostObjectResponse> responseObject
= new AmazonServiceResult<PostObjectRequest, PostObjectResponse>((PostObjectRequest)req, (PostObjectResponse)res, ex, ao.State);
if (callback != null)
callback(responseObject);
};
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
// Provide a default policy if user doesn't set it.
try
{
InferContentType(request);
if (request.SignedPolicy == null)
{
CreateSignedPolicy(request);
}
PostObject(request, options, callbackHelper);
}
catch (Exception e)
{
callback(new AmazonServiceResult<PostObjectRequest, PostObjectResponse>(request, null, e, options.State));
}
}));
}
public void RequestUploadCredentialsAsync(RequestUploadCredentialsRequest request, AmazonServiceCallback <RequestUploadCredentialsRequest, RequestUploadCredentialsResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeIdentityUsage operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeIdentityUsage operation on AmazonCognitoSyncClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void DescribeIdentityUsageAsync(DescribeIdentityUsageRequest request, AmazonServiceCallback<DescribeIdentityUsageRequest, DescribeIdentityUsageResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new DescribeIdentityUsageRequestMarshaller();
var unmarshaller = DescribeIdentityUsageResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<DescribeIdentityUsageRequest,DescribeIdentityUsageResponse> responseObject
= new AmazonServiceResult<DescribeIdentityUsageRequest,DescribeIdentityUsageResponse>((DescribeIdentityUsageRequest)req, (DescribeIdentityUsageResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<DescribeIdentityUsageRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Returns credentials for the the provided identity ID. Any provided logins will be
/// validated against supported login providers. If the token is for cognito-identity.amazonaws.com,
/// it will be passed through to AWS Security Token Service with the appropriate role
/// for the token.
/// </summary>
/// <param name="identityId">A unique identifier in the format REGION:GUID.</param>
/// <param name="logins">A set of optional name-value pairs that map provider names to provider tokens.</param>
///
/// <returns>The response from the GetCredentialsForIdentity service method, as returned by CognitoIdentity.</returns>
/// <exception cref="Amazon.CognitoIdentity.Model.InternalErrorException">
/// Thrown when the service encounters an error during processing the request.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.InvalidIdentityPoolConfigurationException">
/// Thrown if the identity pool has no role associated for the given auth type (auth/unauth)
/// or if the AssumeRole fails.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.InvalidParameterException">
/// Thrown for missing or bad input parameter(s).
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceConflictException">
/// Thrown when a user tries to use a login which is already linked to another account.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceNotFoundException">
/// Thrown when the requested resource (for example, a dataset or record) does not exist.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.TooManyRequestsException">
/// Thrown when a request is throttled.
/// </exception>
public void GetCredentialsForIdentityAsync(string identityId, Dictionary<string, string> logins, AmazonServiceCallback<GetCredentialsForIdentityRequest, GetCredentialsForIdentityResponse> callback, AsyncOptions options = null)
{
var request = new GetCredentialsForIdentityRequest();
request.IdentityId = identityId;
request.Logins = logins;
GetCredentialsForIdentityAsync(request, callback, options);
}
/// <summary>
/// Removes the null version (if there is one) of an object and inserts a delete marker,
/// which becomes the latest version of the object. If there isn't a null version, Amazon
/// S3 does not remove any objects.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of DeleteObjectRequest used to execute the DeleteObject service method.</param>
/// <param name="key">A property of DeleteObjectRequest used to execute the DeleteObject service method.</param>
/// <param name="versionId">VersionId used to reference a specific version of the object.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the DeleteObject service method, as returned by S3.</returns>
public void DeleteObjectAsync(string bucketName, string key, string versionId, AmazonServiceCallback<DeleteObjectRequest, DeleteObjectResponse> callback, AsyncOptions options = null)
{
var request = new DeleteObjectRequest();
request.BucketName = bucketName;
request.Key = key;
request.VersionId = versionId;
DeleteObjectAsync(request, callback, options);
}
/// <summary>
/// Restores an archived copy of an object back into Amazon S3
/// </summary>
/// <param name="bucketName">A property of RestoreObjectRequest used to execute the RestoreObject service method.</param>
/// <param name="key">A property of RestoreObjectRequest used to execute the RestoreObject service method.</param>
/// <param name="versionId">A property of RestoreObjectRequest used to execute the RestoreObject service method.</param>
/// <param name="days">A property of RestoreObjectRequest used to execute the RestoreObject service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the RestoreObject service method, as returned by S3.</returns>
public void RestoreObjectAsync(string bucketName, string key, string versionId, int days, AmazonServiceCallback<RestoreObjectRequest, RestoreObjectResponse> callback, AsyncOptions options = null)
{
var request = new RestoreObjectRequest();
request.BucketName = bucketName;
request.Key = key;
request.VersionId = versionId;
request.Days = days;
RestoreObjectAsync(request, callback, options);
}
/// <summary>
/// Sets the tags for a bucket.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of PutBucketTaggingRequest used to execute the PutBucketTagging service method.</param>
/// <param name="tagSet">A property of PutBucketTaggingRequest used to execute the PutBucketTagging service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the PutBucketTagging service method, as returned by S3.</returns>
public void PutBucketTaggingAsync(string bucketName, List<Tag> tagSet, AmazonServiceCallback<PutBucketTaggingRequest, PutBucketTaggingResponse> callback, AsyncOptions options = null)
{
var request = new PutBucketTaggingRequest();
request.BucketName = bucketName;
request.TagSet = tagSet;
PutBucketTaggingAsync(request, callback, options);
}
/// <summary>
/// Returns metadata about all of the versions of objects in a bucket.
/// </summary>
/// <param name="bucketName">A property of ListVersionsRequest used to execute the ListVersions service method.</param>
/// <param name="prefix">Limits the response to keys that begin with the specified prefix.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the ListVersions service method, as returned by S3.</returns>
public void ListVersionsAsync(string bucketName, string prefix, AmazonServiceCallback<ListVersionsRequest, ListVersionsResponse> callback, AsyncOptions options = null)
{
var request = new ListVersionsRequest();
request.BucketName = bucketName;
request.Prefix = prefix;
ListVersionsAsync(request, callback, options);
}
public void UpdateRuntimeConfigurationAsync(UpdateRuntimeConfigurationRequest request, AmazonServiceCallback <UpdateRuntimeConfigurationRequest, UpdateRuntimeConfigurationResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public void UpdateGameSessionQueueAsync(UpdateGameSessionQueueRequest request, AmazonServiceCallback <UpdateGameSessionQueueRequest, UpdateGameSessionQueueResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public void UpdateFleetPortSettingsAsync(UpdateFleetPortSettingsRequest request, AmazonServiceCallback <UpdateFleetPortSettingsRequest, UpdateFleetPortSettingsResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public void StopMatchmakingAsync(StopMatchmakingRequest request, AmazonServiceCallback <StopMatchmakingRequest, StopMatchmakingResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public void StopGameSessionPlacementAsync(StopGameSessionPlacementRequest request, AmazonServiceCallback <StopGameSessionPlacementRequest, StopGameSessionPlacementResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public void SearchGameSessionsAsync(SearchGameSessionsRequest request, AmazonServiceCallback <SearchGameSessionsRequest, SearchGameSessionsResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public void ResolveAliasAsync(string aliasId, AmazonServiceCallback <ResolveAliasRequest, ResolveAliasResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Initiates the asynchronous execution of the ListBucketMetricsConfigurations operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListBucketMetricsConfigurations operation on AmazonS3Client.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void ListBucketMetricsConfigurationsAsync(ListBucketMetricsConfigurationsRequest request, AmazonServiceCallback<ListBucketMetricsConfigurationsRequest, ListBucketMetricsConfigurationsResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new ListBucketMetricsConfigurationsRequestMarshaller();
var unmarshaller = ListBucketMetricsConfigurationsResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<ListBucketMetricsConfigurationsRequest,ListBucketMetricsConfigurationsResponse> responseObject
= new AmazonServiceResult<ListBucketMetricsConfigurationsRequest,ListBucketMetricsConfigurationsResponse>((ListBucketMetricsConfigurationsRequest)req, (ListBucketMetricsConfigurationsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<ListBucketMetricsConfigurationsRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Returns some or all (up to 1000) of the objects in a bucket. You can use the request
/// parameters as selection criteria to return a subset of the objects in a bucket.
/// </summary>
/// <param name="bucketName">A property of ListObjectsRequest used to execute the ListObjects service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the ListObjects service method, as returned by S3.</returns>
public void ListObjectsAsync(string bucketName, AmazonServiceCallback<ListObjectsRequest, ListObjectsResponse> callback, AsyncOptions options = null)
{
var request = new ListObjectsRequest();
request.BucketName = bucketName;
ListObjectsAsync(request, callback, options);
}
public void CreateMatchmakingRuleSetAsync(CreateMatchmakingRuleSetRequest request, AmazonServiceCallback <CreateMatchmakingRuleSetRequest, CreateMatchmakingRuleSetResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Replaces a policy on a bucket. If the bucket already has a policy, the one in this
/// request completely replaces it.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</param>
/// <param name="policy">The bucket policy as a JSON document.</param>
/// <param name="contentMD5">A property of PutBucketPolicyRequest used to execute the PutBucketPolicy service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the PutBucketPolicy service method, as returned by S3.</returns>
public void PutBucketPolicyAsync(string bucketName, string policy, string contentMD5, AmazonServiceCallback<PutBucketPolicyRequest, PutBucketPolicyResponse> callback, AsyncOptions options = null)
{
var request = new PutBucketPolicyRequest();
request.BucketName = bucketName;
request.Policy = policy;
request.ContentMD5 = contentMD5;
PutBucketPolicyAsync(request, callback, options);
}
public void CreatePlayerSessionsAsync(string gameSessionId, List <string> playerIds, AmazonServiceCallback <CreatePlayerSessionsRequest, CreatePlayerSessionsResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Set the website configuration for a bucket.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of PutBucketWebsiteRequest used to execute the PutBucketWebsite service method.</param>
/// <param name="websiteConfiguration">A property of PutBucketWebsiteRequest used to execute the PutBucketWebsite service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the PutBucketWebsite service method, as returned by S3.</returns>
public void PutBucketWebsiteAsync(string bucketName, WebsiteConfiguration websiteConfiguration, AmazonServiceCallback<PutBucketWebsiteRequest, PutBucketWebsiteResponse> callback, AsyncOptions options = null)
{
var request = new PutBucketWebsiteRequest();
request.BucketName = bucketName;
request.WebsiteConfiguration = websiteConfiguration;
PutBucketWebsiteAsync(request, callback, options);
}
public void CreatePlayerSessionsAsync(CreatePlayerSessionsRequest request, AmazonServiceCallback <CreatePlayerSessionsRequest, CreatePlayerSessionsResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// This operation removes the website configuration from the bucket.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of DeleteBucketWebsiteRequest used to execute the DeleteBucketWebsite service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the DeleteBucketWebsite service method, as returned by S3.</returns>
public void DeleteBucketWebsiteAsync(string bucketName, AmazonServiceCallback<DeleteBucketWebsiteRequest, DeleteBucketWebsiteResponse> callback, AsyncOptions options = null)
{
var request = new DeleteBucketWebsiteRequest();
request.BucketName = bucketName;
DeleteBucketWebsiteAsync(request, callback, options);
}
public void CreateVpcPeeringConnectionAsync(CreateVpcPeeringConnectionRequest request, AmazonServiceCallback <CreateVpcPeeringConnectionRequest, CreateVpcPeeringConnectionResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Returns a set of temporary credentials for an AWS account or IAM user. The credentials
/// consist of an access key ID, a secret access key, and a security token. Typically,
/// you use <code>GetSessionToken</code> if you want to use MFA to protect programmatic
/// calls to specific AWS APIs like Amazon EC2 <code>StopInstances</code>. MFA-enabled
/// IAM users would need to call <code>GetSessionToken</code> and submit an MFA code that
/// is associated with their MFA device. Using the temporary security credentials that
/// are returned from the call, IAM users can then make programmatic calls to APIs that
/// require MFA authentication.
///
///
/// <para>
/// The <code>GetSessionToken</code> action must be called by using the long-term AWS
/// security credentials of the AWS account or an IAM user. Credentials that are created
/// by IAM users are valid for the duration that you specify, between 900 seconds (15
/// minutes) and 129600 seconds (36 hours); credentials that are created by using account
/// credentials have a maximum duration of 3600 seconds (1 hour).
/// </para>
/// <note>
/// <para>
/// We recommend that you do not call <code>GetSessionToken</code> with root account credentials.
/// Instead, follow our <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html#create-iam-users">best
/// practices</a> by creating one or more IAM users, giving them the necessary permissions,
/// and using IAM users for everyday interaction with AWS.
/// </para>
/// </note>
/// <para>
/// The permissions associated with the temporary security credentials returned by <code>GetSessionToken</code>
/// are based on the permissions associated with account or IAM user whose credentials
/// are used to call the action. If <code>GetSessionToken</code> is called using root
/// account credentials, the temporary credentials have root account permissions. Similarly,
/// if <code>GetSessionToken</code> is called using the credentials of an IAM user, the
/// temporary credentials have the same permissions as the IAM user.
/// </para>
///
/// <para>
/// For more information about using <code>GetSessionToken</code> to create temporary
/// credentials, go to <a href="http://docs.aws.amazon.com/STS/latest/UsingSTS/CreatingSessionTokens.html"
/// target="_blank">Creating Temporary Credentials to Enable Access for IAM Users</a>.
///
/// </para>
/// </summary>
/// <param name="options">
/// 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>The response from the GetSessionToken service method, as returned by SecurityTokenService.</returns>
public void GetSessionTokenAsync(AmazonServiceCallback<GetSessionTokenRequest, GetSessionTokenResponse> callback, AsyncOptions options = null)
{
GetSessionTokenAsync(new GetSessionTokenRequest(), callback, options);
}
public void DeleteAliasAsync(DeleteAliasRequest request, AmazonServiceCallback <DeleteAliasRequest, DeleteAliasResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Initiates the asynchronous execution of the GetOpenIdTokenForDeveloperIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetOpenIdTokenForDeveloperIdentity operation on AmazonCognitoIdentityClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void GetOpenIdTokenForDeveloperIdentityAsync(GetOpenIdTokenForDeveloperIdentityRequest request, AmazonServiceCallback<GetOpenIdTokenForDeveloperIdentityRequest, GetOpenIdTokenForDeveloperIdentityResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetOpenIdTokenForDeveloperIdentityRequestMarshaller();
var unmarshaller = GetOpenIdTokenForDeveloperIdentityResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<GetOpenIdTokenForDeveloperIdentityRequest,GetOpenIdTokenForDeveloperIdentityResponse> responseObject
= new AmazonServiceResult<GetOpenIdTokenForDeveloperIdentityRequest,GetOpenIdTokenForDeveloperIdentityResponse>((GetOpenIdTokenForDeveloperIdentityRequest)req, (GetOpenIdTokenForDeveloperIdentityResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<GetOpenIdTokenForDeveloperIdentityRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
public void DeleteBuildAsync(string buildId, AmazonServiceCallback <DeleteBuildRequest, DeleteBuildResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Initiates the asynchronous execution of the SetIdentityPoolConfiguration operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SetIdentityPoolConfiguration operation on AmazonCognitoSyncClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void SetIdentityPoolConfigurationAsync(SetIdentityPoolConfigurationRequest request, AmazonServiceCallback<SetIdentityPoolConfigurationRequest, SetIdentityPoolConfigurationResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new SetIdentityPoolConfigurationRequestMarshaller();
var unmarshaller = SetIdentityPoolConfigurationResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<SetIdentityPoolConfigurationRequest,SetIdentityPoolConfigurationResponse> responseObject
= new AmazonServiceResult<SetIdentityPoolConfigurationRequest,SetIdentityPoolConfigurationResponse>((SetIdentityPoolConfigurationRequest)req, (SetIdentityPoolConfigurationResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<SetIdentityPoolConfigurationRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateEventSourceMapping operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateEventSourceMapping operation on AmazonLambdaClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void CreateEventSourceMappingAsync(CreateEventSourceMappingRequest request, AmazonServiceCallback <CreateEventSourceMappingRequest, CreateEventSourceMappingResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new CreateEventSourceMappingRequestMarshaller();
var unmarshaller = CreateEventSourceMappingResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <CreateEventSourceMappingRequest, CreateEventSourceMappingResponse> responseObject
= new AmazonServiceResult <CreateEventSourceMappingRequest, CreateEventSourceMappingResponse>((CreateEventSourceMappingRequest)req, (CreateEventSourceMappingResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <CreateEventSourceMappingRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Aborts a multipart upload.
///
///
/// <para>
/// To verify that all parts have been removed, so you don't get charged for the part
/// storage, you should call the List Parts operation and ensure the parts list is empty.
/// </para>
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of AbortMultipartUploadRequest used to execute the AbortMultipartUpload service method.</param>
/// <param name="key">A property of AbortMultipartUploadRequest used to execute the AbortMultipartUpload service method.</param>
/// <param name="uploadId">A property of AbortMultipartUploadRequest used to execute the AbortMultipartUpload service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the AbortMultipartUpload service method, as returned by S3.</returns>
public void AbortMultipartUploadAsync(string bucketName, string key, string uploadId, AmazonServiceCallback<AbortMultipartUploadRequest, AbortMultipartUploadResponse> callback, AsyncOptions options = null)
{
var request = new AbortMultipartUploadRequest();
request.BucketName = bucketName;
request.Key = key;
request.UploadId = uploadId;
AbortMultipartUploadAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetFunctionConfiguration operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetFunctionConfiguration operation on AmazonLambdaClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void GetFunctionConfigurationAsync(GetFunctionConfigurationRequest request, AmazonServiceCallback <GetFunctionConfigurationRequest, GetFunctionConfigurationResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetFunctionConfigurationRequestMarshaller();
var unmarshaller = GetFunctionConfigurationResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <GetFunctionConfigurationRequest, GetFunctionConfigurationResponse> responseObject
= new AmazonServiceResult <GetFunctionConfigurationRequest, GetFunctionConfigurationResponse>((GetFunctionConfigurationRequest)req, (GetFunctionConfigurationResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <GetFunctionConfigurationRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Returns a list of all buckets owned by the authenticated sender of the request.
/// </summary>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the ListBuckets service method, as returned by S3.</returns>
public void ListBucketsAsync(AmazonServiceCallback<ListBucketsRequest, ListBucketsResponse> callback, AsyncOptions options = null)
{
ListBucketsAsync(new ListBucketsRequest(), callback, options);
}
/// <summary>
/// Returns a list of your Lambda functions. For each function, the response includes
/// the function configuration information. You must use <a>GetFunction</a> to retrieve
/// the code for your function.
///
///
/// <para>
/// This operation requires permission for the <code>lambda:ListFunctions</code> action.
/// </para>
/// </summary>
/// <param name="options">
/// 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>The response from the ListFunctions service method, as returned by Lambda.</returns>
/// <exception cref="Amazon.Lambda.Model.ServiceException">
/// The AWS Lambda service encountered an internal error.
/// </exception>
/// <exception cref="Amazon.Lambda.Model.TooManyRequestsException">
///
/// </exception>
public void ListFunctionsAsync(AmazonServiceCallback <ListFunctionsRequest, ListFunctionsResponse> callback, AsyncOptions options = null)
{
var request = new ListFunctionsRequest();
ListFunctionsAsync(request, callback, options);
}
/// <summary>
/// Lists the parts that have been uploaded for a specific multipart upload.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of ListPartsRequest used to execute the ListParts service method.</param>
/// <param name="key">A property of ListPartsRequest used to execute the ListParts service method.</param>
/// <param name="uploadId">Upload ID identifying the multipart upload whose parts are being listed.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the ListParts service method, as returned by S3.</returns>
public void ListPartsAsync(string bucketName, string key, string uploadId, AmazonServiceCallback<ListPartsRequest, ListPartsResponse> callback, AsyncOptions options = null)
{
var request = new ListPartsRequest();
request.BucketName = bucketName;
request.Key = key;
request.UploadId = uploadId;
ListPartsAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListDeliveryStreams operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListDeliveryStreams operation on AmazonKinesisFirehoseClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/ListDeliveryStreams">REST API Reference for ListDeliveryStreams Operation</seealso>
public virtual void ListDeliveryStreamsAsync(ListDeliveryStreamsRequest request, AmazonServiceCallback <ListDeliveryStreamsRequest, ListDeliveryStreamsResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new ListDeliveryStreamsRequestMarshaller();
var unmarshaller = ListDeliveryStreamsResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <ListDeliveryStreamsRequest, ListDeliveryStreamsResponse> responseObject
= new AmazonServiceResult <ListDeliveryStreamsRequest, ListDeliveryStreamsResponse>((ListDeliveryStreamsRequest)req, (ListDeliveryStreamsResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <ListDeliveryStreamsRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Creates a new bucket.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of PutBucketRequest used to execute the PutBucket service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the PutBucket service method, as returned by S3.</returns>
public void PutBucketAsync(string bucketName, AmazonServiceCallback<PutBucketRequest, PutBucketResponse> callback, AsyncOptions options = null)
{
var request = new PutBucketRequest();
request.BucketName = bucketName;
PutBucketAsync(request, callback, options);
}
/// <summary>
/// Writes multiple data records into a delivery stream in a single call, which can achieve
/// higher throughput per producer than when writing single records. To write single data
/// records into a delivery stream, use <a>PutRecord</a>. Applications using these operations
/// are referred to as producers.
///
///
/// <para>
/// By default, each delivery stream can take in up to 2,000 transactions per second,
/// 5,000 records per second, or 5 MB per second. If you use <a>PutRecord</a> and <a>PutRecordBatch</a>,
/// the limits are an aggregate across these two operations for each delivery stream.
/// For more information about limits, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
/// Kinesis Firehose Limits</a>.
/// </para>
///
/// <para>
/// Each <a>PutRecordBatch</a> request supports up to 500 records. Each record in the
/// request can be as large as 1,000 KB (before 64-bit encoding), up to a limit of 4 MB
/// for the entire request. These limits cannot be changed.
/// </para>
///
/// <para>
/// You must specify the name of the delivery stream and the data record when using <a>PutRecord</a>.
/// The data record consists of a data blob that can be up to 1,000 KB in size, and any
/// kind of data. For example, it could be a segment from a log file, geographic location
/// data, web site clickstream data, and so on.
/// </para>
///
/// <para>
/// Kinesis Firehose buffers records before delivering them to the destination. To disambiguate
/// the data blobs at the destination, a common solution is to use delimiters in the data,
/// such as a newline (<code>\n</code>) or some other character unique within the data.
/// This allows the consumer application to parse individual data items when reading the
/// data from the destination.
/// </para>
///
/// <para>
/// The <a>PutRecordBatch</a> response includes a count of failed records, <b>FailedPutCount</b>,
/// and an array of responses, <b>RequestResponses</b>. Each entry in the <b>RequestResponses</b>
/// array provides additional information about the processed record. It directly correlates
/// with a record in the request array using the same ordering, from the top to the bottom.
/// The response array always includes the same number of records as the request array.
/// <b>RequestResponses</b> includes both successfully and unsuccessfully processed records.
/// Kinesis Firehose attempts to process all records in each <a>PutRecordBatch</a> request.
/// A single record failure does not stop the processing of subsequent records.
/// </para>
///
/// <para>
/// A successfully processed record includes a <b>RecordId</b> value, which is unique
/// for the record. An unsuccessfully processed record includes <b>ErrorCode</b> and <b>ErrorMessage</b>
/// values. <b>ErrorCode</b> reflects the type of error, and is one of the following values:
/// <code>ServiceUnavailable</code> or <code>InternalFailure</code>. <b>ErrorMessage</b>
/// provides more detailed information about the error.
/// </para>
///
/// <para>
/// If there is an internal server error or a timeout, the write might have completed
/// or it might have failed. If <b>FailedPutCount</b> is greater than 0, retry the request,
/// resending only those records that might have failed processing. This minimizes the
/// possible duplicate records and also reduces the total bytes sent (and corresponding
/// charges). We recommend that you handle any duplicates at the destination.
/// </para>
///
/// <para>
/// If <a>PutRecordBatch</a> throws <b>ServiceUnavailableException</b>, back off and retry.
/// If the exception persists, it is possible that the throughput limits have been exceeded
/// for the delivery stream.
/// </para>
///
/// <para>
/// Data records sent to Kinesis Firehose are stored for 24 hours from the time they are
/// added to a delivery stream as it attempts to send the records to the destination.
/// If the destination is unreachable for more than 24 hours, the data is no longer available.
/// </para>
/// </summary>
/// <param name="deliveryStreamName">The name of the delivery stream.</param>
/// <param name="records">One or more records.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the PutRecordBatch service method, as returned by KinesisFirehose.</returns>
/// <exception cref="Amazon.KinesisFirehose.Model.InvalidArgumentException">
/// The specified input parameter has a value that is not valid.
/// </exception>
/// <exception cref="Amazon.KinesisFirehose.Model.ResourceNotFoundException">
/// The specified resource could not be found.
/// </exception>
/// <exception cref="Amazon.KinesisFirehose.Model.ServiceUnavailableException">
/// The service is unavailable, back off and retry the operation. If you continue to see
/// the exception, throughput limits for the delivery stream may have been exceeded. For
/// more information about limits and how to request an increase, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
/// Kinesis Firehose Limits</a>.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/PutRecordBatch">REST API Reference for PutRecordBatch Operation</seealso>
public virtual void PutRecordBatchAsync(string deliveryStreamName, List <Record> records, AmazonServiceCallback <PutRecordBatchRequest, PutRecordBatchResponse> callback, AsyncOptions options = null)
{
var request = new PutRecordBatchRequest();
request.DeliveryStreamName = deliveryStreamName;
request.Records = records;
PutRecordBatchAsync(request, callback, options);
}
/// <summary>
/// Sets the request payment configuration for a bucket. By default, the bucket owner
/// pays for downloads from the bucket. This configuration parameter enables the bucket
/// owner (only) to specify that the person requesting the download will be charged for
/// the download. Documentation on requester pays buckets can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of PutBucketRequestPaymentRequest used to execute the PutBucketRequestPayment service method.</param>
/// <param name="requestPaymentConfiguration">A property of PutBucketRequestPaymentRequest used to execute the PutBucketRequestPayment service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the PutBucketRequestPayment service method, as returned by S3.</returns>
public void PutBucketRequestPaymentAsync(string bucketName, RequestPaymentConfiguration requestPaymentConfiguration, AmazonServiceCallback<PutBucketRequestPaymentRequest, PutBucketRequestPaymentResponse> callback, AsyncOptions options = null)
{
var request = new PutBucketRequestPaymentRequest();
request.BucketName = bucketName;
request.RequestPaymentConfiguration = requestPaymentConfiguration;
PutBucketRequestPaymentAsync(request, callback, options);
}
public void AssumeRoleWithWebIdentityAsync(AssumeRoleWithWebIdentityRequest request, AmazonServiceCallback <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> callback, AsyncOptions options = null)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
options = ((options == null) ? ((object)new AsyncOptions()) : ((object)options));
AssumeRoleWithWebIdentityRequestMarshaller assumeRoleWithWebIdentityRequestMarshaller = new AssumeRoleWithWebIdentityRequestMarshaller();
AssumeRoleWithWebIdentityResponseUnmarshaller instance = AssumeRoleWithWebIdentityResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> action = null;
if (callback != null)
{
action = delegate(AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao)
{
AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> val = new AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse>((AssumeRoleWithWebIdentityRequest)req, (AssumeRoleWithWebIdentityResponse)res, ex, ao.get_State());
callback.Invoke(val);
};
}
this.BeginInvoke <AssumeRoleWithWebIdentityRequest>(request, assumeRoleWithWebIdentityRequestMarshaller, instance, options, action);
}
/// <summary>
/// Creates a copy of an object that is already stored in Amazon S3.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="sourceBucket">A property of CopyObjectRequest used to execute the CopyObject service method.</param>
/// <param name="sourceKey">A property of CopyObjectRequest used to execute the CopyObject service method.</param>
/// <param name="destinationBucket">A property of CopyObjectRequest used to execute the CopyObject service method.</param>
/// <param name="destinationKey">A property of CopyObjectRequest used to execute the CopyObject service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the CopyObject service method, as returned by S3.</returns>
public void CopyObjectAsync(string sourceBucket, string sourceKey, string destinationBucket, string destinationKey, AmazonServiceCallback<CopyObjectRequest, CopyObjectResponse> callback, AsyncOptions options = null)
{
var request = new CopyObjectRequest();
request.SourceBucket = sourceBucket;
request.SourceKey = sourceKey;
request.DestinationBucket = destinationBucket;
request.DestinationKey = destinationKey;
CopyObjectAsync(request, callback, options);
}
public void DecodeAuthorizationMessageAsync(DecodeAuthorizationMessageRequest request, AmazonServiceCallback <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> callback, AsyncOptions options = null)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
options = ((options == null) ? ((object)new AsyncOptions()) : ((object)options));
DecodeAuthorizationMessageRequestMarshaller decodeAuthorizationMessageRequestMarshaller = new DecodeAuthorizationMessageRequestMarshaller();
DecodeAuthorizationMessageResponseUnmarshaller instance = DecodeAuthorizationMessageResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> action = null;
if (callback != null)
{
action = delegate(AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao)
{
AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> val = new AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse>((DecodeAuthorizationMessageRequest)req, (DecodeAuthorizationMessageResponse)res, ex, ao.get_State());
callback.Invoke(val);
};
}
this.BeginInvoke <DecodeAuthorizationMessageRequest>(request, decodeAuthorizationMessageRequestMarshaller, instance, options, action);
}
/// <summary>
/// Sets lifecycle configuration for your bucket. If a lifecycle configuration exists,
/// it replaces it.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of PutLifecycleConfigurationRequest used to execute the PutLifecycleConfiguration service method.</param>
/// <param name="configuration">A property of PutLifecycleConfigurationRequest used to execute the PutLifecycleConfiguration service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the PutLifecycleConfiguration service method, as returned by S3.</returns>
public void PutLifecycleConfigurationAsync(string bucketName, LifecycleConfiguration configuration, AmazonServiceCallback<PutLifecycleConfigurationRequest, PutLifecycleConfigurationResponse> callback, AsyncOptions options = null)
{
var request = new PutLifecycleConfigurationRequest();
request.BucketName = bucketName;
request.Configuration = configuration;
PutLifecycleConfigurationAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the EnableEnhancedMonitoring operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the EnableEnhancedMonitoring operation on AmazonKinesisClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void EnableEnhancedMonitoringAsync(EnableEnhancedMonitoringRequest request, AmazonServiceCallback <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new EnableEnhancedMonitoringRequestMarshaller();
var unmarshaller = EnableEnhancedMonitoringResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse> responseObject
= new AmazonServiceResult <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse>((EnableEnhancedMonitoringRequest)req, (EnableEnhancedMonitoringResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <EnableEnhancedMonitoringRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Uploads a part by copying data from an existing object as data source.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="sourceBucket">A property of CopyPartRequest used to execute the CopyPart service method.</param>
/// <param name="sourceKey">A property of CopyPartRequest used to execute the CopyPart service method.</param>
/// <param name="sourceVersionId">A property of CopyPartRequest used to execute the CopyPart service method.</param>
/// <param name="destinationBucket">A property of CopyPartRequest used to execute the CopyPart service method.</param>
/// <param name="destinationKey">A property of CopyPartRequest used to execute the CopyPart service method.</param>
/// <param name="uploadId">Upload ID identifying the multipart upload whose part is being copied.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the CopyPart service method, as returned by S3.</returns>
public void CopyPartAsync(string sourceBucket, string sourceKey, string sourceVersionId, string destinationBucket, string destinationKey, string uploadId, AmazonServiceCallback<CopyPartRequest, CopyPartResponse> callback, AsyncOptions options = null)
{
var request = new CopyPartRequest();
request.SourceBucket = sourceBucket;
request.SourceKey = sourceKey;
request.SourceVersionId = sourceVersionId;
request.DestinationBucket = destinationBucket;
request.DestinationKey = destinationKey;
request.UploadId = uploadId;
CopyPartAsync(request, callback, options);
}
/// <summary>
/// Increases the Amazon Kinesis stream's retention period, which is the length of time
/// data records are accessible after they are added to the stream. The maximum value
/// of a stream's retention period is 168 hours (7 days).
///
///
/// <para>
/// Upon choosing a longer stream retention period, this operation will increase the time
/// period records are accessible that have not yet expired. However, it will not make
/// previous data that has expired (older than the stream's previous retention period)
/// accessible after the operation has been called. For example, if a stream's retention
/// period is set to 24 hours and is increased to 168 hours, any data that is older than
/// 24 hours will remain inaccessible to consumer applications.
/// </para>
/// </summary>
/// <param name="streamName">The name of the stream to modify.</param>
/// <param name="retentionPeriodHours">The new retention period of the stream, in hours. Must be more than the current retention period.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the IncreaseStreamRetentionPeriod service method, as returned by Kinesis.</returns>
/// <exception cref="Amazon.Kinesis.Model.InvalidArgumentException">
/// A specified parameter exceeds its restrictions, is not supported, or can't be used.
/// For more information, see the returned message.
/// </exception>
/// <exception cref="Amazon.Kinesis.Model.LimitExceededException">
/// The requested resource exceeds the maximum number allowed, or the number of concurrent
/// stream requests exceeds the maximum number allowed (5).
/// </exception>
/// <exception cref="Amazon.Kinesis.Model.ResourceInUseException">
/// The resource is not available for this operation. For successful operation, the resource
/// needs to be in the <code>ACTIVE</code> state.
/// </exception>
/// <exception cref="Amazon.Kinesis.Model.ResourceNotFoundException">
/// The requested resource could not be found. The stream might not be specified correctly,
/// or it might not be in the <code>ACTIVE</code> state if the operation requires it.
/// </exception>
public void IncreaseStreamRetentionPeriodAsync(string streamName, int retentionPeriodHours, AmazonServiceCallback <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> callback, AsyncOptions options = null)
{
var request = new IncreaseStreamRetentionPeriodRequest();
request.StreamName = streamName;
request.RetentionPeriodHours = retentionPeriodHours;
IncreaseStreamRetentionPeriodAsync(request, callback, options);
}
/// <summary>
/// Deletes the lifecycle configuration from the bucket.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of DeleteLifecycleConfigurationRequest used to execute the DeleteLifecycleConfiguration service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the DeleteLifecycleConfiguration service method, as returned by S3.</returns>
public void DeleteLifecycleConfigurationAsync(string bucketName, AmazonServiceCallback<DeleteLifecycleConfigurationRequest, DeleteLifecycleConfigurationResponse> callback, AsyncOptions options = null)
{
var request = new DeleteLifecycleConfigurationRequest();
request.BucketName = bucketName;
DeleteLifecycleConfigurationAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the IncreaseStreamRetentionPeriod operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the IncreaseStreamRetentionPeriod operation on AmazonKinesisClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void IncreaseStreamRetentionPeriodAsync(IncreaseStreamRetentionPeriodRequest request, AmazonServiceCallback <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new IncreaseStreamRetentionPeriodRequestMarshaller();
var unmarshaller = IncreaseStreamRetentionPeriodResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> responseObject
= new AmazonServiceResult <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse>((IncreaseStreamRetentionPeriodRequest)req, (IncreaseStreamRetentionPeriodResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <IncreaseStreamRetentionPeriodRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteObject operation.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value for this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteObject operation on AmazonS3Client.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void DeleteObjectAsync(DeleteObjectRequest request, AmazonServiceCallback<DeleteObjectRequest, DeleteObjectResponse> callback, AsyncOptions options = null)
{
if (AWSConfigs.HttpClient == AWSConfigs.HttpClientOption.UnityWWW)
{
throw new InvalidOperationException("DeleteObject is only allowed with AWSConfigs.HttpClientOption.UnityWebRequest API option");
}
options = options == null?new AsyncOptions():options;
var marshaller = new DeleteObjectRequestMarshaller();
var unmarshaller = DeleteObjectResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<DeleteObjectRequest,DeleteObjectResponse> responseObject
= new AmazonServiceResult<DeleteObjectRequest,DeleteObjectResponse>((DeleteObjectRequest)req, (DeleteObjectResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<DeleteObjectRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Lists your Amazon Kinesis streams.
///
///
/// <para>
/// The number of streams may be too large to return from a single call to <code>ListStreams</code>.
/// You can limit the number of returned streams using the <code>Limit</code> parameter.
/// If you do not specify a value for the <code>Limit</code> parameter, Amazon Kinesis
/// uses the default limit, which is currently 10.
/// </para>
///
/// <para>
/// You can detect if there are more streams available to list by using the <code>HasMoreStreams</code>
/// flag from the returned output. If there are more streams available, you can request
/// more streams by using the name of the last stream returned by the <code>ListStreams</code>
/// request in the <code>ExclusiveStartStreamName</code> parameter in a subsequent request
/// to <code>ListStreams</code>. The group of stream names returned by the subsequent
/// request is then added to the list. You can continue this process until all the stream
/// names have been collected in the list.
/// </para>
///
/// <para>
/// <a>ListStreams</a> has a limit of 5 transactions per second per account.
/// </para>
/// </summary>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the ListStreams service method, as returned by Kinesis.</returns>
/// <exception cref="Amazon.Kinesis.Model.LimitExceededException">
/// The requested resource exceeds the maximum number allowed, or the number of concurrent
/// stream requests exceeds the maximum number allowed (5).
/// </exception>
public void ListStreamsAsync(AmazonServiceCallback <ListStreamsRequest, ListStreamsResponse> callback, AsyncOptions options = null)
{
ListStreamsAsync(new ListStreamsRequest(), callback, options);
}
/// <summary>
/// Sets the roles for an identity pool. These roles are used when making calls to <code>GetCredentialsForIdentity</code>
/// action.
/// </summary>
/// <param name="identityPoolId">An identity pool ID in the format REGION:GUID.</param>
/// <param name="roles">The map of roles associated with this pool. Currently only authenticated and unauthenticated roles are supported.</param>
///
/// <returns>The response from the SetIdentityPoolRoles service method, as returned by CognitoIdentity.</returns>
/// <exception cref="Amazon.CognitoIdentity.Model.InternalErrorException">
/// Thrown when the service encounters an error during processing the request.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.InvalidParameterException">
/// Thrown for missing or bad input parameter(s).
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceConflictException">
/// Thrown when a user tries to use a login which is already linked to another account.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceNotFoundException">
/// Thrown when the requested resource (for example, a dataset or record) does not exist.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.TooManyRequestsException">
/// Thrown when a request is throttled.
/// </exception>
public void SetIdentityPoolRolesAsync(string identityPoolId, Dictionary<string, string> roles, AmazonServiceCallback<SetIdentityPoolRolesRequest, SetIdentityPoolRolesResponse> callback, AsyncOptions options = null)
{
var request = new SetIdentityPoolRolesRequest();
request.IdentityPoolId = identityPoolId;
request.Roles = roles;
SetIdentityPoolRolesAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the AssumeRoleWithWebIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the AssumeRoleWithWebIdentity operation on AmazonSecurityTokenServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void AssumeRoleWithWebIdentityAsync(AssumeRoleWithWebIdentityRequest request, AmazonServiceCallback <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new AssumeRoleWithWebIdentityRequestMarshaller();
var unmarshaller = AssumeRoleWithWebIdentityResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> responseObject
= new AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse>((AssumeRoleWithWebIdentityRequest)req, (AssumeRoleWithWebIdentityResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <AssumeRoleWithWebIdentityRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Gets an OpenID token, using a known Cognito ID. This known Cognito ID is returned
/// by <a>GetId</a>. You can optionally add additional logins for the identity. Supplying
/// multiple logins creates an implicit link.
///
///
/// <para>
/// The OpenId token is valid for 15 minutes.
/// </para>
/// </summary>
/// <param name="identityId">A unique identifier in the format REGION:GUID.</param>
///
/// <returns>The response from the GetOpenIdToken service method, as returned by CognitoIdentity.</returns>
/// <exception cref="Amazon.CognitoIdentity.Model.InternalErrorException">
/// Thrown when the service encounters an error during processing the request.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.InvalidParameterException">
/// Thrown for missing or bad input parameter(s).
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceConflictException">
/// Thrown when a user tries to use a login which is already linked to another account.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceNotFoundException">
/// Thrown when the requested resource (for example, a dataset or record) does not exist.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.TooManyRequestsException">
/// Thrown when a request is throttled.
/// </exception>
public void GetOpenIdTokenAsync(string identityId, AmazonServiceCallback<GetOpenIdTokenRequest, GetOpenIdTokenResponse> callback, AsyncOptions options = null)
{
var request = new GetOpenIdTokenRequest();
request.IdentityId = identityId;
GetOpenIdTokenAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DecodeAuthorizationMessage operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DecodeAuthorizationMessage operation on AmazonSecurityTokenServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void DecodeAuthorizationMessageAsync(DecodeAuthorizationMessageRequest request, AmazonServiceCallback <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new DecodeAuthorizationMessageRequestMarshaller();
var unmarshaller = DecodeAuthorizationMessageResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> responseObject
= new AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse>((DecodeAuthorizationMessageRequest)req, (DecodeAuthorizationMessageResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <DecodeAuthorizationMessageRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Gets usage details (for example, data storage) about a particular identity pool.
///
///
/// <para>
/// This API can only be called with developer credentials. You cannot call this API with
/// the temporary user credentials provided by Cognito Identity.
/// </para>
/// </summary>
/// <param name="identityPoolId">A name-spaced GUID (for example, us-east-1:23EC4050-6AEA-7089-A2DD-08002EXAMPLE) created by Amazon Cognito. GUID generation is unique within a region.</param>
/// <param name="options">
/// 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>The response from the DescribeIdentityPoolUsage service method, as returned by CognitoSync.</returns>
/// <exception cref="Amazon.CognitoSync.Model.InternalErrorException">
/// Indicates an internal service error.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.InvalidParameterException">
/// Thrown when a request parameter does not comply with the associated constraints.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.ResourceNotFoundException">
/// Thrown if the resource doesn't exist.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.TooManyRequestsException">
/// Thrown if the request is throttled.
/// </exception>
public void DescribeIdentityPoolUsageAsync(string identityPoolId, AmazonServiceCallback<DescribeIdentityPoolUsageRequest, DescribeIdentityPoolUsageResponse> callback, AsyncOptions options = null)
{
var request = new DescribeIdentityPoolUsageRequest();
request.IdentityPoolId = identityPoolId;
DescribeIdentityPoolUsageAsync(request, callback, options);
}
/// <summary>
/// Returns a set of temporary credentials for an AWS account or IAM user. The credentials
/// consist of an access key ID, a secret access key, and a security token. Typically,
/// you use <code>GetSessionToken</code> if you want to use MFA to protect programmatic
/// calls to specific AWS APIs like Amazon EC2 <code>StopInstances</code>. MFA-enabled
/// IAM users would need to call <code>GetSessionToken</code> and submit an MFA code that
/// is associated with their MFA device. Using the temporary security credentials that
/// are returned from the call, IAM users can then make programmatic calls to APIs that
/// require MFA authentication. If you do not supply a correct MFA code, then the API
/// returns an access denied error.
///
///
/// <para>
/// The <code>GetSessionToken</code> action must be called by using the long-term AWS
/// security credentials of the AWS account or an IAM user. Credentials that are created
/// by IAM users are valid for the duration that you specify, between 900 seconds (15
/// minutes) and 129600 seconds (36 hours); credentials that are created by using account
/// credentials have a maximum duration of 3600 seconds (1 hour).
/// </para>
/// <note>
/// <para>
/// We recommend that you do not call <code>GetSessionToken</code> with root account credentials.
/// Instead, follow our <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users">best
/// practices</a> by creating one or more IAM users, giving them the necessary permissions,
/// and using IAM users for everyday interaction with AWS.
/// </para>
/// </note>
/// <para>
/// The permissions associated with the temporary security credentials returned by <code>GetSessionToken</code>
/// are based on the permissions associated with account or IAM user whose credentials
/// are used to call the action. If <code>GetSessionToken</code> is called using root
/// account credentials, the temporary credentials have root account permissions. Similarly,
/// if <code>GetSessionToken</code> is called using the credentials of an IAM user, the
/// temporary credentials have the same permissions as the IAM user.
/// </para>
///
/// <para>
/// For more information about using <code>GetSessionToken</code> to create temporary
/// credentials, go to <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getsessiontoken">Temporary
/// Credentials for Users in Untrusted Environments</a> in the <i>Using IAM</i>.
/// </para>
/// </summary>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>The response from the GetSessionToken service method, as returned by SecurityTokenService.</returns>
/// <exception cref="Amazon.SecurityToken.Model.RegionDisabledException">
/// STS is not activated in the requested region for the account that is being asked to
/// create temporary credentials. The account administrator must activate STS in that
/// region using the IAM Console. For more information, see <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html">Activating
/// and Deactivating AWS STS in an AWS Region</a> in the <i>Using IAM</i>.
/// </exception>
public void GetSessionTokenAsync(AmazonServiceCallback <GetSessionTokenRequest, GetSessionTokenResponse> callback, AsyncOptions options = null)
{
GetSessionTokenAsync(new GetSessionTokenRequest(), callback, options);
}
/// <summary>
/// Gets the configuration settings of an identity pool.
///
///
/// <para>
/// This API can only be called with developer credentials. You cannot call this API with
/// the temporary user credentials provided by Cognito Identity.
/// </para>
/// </summary>
/// <param name="identityPoolId">A name-spaced GUID (for example, us-east-1:23EC4050-6AEA-7089-A2DD-08002EXAMPLE) created by Amazon Cognito. This is the ID of the pool for which to return a configuration.</param>
/// <param name="options">
/// 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>The response from the GetIdentityPoolConfiguration service method, as returned by CognitoSync.</returns>
/// <exception cref="Amazon.CognitoSync.Model.InternalErrorException">
/// Indicates an internal service error.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.InvalidParameterException">
/// Thrown when a request parameter does not comply with the associated constraints.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.ResourceNotFoundException">
/// Thrown if the resource doesn't exist.
/// </exception>
/// <exception cref="Amazon.CognitoSync.Model.TooManyRequestsException">
/// Thrown if the request is throttled.
/// </exception>
public void GetIdentityPoolConfigurationAsync(string identityPoolId, AmazonServiceCallback<GetIdentityPoolConfigurationRequest, GetIdentityPoolConfigurationResponse> callback, AsyncOptions options = null)
{
var request = new GetIdentityPoolConfigurationRequest();
request.IdentityPoolId = identityPoolId;
GetIdentityPoolConfigurationAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetOpenIdTokenForDeveloperIdentity operation.
/// <seealso cref="Amazon.CognitoIdentity.IAmazonCognitoIdentity"/>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetOpenIdTokenForDeveloperIdentity operation.</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>void</returns>
public void GetOpenIdTokenForDeveloperIdentityAsync(GetOpenIdTokenForDeveloperIdentityRequest request, AmazonServiceCallback callback, object state)
{
if (!AmazonInitializer.IsInitialized)
{
throw new Exception("AWSPrefab is not added to the scene");
}
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
var marshaller = new GetOpenIdTokenForDeveloperIdentityRequestMarshaller();
var unmarshaller = GetOpenIdTokenForDeveloperIdentityResponseUnmarshaller.Instance;
Invoke(request, callback, state, marshaller, unmarshaller, signer);
}));
return;
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateRecords operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateRecords operation on AmazonCognitoSyncClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void UpdateRecordsAsync(UpdateRecordsRequest request, AmazonServiceCallback<UpdateRecordsRequest, UpdateRecordsResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new UpdateRecordsRequestMarshaller();
var unmarshaller = UpdateRecordsResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<UpdateRecordsRequest,UpdateRecordsResponse> responseObject
= new AmazonServiceResult<UpdateRecordsRequest,UpdateRecordsResponse>((UpdateRecordsRequest)req, (UpdateRecordsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<UpdateRecordsRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
public void PutScalingPolicyAsync(PutScalingPolicyRequest request, AmazonServiceCallback <PutScalingPolicyRequest, PutScalingPolicyResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
