/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the gamesparks-2021-08-17.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.GameSparks.Model; using Amazon.GameSparks.Model.Internal.MarshallTransformations; using Amazon.GameSparks.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.GameSparks { ///

/// Implementation for accessing GameSparks /// /// ///

public partial class AmazonGameSparksClient : AmazonServiceClient, IAmazonGameSparks { private static IServiceMetadata serviceMetadata = new AmazonGameSparksMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IGameSparksPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IGameSparksPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new GameSparksPaginatorFactory(this); } return this._paginators; } } #endif #region Constructors ///

/// Constructs AmazonGameSparksClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonGameSparksClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonGameSparksConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonGameSparksClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonGameSparksConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonGameSparksClient Configuration Object public AmazonGameSparksClient(AmazonGameSparksConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonGameSparksClient with AWS Credentials ///

/// AWS Credentials public AmazonGameSparksClient(AWSCredentials credentials) : this(credentials, new AmazonGameSparksConfig()) { } ///

/// Constructs AmazonGameSparksClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonGameSparksClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonGameSparksConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonGameSparksClient with AWS Credentials and an /// AmazonGameSparksClient Configuration object. ///

/// AWS Credentials /// The AmazonGameSparksClient Configuration Object public AmazonGameSparksClient(AWSCredentials credentials, AmazonGameSparksConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonGameSparksClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonGameSparksClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonGameSparksConfig()) { } ///

/// Constructs AmazonGameSparksClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonGameSparksClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonGameSparksConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonGameSparksClient with AWS Access Key ID, AWS Secret Key and an /// AmazonGameSparksClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonGameSparksClient Configuration Object public AmazonGameSparksClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonGameSparksConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonGameSparksClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonGameSparksClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonGameSparksConfig()) { } ///

/// Constructs AmazonGameSparksClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonGameSparksClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonGameSparksConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonGameSparksClient with AWS Access Key ID, AWS Secret Key and an /// AmazonGameSparksClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonGameSparksClient Configuration Object public AmazonGameSparksClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonGameSparksConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonGameSparksEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region CreateGame ///

/// Creates a new game with an empty configuration. After creating your game, you can /// update the configuration using UpdateGameConfiguration or ImportGameConfiguration. ///

/// Container for the necessary parameters to execute the CreateGame service method. /// /// The response from the CreateGame service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The resource already exists, or another operation is in progress. /// /// /// The service encountered an internal error. /// /// /// The request would result in exceeding service quota. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for CreateGame Operation public virtual CreateGameResponse CreateGame(CreateGameRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGameRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGameResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateGame operation. ///

/// /// Container for the necessary parameters to execute the CreateGame operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateGame /// operation. /// REST API Reference for CreateGame Operation public virtual IAsyncResult BeginCreateGame(CreateGameRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGameRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGameResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateGame operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateGame. /// /// Returns a CreateGameResult from GameSparks. /// REST API Reference for CreateGame Operation public virtual CreateGameResponse EndCreateGame(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSnapshot ///

/// Creates a snapshot of the game configuration. ///

/// Container for the necessary parameters to execute the CreateSnapshot service method. /// /// The response from the CreateSnapshot service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The resource already exists, or another operation is in progress. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateSnapshot operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSnapshot /// operation. /// REST API Reference for CreateSnapshot Operation public virtual IAsyncResult BeginCreateSnapshot(CreateSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateSnapshot. /// /// Returns a CreateSnapshotResult from GameSparks. /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse EndCreateSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateStage ///

/// Creates a new stage for stage-by-stage game development and deployment. ///

/// Container for the necessary parameters to execute the CreateStage service method. /// /// The response from the CreateStage service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The resource already exists, or another operation is in progress. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for CreateStage Operation public virtual CreateStageResponse CreateStage(CreateStageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateStageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateStageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateStage operation. ///

/// /// Container for the necessary parameters to execute the CreateStage operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateStage /// operation. /// REST API Reference for CreateStage Operation public virtual IAsyncResult BeginCreateStage(CreateStageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateStageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateStageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateStage operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateStage. /// /// Returns a CreateStageResult from GameSparks. /// REST API Reference for CreateStage Operation public virtual CreateStageResponse EndCreateStage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteGame ///

/// Deletes a game. ///

/// Container for the necessary parameters to execute the DeleteGame service method. /// /// The response from the DeleteGame service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The resource already exists, or another operation is in progress. /// /// /// The service encountered an internal error. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for DeleteGame Operation public virtual DeleteGameResponse DeleteGame(DeleteGameRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteGameRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteGameResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteGame operation. ///

/// /// Container for the necessary parameters to execute the DeleteGame operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteGame /// operation. /// REST API Reference for DeleteGame Operation public virtual IAsyncResult BeginDeleteGame(DeleteGameRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteGameRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteGameResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteGame operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteGame. /// /// Returns a DeleteGameResult from GameSparks. /// REST API Reference for DeleteGame Operation public virtual DeleteGameResponse EndDeleteGame(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteStage ///

/// Deletes a stage from a game, along with the associated game runtime. ///

/// Container for the necessary parameters to execute the DeleteStage service method. /// /// The response from the DeleteStage service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The resource already exists, or another operation is in progress. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for DeleteStage Operation public virtual DeleteStageResponse DeleteStage(DeleteStageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteStageRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteStageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteStage operation. ///

/// /// Container for the necessary parameters to execute the DeleteStage operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteStage /// operation. /// REST API Reference for DeleteStage Operation public virtual IAsyncResult BeginDeleteStage(DeleteStageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteStageRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteStageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteStage operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteStage. /// /// Returns a DeleteStageResult from GameSparks. /// REST API Reference for DeleteStage Operation public virtual DeleteStageResponse EndDeleteStage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisconnectPlayer ///

/// Disconnects a player from the game runtime. /// /// /// /// If a player has multiple connections, this operation attempts to close all of them. /// /// ///

/// Container for the necessary parameters to execute the DisconnectPlayer service method. /// /// The response from the DisconnectPlayer service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for DisconnectPlayer Operation public virtual DisconnectPlayerResponse DisconnectPlayer(DisconnectPlayerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisconnectPlayerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisconnectPlayerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisconnectPlayer operation. ///

/// /// Container for the necessary parameters to execute the DisconnectPlayer operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisconnectPlayer /// operation. /// REST API Reference for DisconnectPlayer Operation public virtual IAsyncResult BeginDisconnectPlayer(DisconnectPlayerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisconnectPlayerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisconnectPlayerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisconnectPlayer operation. ///

/// /// The IAsyncResult returned by the call to BeginDisconnectPlayer. /// /// Returns a DisconnectPlayerResult from GameSparks. /// REST API Reference for DisconnectPlayer Operation public virtual DisconnectPlayerResponse EndDisconnectPlayer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ExportSnapshot ///

/// Exports a game configuration snapshot. ///

/// Container for the necessary parameters to execute the ExportSnapshot service method. /// /// The response from the ExportSnapshot service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ExportSnapshot Operation public virtual ExportSnapshotResponse ExportSnapshot(ExportSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ExportSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ExportSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ExportSnapshot operation. ///

/// /// Container for the necessary parameters to execute the ExportSnapshot operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExportSnapshot /// operation. /// REST API Reference for ExportSnapshot Operation public virtual IAsyncResult BeginExportSnapshot(ExportSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ExportSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ExportSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ExportSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginExportSnapshot. /// /// Returns a ExportSnapshotResult from GameSparks. /// REST API Reference for ExportSnapshot Operation public virtual ExportSnapshotResponse EndExportSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetExtension ///

/// Gets details about a specified extension. ///

/// Container for the necessary parameters to execute the GetExtension service method. /// /// The response from the GetExtension service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetExtension Operation public virtual GetExtensionResponse GetExtension(GetExtensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExtensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetExtension operation. ///

/// /// Container for the necessary parameters to execute the GetExtension operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetExtension /// operation. /// REST API Reference for GetExtension Operation public virtual IAsyncResult BeginGetExtension(GetExtensionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExtensionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetExtension operation. ///

/// /// The IAsyncResult returned by the call to BeginGetExtension. /// /// Returns a GetExtensionResult from GameSparks. /// REST API Reference for GetExtension Operation public virtual GetExtensionResponse EndGetExtension(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetExtensionVersion ///

/// Gets details about a specified extension version. ///

/// Container for the necessary parameters to execute the GetExtensionVersion service method. /// /// The response from the GetExtensionVersion service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetExtensionVersion Operation public virtual GetExtensionVersionResponse GetExtensionVersion(GetExtensionVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetExtensionVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExtensionVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetExtensionVersion operation. ///

/// /// Container for the necessary parameters to execute the GetExtensionVersion operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetExtensionVersion /// operation. /// REST API Reference for GetExtensionVersion Operation public virtual IAsyncResult BeginGetExtensionVersion(GetExtensionVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetExtensionVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExtensionVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetExtensionVersion operation. ///

/// /// The IAsyncResult returned by the call to BeginGetExtensionVersion. /// /// Returns a GetExtensionVersionResult from GameSparks. /// REST API Reference for GetExtensionVersion Operation public virtual GetExtensionVersionResponse EndGetExtensionVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetGame ///

/// Gets details about a game. ///

/// Container for the necessary parameters to execute the GetGame service method. /// /// The response from the GetGame service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetGame Operation public virtual GetGameResponse GetGame(GetGameRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetGameRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGameResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetGame operation. ///

/// /// Container for the necessary parameters to execute the GetGame operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetGame /// operation. /// REST API Reference for GetGame Operation public virtual IAsyncResult BeginGetGame(GetGameRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetGameRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGameResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetGame operation. ///

/// /// The IAsyncResult returned by the call to BeginGetGame. /// /// Returns a GetGameResult from GameSparks. /// REST API Reference for GetGame Operation public virtual GetGameResponse EndGetGame(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetGameConfiguration ///

/// Gets the configuration of the game. ///

/// Container for the necessary parameters to execute the GetGameConfiguration service method. /// /// The response from the GetGameConfiguration service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetGameConfiguration Operation public virtual GetGameConfigurationResponse GetGameConfiguration(GetGameConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetGameConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGameConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetGameConfiguration operation. ///

/// /// Container for the necessary parameters to execute the GetGameConfiguration operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetGameConfiguration /// operation. /// REST API Reference for GetGameConfiguration Operation public virtual IAsyncResult BeginGetGameConfiguration(GetGameConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetGameConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGameConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetGameConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginGetGameConfiguration. /// /// Returns a GetGameConfigurationResult from GameSparks. /// REST API Reference for GetGameConfiguration Operation public virtual GetGameConfigurationResponse EndGetGameConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetGeneratedCodeJob ///

/// Gets details about a job that is generating code for a snapshot. ///

/// Container for the necessary parameters to execute the GetGeneratedCodeJob service method. /// /// The response from the GetGeneratedCodeJob service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetGeneratedCodeJob Operation public virtual GetGeneratedCodeJobResponse GetGeneratedCodeJob(GetGeneratedCodeJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetGeneratedCodeJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGeneratedCodeJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetGeneratedCodeJob operation. ///

/// /// Container for the necessary parameters to execute the GetGeneratedCodeJob operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetGeneratedCodeJob /// operation. /// REST API Reference for GetGeneratedCodeJob Operation public virtual IAsyncResult BeginGetGeneratedCodeJob(GetGeneratedCodeJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetGeneratedCodeJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGeneratedCodeJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetGeneratedCodeJob operation. ///

/// /// The IAsyncResult returned by the call to BeginGetGeneratedCodeJob. /// /// Returns a GetGeneratedCodeJobResult from GameSparks. /// REST API Reference for GetGeneratedCodeJob Operation public virtual GetGeneratedCodeJobResponse EndGetGeneratedCodeJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetPlayerConnectionStatus ///

/// Gets the status of a player's connection to the game runtime. /// /// /// /// It's possible for a single player to have multiple connections to the game runtime. /// If a player is not connected, this operation returns an empty list. /// ///

/// Container for the necessary parameters to execute the GetPlayerConnectionStatus service method. /// /// The response from the GetPlayerConnectionStatus service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetPlayerConnectionStatus Operation public virtual GetPlayerConnectionStatusResponse GetPlayerConnectionStatus(GetPlayerConnectionStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetPlayerConnectionStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPlayerConnectionStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetPlayerConnectionStatus operation. ///

/// /// Container for the necessary parameters to execute the GetPlayerConnectionStatus operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetPlayerConnectionStatus /// operation. /// REST API Reference for GetPlayerConnectionStatus Operation public virtual IAsyncResult BeginGetPlayerConnectionStatus(GetPlayerConnectionStatusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetPlayerConnectionStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPlayerConnectionStatusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetPlayerConnectionStatus operation. ///

/// /// The IAsyncResult returned by the call to BeginGetPlayerConnectionStatus. /// /// Returns a GetPlayerConnectionStatusResult from GameSparks. /// REST API Reference for GetPlayerConnectionStatus Operation public virtual GetPlayerConnectionStatusResponse EndGetPlayerConnectionStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSnapshot ///

/// Gets a copy of the game configuration in a snapshot. ///

/// Container for the necessary parameters to execute the GetSnapshot service method. /// /// The response from the GetSnapshot service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetSnapshot Operation public virtual GetSnapshotResponse GetSnapshot(GetSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetSnapshot operation. ///

/// /// Container for the necessary parameters to execute the GetSnapshot operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSnapshot /// operation. /// REST API Reference for GetSnapshot Operation public virtual IAsyncResult BeginGetSnapshot(GetSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginGetSnapshot. /// /// Returns a GetSnapshotResult from GameSparks. /// REST API Reference for GetSnapshot Operation public virtual GetSnapshotResponse EndGetSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetStage ///

/// Gets information about a stage. ///

/// Container for the necessary parameters to execute the GetStage service method. /// /// The response from the GetStage service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetStage Operation public virtual GetStageResponse GetStage(GetStageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetStageRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetStage operation. ///

/// /// Container for the necessary parameters to execute the GetStage operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetStage /// operation. /// REST API Reference for GetStage Operation public virtual IAsyncResult BeginGetStage(GetStageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetStageRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetStage operation. ///

/// /// The IAsyncResult returned by the call to BeginGetStage. /// /// Returns a GetStageResult from GameSparks. /// REST API Reference for GetStage Operation public virtual GetStageResponse EndGetStage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetStageDeployment ///

/// Gets information about a stage deployment. ///

/// Container for the necessary parameters to execute the GetStageDeployment service method. /// /// The response from the GetStageDeployment service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for GetStageDeployment Operation public virtual GetStageDeploymentResponse GetStageDeployment(GetStageDeploymentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetStageDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStageDeploymentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetStageDeployment operation. ///

/// /// Container for the necessary parameters to execute the GetStageDeployment operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetStageDeployment /// operation. /// REST API Reference for GetStageDeployment Operation public virtual IAsyncResult BeginGetStageDeployment(GetStageDeploymentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetStageDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetStageDeploymentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetStageDeployment operation. ///

/// /// The IAsyncResult returned by the call to BeginGetStageDeployment. /// /// Returns a GetStageDeploymentResult from GameSparks. /// REST API Reference for GetStageDeployment Operation public virtual GetStageDeploymentResponse EndGetStageDeployment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ImportGameConfiguration ///

/// Imports a game configuration. /// /// /// /// This operation replaces the current configuration of the game with the provided input. /// This is not a reversible operation. If you want to preserve the previous configuration, /// use CreateSnapshot to make a new snapshot before importing. /// ///

/// Container for the necessary parameters to execute the ImportGameConfiguration service method. /// /// The response from the ImportGameConfiguration service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request would result in exceeding service quota. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ImportGameConfiguration Operation public virtual ImportGameConfigurationResponse ImportGameConfiguration(ImportGameConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ImportGameConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ImportGameConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ImportGameConfiguration operation. ///

/// /// Container for the necessary parameters to execute the ImportGameConfiguration operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportGameConfiguration /// operation. /// REST API Reference for ImportGameConfiguration Operation public virtual IAsyncResult BeginImportGameConfiguration(ImportGameConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ImportGameConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ImportGameConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ImportGameConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginImportGameConfiguration. /// /// Returns a ImportGameConfigurationResult from GameSparks. /// REST API Reference for ImportGameConfiguration Operation public virtual ImportGameConfigurationResponse EndImportGameConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListExtensions ///

/// Gets a paginated list of available extensions. /// /// /// /// Extensions provide features that games can use from scripts. /// ///

/// Container for the necessary parameters to execute the ListExtensions service method. /// /// The response from the ListExtensions service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListExtensions Operation public virtual ListExtensionsResponse ListExtensions(ListExtensionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListExtensionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListExtensionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListExtensions operation. ///

/// /// Container for the necessary parameters to execute the ListExtensions operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListExtensions /// operation. /// REST API Reference for ListExtensions Operation public virtual IAsyncResult BeginListExtensions(ListExtensionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListExtensionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListExtensionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListExtensions operation. ///

/// /// The IAsyncResult returned by the call to BeginListExtensions. /// /// Returns a ListExtensionsResult from GameSparks. /// REST API Reference for ListExtensions Operation public virtual ListExtensionsResponse EndListExtensions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListExtensionVersions ///

/// Gets a paginated list of available versions for the extension. /// /// /// /// Each time an API change is made to an extension, the version is incremented. The /// list retrieved by this operation shows the versions that are currently available. /// /// ///

/// Container for the necessary parameters to execute the ListExtensionVersions service method. /// /// The response from the ListExtensionVersions service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListExtensionVersions Operation public virtual ListExtensionVersionsResponse ListExtensionVersions(ListExtensionVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListExtensionVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListExtensionVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListExtensionVersions operation. ///

/// /// Container for the necessary parameters to execute the ListExtensionVersions operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListExtensionVersions /// operation. /// REST API Reference for ListExtensionVersions Operation public virtual IAsyncResult BeginListExtensionVersions(ListExtensionVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListExtensionVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListExtensionVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListExtensionVersions operation. ///

/// /// The IAsyncResult returned by the call to BeginListExtensionVersions. /// /// Returns a ListExtensionVersionsResult from GameSparks. /// REST API Reference for ListExtensionVersions Operation public virtual ListExtensionVersionsResponse EndListExtensionVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListGames ///

/// Gets a paginated list of games. ///

/// Container for the necessary parameters to execute the ListGames service method. /// /// The response from the ListGames service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListGames Operation public virtual ListGamesResponse ListGames(ListGamesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListGamesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListGamesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListGames operation. ///

/// /// Container for the necessary parameters to execute the ListGames operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListGames /// operation. /// REST API Reference for ListGames Operation public virtual IAsyncResult BeginListGames(ListGamesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListGamesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListGamesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListGames operation. ///

/// /// The IAsyncResult returned by the call to BeginListGames. /// /// Returns a ListGamesResult from GameSparks. /// REST API Reference for ListGames Operation public virtual ListGamesResponse EndListGames(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListGeneratedCodeJobs ///

/// Gets a paginated list of code generation jobs for a snapshot. ///

/// Container for the necessary parameters to execute the ListGeneratedCodeJobs service method. /// /// The response from the ListGeneratedCodeJobs service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListGeneratedCodeJobs Operation public virtual ListGeneratedCodeJobsResponse ListGeneratedCodeJobs(ListGeneratedCodeJobsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListGeneratedCodeJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListGeneratedCodeJobsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListGeneratedCodeJobs operation. ///

/// /// Container for the necessary parameters to execute the ListGeneratedCodeJobs operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListGeneratedCodeJobs /// operation. /// REST API Reference for ListGeneratedCodeJobs Operation public virtual IAsyncResult BeginListGeneratedCodeJobs(ListGeneratedCodeJobsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListGeneratedCodeJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListGeneratedCodeJobsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListGeneratedCodeJobs operation. ///

/// /// The IAsyncResult returned by the call to BeginListGeneratedCodeJobs. /// /// Returns a ListGeneratedCodeJobsResult from GameSparks. /// REST API Reference for ListGeneratedCodeJobs Operation public virtual ListGeneratedCodeJobsResponse EndListGeneratedCodeJobs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListSnapshots ///

/// Gets a paginated list of snapshot summaries from the game. ///

/// Container for the necessary parameters to execute the ListSnapshots service method. /// /// The response from the ListSnapshots service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListSnapshots Operation public virtual ListSnapshotsResponse ListSnapshots(ListSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListSnapshots operation. ///

/// /// Container for the necessary parameters to execute the ListSnapshots operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSnapshots /// operation. /// REST API Reference for ListSnapshots Operation public virtual IAsyncResult BeginListSnapshots(ListSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListSnapshots operation. ///

/// /// The IAsyncResult returned by the call to BeginListSnapshots. /// /// Returns a ListSnapshotsResult from GameSparks. /// REST API Reference for ListSnapshots Operation public virtual ListSnapshotsResponse EndListSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListStageDeployments ///

/// Gets a paginated list of stage deployment summaries from the game. ///

/// Container for the necessary parameters to execute the ListStageDeployments service method. /// /// The response from the ListStageDeployments service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListStageDeployments Operation public virtual ListStageDeploymentsResponse ListStageDeployments(ListStageDeploymentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListStageDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListStageDeploymentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListStageDeployments operation. ///

/// /// Container for the necessary parameters to execute the ListStageDeployments operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListStageDeployments /// operation. /// REST API Reference for ListStageDeployments Operation public virtual IAsyncResult BeginListStageDeployments(ListStageDeploymentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListStageDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListStageDeploymentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListStageDeployments operation. ///

/// /// The IAsyncResult returned by the call to BeginListStageDeployments. /// /// Returns a ListStageDeploymentsResult from GameSparks. /// REST API Reference for ListStageDeployments Operation public virtual ListStageDeploymentsResponse EndListStageDeployments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListStages ///

/// Gets a paginated list of stage summaries from the game. ///

/// Container for the necessary parameters to execute the ListStages service method. /// /// The response from the ListStages service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListStages Operation public virtual ListStagesResponse ListStages(ListStagesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListStagesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListStagesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListStages operation. ///

/// /// Container for the necessary parameters to execute the ListStages operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListStages /// operation. /// REST API Reference for ListStages Operation public virtual IAsyncResult BeginListStages(ListStagesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListStagesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListStagesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListStages operation. ///

/// /// The IAsyncResult returned by the call to BeginListStages. /// /// Returns a ListStagesResult from GameSparks. /// REST API Reference for ListStages Operation public virtual ListStagesResponse EndListStages(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Lists the tags associated with a GameSparks resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by GameSparks. /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTagsForResource operation. ///

/// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation public virtual IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTagsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from GameSparks. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartGeneratedCodeJob ///

/// Starts an asynchronous process that generates client code for system-defined and /// custom messages. The resulting code is collected as a .zip file and uploaded to a /// pre-signed Amazon S3 URL. ///

/// Container for the necessary parameters to execute the StartGeneratedCodeJob service method. /// /// The response from the StartGeneratedCodeJob service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for StartGeneratedCodeJob Operation public virtual StartGeneratedCodeJobResponse StartGeneratedCodeJob(StartGeneratedCodeJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartGeneratedCodeJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartGeneratedCodeJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartGeneratedCodeJob operation. ///

/// /// Container for the necessary parameters to execute the StartGeneratedCodeJob operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartGeneratedCodeJob /// operation. /// REST API Reference for StartGeneratedCodeJob Operation public virtual IAsyncResult BeginStartGeneratedCodeJob(StartGeneratedCodeJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartGeneratedCodeJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartGeneratedCodeJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartGeneratedCodeJob operation. ///

/// /// The IAsyncResult returned by the call to BeginStartGeneratedCodeJob. /// /// Returns a StartGeneratedCodeJobResult from GameSparks. /// REST API Reference for StartGeneratedCodeJob Operation public virtual StartGeneratedCodeJobResponse EndStartGeneratedCodeJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartStageDeployment ///

/// Deploys a snapshot to the stage and creates a new game runtime. /// /// /// /// After you call this operation, you can check the deployment status by using GetStageDeployment. /// /// /// /// /// If there are any players connected to the previous game runtime, then both runtimes /// persist. Existing connections to the previous runtime are maintained. When players /// disconnect and reconnect, they connect to the new runtime. After there are no connections /// to the previous game runtime, it is deleted. /// ///

/// Container for the necessary parameters to execute the StartStageDeployment service method. /// /// The response from the StartStageDeployment service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The resource already exists, or another operation is in progress. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for StartStageDeployment Operation public virtual StartStageDeploymentResponse StartStageDeployment(StartStageDeploymentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartStageDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = StartStageDeploymentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartStageDeployment operation. ///

/// /// Container for the necessary parameters to execute the StartStageDeployment operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartStageDeployment /// operation. /// REST API Reference for StartStageDeployment Operation public virtual IAsyncResult BeginStartStageDeployment(StartStageDeploymentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartStageDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = StartStageDeploymentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartStageDeployment operation. ///

/// /// The IAsyncResult returned by the call to BeginStartStageDeployment. /// /// Returns a StartStageDeploymentResult from GameSparks. /// REST API Reference for StartStageDeployment Operation public virtual StartStageDeploymentResponse EndStartStageDeployment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Adds tags to a GameSparks resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by GameSparks. /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TagResource operation. ///

/// /// Container for the necessary parameters to execute the TagResource operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource /// operation. /// REST API Reference for TagResource Operation public virtual IAsyncResult BeginTagResource(TagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from GameSparks. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes tags from a GameSparks resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by GameSparks. /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UntagResource operation. ///

/// /// Container for the necessary parameters to execute the UntagResource operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource /// operation. /// REST API Reference for UntagResource Operation public virtual IAsyncResult BeginUntagResource(UntagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UntagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from GameSparks. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateGame ///

/// Updates details of the game. ///

/// Container for the necessary parameters to execute the UpdateGame service method. /// /// The response from the UpdateGame service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for UpdateGame Operation public virtual UpdateGameResponse UpdateGame(UpdateGameRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateGameRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateGameResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateGame operation. ///

/// /// Container for the necessary parameters to execute the UpdateGame operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateGame /// operation. /// REST API Reference for UpdateGame Operation public virtual IAsyncResult BeginUpdateGame(UpdateGameRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateGameRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateGameResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateGame operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateGame. /// /// Returns a UpdateGameResult from GameSparks. /// REST API Reference for UpdateGame Operation public virtual UpdateGameResponse EndUpdateGame(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateGameConfiguration ///

/// Updates one or more sections of the game configuration. ///

/// Container for the necessary parameters to execute the UpdateGameConfiguration service method. /// /// The response from the UpdateGameConfiguration service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request would result in exceeding service quota. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for UpdateGameConfiguration Operation public virtual UpdateGameConfigurationResponse UpdateGameConfiguration(UpdateGameConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateGameConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateGameConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateGameConfiguration operation. ///

/// /// Container for the necessary parameters to execute the UpdateGameConfiguration operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateGameConfiguration /// operation. /// REST API Reference for UpdateGameConfiguration Operation public virtual IAsyncResult BeginUpdateGameConfiguration(UpdateGameConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateGameConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateGameConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateGameConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateGameConfiguration. /// /// Returns a UpdateGameConfigurationResult from GameSparks. /// REST API Reference for UpdateGameConfiguration Operation public virtual UpdateGameConfigurationResponse EndUpdateGameConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateSnapshot ///

/// Updates the metadata of a GameSparks snapshot. ///

/// Container for the necessary parameters to execute the UpdateSnapshot service method. /// /// The response from the UpdateSnapshot service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for UpdateSnapshot Operation public virtual UpdateSnapshotResponse UpdateSnapshot(UpdateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateSnapshot operation. ///

/// /// Container for the necessary parameters to execute the UpdateSnapshot operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateSnapshot /// operation. /// REST API Reference for UpdateSnapshot Operation public virtual IAsyncResult BeginUpdateSnapshot(UpdateSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateSnapshot. /// /// Returns a UpdateSnapshotResult from GameSparks. /// REST API Reference for UpdateSnapshot Operation public virtual UpdateSnapshotResponse EndUpdateSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateStage ///

/// Updates the metadata of a stage. ///

/// Container for the necessary parameters to execute the UpdateStage service method. /// /// The response from the UpdateStage service method, as returned by GameSparks. /// /// You do not have sufficient access to perform this action. /// /// /// The service encountered an internal error. /// /// /// The resource specified in the request does not exist. /// /// /// The request throughput limit was exceeded. /// /// /// One of the parameters in the request is invalid. /// /// REST API Reference for UpdateStage Operation public virtual UpdateStageResponse UpdateStage(UpdateStageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateStageRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateStageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateStage operation. ///

/// /// Container for the necessary parameters to execute the UpdateStage operation on AmazonGameSparksClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateStage /// operation. /// REST API Reference for UpdateStage Operation public virtual IAsyncResult BeginUpdateStage(UpdateStageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateStageRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateStageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateStage operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateStage. /// /// Returns a UpdateStageResult from GameSparks. /// REST API Reference for UpdateStage Operation public virtual UpdateStageResponse EndUpdateStage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }