ActivitiesApi.gen.cs

/* 
 * Forge SDK
 *
 * The Forge Platform contains an expanding collection of web service components that can be used with Autodesk cloud-based products or your own technologies. Take advantage of Autodesk’s expertise in design and engineering.
 *
 * Design Automation
 *
 * Generated by [Forge Swagger Codegen](https://git.autodesk.com/forge-ozone/forge-rsdk-codegen)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License 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.
 */
using Autodesk.Forge.Core;
using Autodesk.Forge.DesignAutomation.Model;
using Microsoft.Extensions.Options;

namespace Autodesk.Forge.DesignAutomation.Http
{
    /// <summary>
    /// Represents a collection of functions to interact with the API endpoints
    /// </summary>
    public interface IActivitiesApi
    {
        /// <summary>
        /// Creates a new Activity.
        /// </summary>
        /// <remarks>
        /// Creates a new Activity.                             Limits (varies by Engine):                             1. Number of Activities that can be created.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="item"></param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Activity>> CreateActivityAsync (Activity item, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Creates a new alias for this Activity.
        /// </summary>
        /// <remarks>
        /// Creates a new alias for this Activity.                             Limit:                             1. Number of aliases (LimitAliases).
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="alias">{ id : {anyname}, version : {version number}, receiver : [{id of other Forge app},...] }.</param>
        /// <returns>Task of ApiResponse<Alias></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Alias>> CreateActivityAliasAsync (string id, Alias alias, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Creates a new version of the Activity.
        /// </summary>
        /// <remarks>
        /// Creates a new version of the Activity.                             Limit:                             1. Number of versions (LimitVersions).
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="item"></param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Activity>> CreateActivityVersionAsync (string id, Activity item, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Deletes the specified Activity.
        /// </summary>
        /// <remarks>
        /// Deletes the specified Activity, including all versions and aliases.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>
        
        /// <returns>Task of HttpResponseMessage</returns>
        System.Threading.Tasks.Task<HttpResponseMessage> DeleteActivityAsync (string id, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Deletes the alias.
        /// </summary>
        /// <remarks>
        /// Deletes the alias.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="aliasId">Name of alias to delete.</param>
        
        /// <returns>Task of HttpResponseMessage</returns>
        System.Threading.Tasks.Task<HttpResponseMessage> DeleteActivityAliasAsync (string id, string aliasId, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Deletes the specified version of the Activity.
        /// </summary>
        /// <remarks>
        /// Deletes the specified version of the Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="version">Version to delete (integer).</param>
        
        /// <returns>Task of HttpResponseMessage</returns>
        System.Threading.Tasks.Task<HttpResponseMessage> DeleteActivityVersionAsync (string id, int version, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Gets the details of the specified version of the Activity.
        /// </summary>
        /// <remarks>
        /// Gets the details of the specified version of the Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="version">Version to retrieve (integer).</param>     
        /// <returns>Task of ApiResponse<Activity></returns>
        [Obsolete("This method is obsolete. Call GetActivityVersionAsync instead.", false)]
        System.Threading.Tasks.Task<ApiResponse<Activity>> GeActivityVersionAsync(string id, int version, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Gets the details of the specified version of the Activity.
        /// </summary>
        /// <remarks>
        /// Gets the details of the specified version of the Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="version">Version to retrieve (integer).</param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Activity>> GetActivityVersionAsync (string id, int version, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Lists all available Activities.
        /// </summary>
        /// <remarks>
        /// Lists all available Activities, including Activities shared with this Forge app.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="page">Access an additional &#39;page&#39; of data when necessary, based on the &#39;paginationToken&#39; returned from a previous invocation. (optional)</param>
        /// <returns>Task of ApiResponse<Page&lt;string&gt;></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Page<string>>> GetActivitiesAsync (string page = null, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Gets the details of the specified Activity.
        /// </summary>
        /// <remarks>
        /// Gets the details of the specified Activity. Note that the {id} parameter must be a QualifiedId (owner.name+label).
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Full qualified id of the Activity (owner.name+label).</param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Activity>> GetActivityAsync (string id, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Gets alias details.
        /// </summary>
        /// <remarks>
        /// Gets alias details.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="aliasId">Name of alias.</param>
        /// <returns>Task of ApiResponse<Alias></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Alias>> GetActivityAliasAsync (string id, string aliasId, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Lists all aliases for the specified Activity.
        /// </summary>
        /// <remarks>
        /// Lists all aliases for the specified Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="page">Access an additional &#39;page&#39; of data when necessary, based on the &#39;paginationToken&#39; returned from a previous invocation. (optional)</param>
        /// <returns>Task of ApiResponse<Page&lt;Alias&gt;></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Page<Alias>>> GetActivityAliasesAsync (string id, string page = null, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Lists all versions of the specified Activity.
        /// </summary>
        /// <remarks>
        /// Lists all versions of the specified Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="page">Access an additional &#39;page&#39; of data when necessary, based on the &#39;paginationToken&#39; returned from a previous invocation. (optional)</param>
        /// <returns>Task of ApiResponse<Page&lt;int&gt;></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Page<int>>> GetActivityVersionsAsync (string id, string page = null, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
        /// <summary>
        /// Modifies alias details.
        /// </summary>
        /// <remarks>
        /// Modifies alias details.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="aliasId">Name of alias.</param>/// <param name="alias">Alias details to be modified.</param>
        /// <returns>Task of ApiResponse<Alias></returns>
        
        System.Threading.Tasks.Task<ApiResponse<Alias>> ModifyActivityAliasAsync (string id, string aliasId, AliasPatch alias, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true);
    }

    /// <summary>
    /// Represents a collection of functions to interact with the API endpoints
    /// </summary>
    public partial class ActivitiesApi : IActivitiesApi
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ActivitiesApi"/> class
        /// using ForgeService object
        /// </summary>
        /// <param name="service">An instance of ForgeService</param>
        /// <returns></returns>
        public ActivitiesApi(ForgeService service = null, IOptions<Configuration> configuration = null)
        {
            this.Service = service ?? ForgeService.CreateDefault();

            // set BaseAddress from configuration or default
            this.Service.Client.BaseAddress = configuration?.Value.BaseAddress ?? new Configuration().BaseAddress;
        }

        /// <summary>
        /// Gets or sets the configuration object
        /// </summary>
        /// <value>An instance of the ForgeService</value>
        public ForgeService Service {get; set;}

        /// <summary>
        /// Creates a new Activity.
        /// </summary>
        /// <remarks>
        /// Creates a new Activity.                             Limits (varies by Engine):                             1. Number of Activities that can be created.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="item"></param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Activity>> CreateActivityAsync (Activity item, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities", 
                        routeParameters: new Dictionary<string, object> {
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }

                request.Content = Marshalling.Serialize(item); // http body (model) parameter

                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("POST");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Activity>(response, default(Activity));
                }

                return new ApiResponse<Activity>(response, await Marshalling.DeserializeAsync<Activity>(response.Content));

            } // using
        }
        /// <summary>
        /// Creates a new alias for this Activity.
        /// </summary>
        /// <remarks>
        /// Creates a new alias for this Activity.                             Limit:                             1. Number of aliases (LimitAliases).
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="alias">{ id : {anyname}, version : {version number}, receiver : [{id of other Forge app},...] }.</param>
        /// <returns>Task of ApiResponse<Alias></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Alias>> CreateActivityAliasAsync (string id, Alias alias, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/aliases", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }

                request.Content = Marshalling.Serialize(alias); // http body (model) parameter

                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("POST");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Alias>(response, default(Alias));
                }

                return new ApiResponse<Alias>(response, await Marshalling.DeserializeAsync<Alias>(response.Content));

            } // using
        }
        /// <summary>
        /// Creates a new version of the Activity.
        /// </summary>
        /// <remarks>
        /// Creates a new version of the Activity.                             Limit:                             1. Number of versions (LimitVersions).
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="item"></param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Activity>> CreateActivityVersionAsync (string id, Activity item, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/versions", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }

                request.Content = Marshalling.Serialize(item); // http body (model) parameter

                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("POST");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Activity>(response, default(Activity));
                }

                return new ApiResponse<Activity>(response, await Marshalling.DeserializeAsync<Activity>(response.Content));

            } // using
        }
        /// <summary>
        /// Deletes the specified Activity.
        /// </summary>
        /// <remarks>
        /// Deletes the specified Activity, including all versions and aliases.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>
        
        /// <returns>Task of HttpResponseMessage</returns>
        public async System.Threading.Tasks.Task<HttpResponseMessage> DeleteActivityAsync (string id, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("DELETE");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return response;
                }

                return response;

            } // using
        }
        /// <summary>
        /// Deletes the alias.
        /// </summary>
        /// <remarks>
        /// Deletes the alias.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="aliasId">Name of alias to delete.</param>
        
        /// <returns>Task of HttpResponseMessage</returns>
        public async System.Threading.Tasks.Task<HttpResponseMessage> DeleteActivityAliasAsync (string id, string aliasId, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/aliases/{aliasId}", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                            { "aliasId", aliasId},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("DELETE");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return response;
                }

                return response;

            } // using
        }
        /// <summary>
        /// Deletes the specified version of the Activity.
        /// </summary>
        /// <remarks>
        /// Deletes the specified version of the Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="version">Version to delete (integer).</param>
        
        /// <returns>Task of HttpResponseMessage</returns>
        public async System.Threading.Tasks.Task<HttpResponseMessage> DeleteActivityVersionAsync (string id, int version, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/versions/{version}", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                            { "version", version},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("DELETE");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return response;
                }

                return response;

            } // using
        }
        /// <summary>
        /// Gets the details of the specified version of the Activity.
        /// </summary>
        /// <remarks>
        /// Gets the details of the specified version of the Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="version">Version to retrieve (integer).</param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        [Obsolete("This method is obsolete. Call GetActivityVersionAsync instead.", false)]
        public async System.Threading.Tasks.Task<ApiResponse<Activity>> GeActivityVersionAsync(string id, int version, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            return await this.GetActivityVersionAsync(id, version, scopes, headers, throwOnError);
        }
        /// <summary>
        /// Gets the details of the specified version of the Activity.
        /// </summary>
        /// <remarks>
        /// Gets the details of the specified version of the Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="version">Version to retrieve (integer).</param>
        /// <returns>Task of ApiResponse<Activity></returns>

        public async System.Threading.Tasks.Task<ApiResponse<Activity>> GetActivityVersionAsync (string id, int version, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/versions/{version}", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                            { "version", version},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("GET");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Activity>(response, default(Activity));
                }

                return new ApiResponse<Activity>(response, await Marshalling.DeserializeAsync<Activity>(response.Content));

            } // using
        }
        /// <summary>
        /// Lists all available Activities.
        /// </summary>
        /// <remarks>
        /// Lists all available Activities, including Activities shared with this Forge app.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="page">Access an additional &#39;page&#39; of data when necessary, based on the &#39;paginationToken&#39; returned from a previous invocation. (optional)</param>
        /// <returns>Task of ApiResponse<Page&lt;string&gt;></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Page<string>>> GetActivitiesAsync (string page = null, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities", 
                        routeParameters: new Dictionary<string, object> {
                        },
                        queryParameters: new Dictionary<string, object> {
                            { "page", page},
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("GET");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Page<string>>(response, default(Page<string>));
                }

                return new ApiResponse<Page<string>>(response, await Marshalling.DeserializeAsync<Page<string>>(response.Content));

            } // using
        }
        /// <summary>
        /// Gets the details of the specified Activity.
        /// </summary>
        /// <remarks>
        /// Gets the details of the specified Activity. Note that the {id} parameter must be a QualifiedId (owner.name+label).
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Full qualified id of the Activity (owner.name+label).</param>
        /// <returns>Task of ApiResponse<Activity></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Activity>> GetActivityAsync (string id, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("GET");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Activity>(response, default(Activity));
                }

                return new ApiResponse<Activity>(response, await Marshalling.DeserializeAsync<Activity>(response.Content));

            } // using
        }
        /// <summary>
        /// Gets alias details.
        /// </summary>
        /// <remarks>
        /// Gets alias details.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="aliasId">Name of alias.</param>
        /// <returns>Task of ApiResponse<Alias></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Alias>> GetActivityAliasAsync (string id, string aliasId, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/aliases/{aliasId}", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                            { "aliasId", aliasId},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("GET");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Alias>(response, default(Alias));
                }

                return new ApiResponse<Alias>(response, await Marshalling.DeserializeAsync<Alias>(response.Content));

            } // using
        }
        /// <summary>
        /// Lists all aliases for the specified Activity.
        /// </summary>
        /// <remarks>
        /// Lists all aliases for the specified Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="page">Access an additional &#39;page&#39; of data when necessary, based on the &#39;paginationToken&#39; returned from a previous invocation. (optional)</param>
        /// <returns>Task of ApiResponse<Page&lt;Alias&gt;></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Page<Alias>>> GetActivityAliasesAsync (string id, string page = null, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/aliases", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                        },
                        queryParameters: new Dictionary<string, object> {
                            { "page", page},
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("GET");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Page<Alias>>(response, default(Page<Alias>));
                }

                return new ApiResponse<Page<Alias>>(response, await Marshalling.DeserializeAsync<Page<Alias>>(response.Content));

            } // using
        }
        /// <summary>
        /// Lists all versions of the specified Activity.
        /// </summary>
        /// <remarks>
        /// Lists all versions of the specified Activity.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="page">Access an additional &#39;page&#39; of data when necessary, based on the &#39;paginationToken&#39; returned from a previous invocation. (optional)</param>
        /// <returns>Task of ApiResponse<Page&lt;int&gt;></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Page<int>>> GetActivityVersionsAsync (string id, string page = null, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/versions", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                        },
                        queryParameters: new Dictionary<string, object> {
                            { "page", page},
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }


                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("GET");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Page<int>>(response, default(Page<int>));
                }

                return new ApiResponse<Page<int>>(response, await Marshalling.DeserializeAsync<Page<int>>(response.Content));

            } // using
        }
        /// <summary>
        /// Modifies alias details.
        /// </summary>
        /// <remarks>
        /// Modifies alias details.
        /// </remarks>
        /// <exception cref="HttpRequestException">Thrown when fails to make API call</exception>
        /// <param name="id">Name of Activity (unqualified).</param>/// <param name="aliasId">Name of alias.</param>/// <param name="alias">Alias details to be modified.</param>
        /// <returns>Task of ApiResponse<Alias></returns>
        
        public async System.Threading.Tasks.Task<ApiResponse<Alias>> ModifyActivityAliasAsync (string id, string aliasId, AliasPatch alias, string scopes = null, IDictionary<string, string> headers = null, bool throwOnError = true)
        {
            using (var request = new HttpRequestMessage())
            {
                request.RequestUri = 
                    Marshalling.BuildRequestUri("/v3/activities/{id}/aliases/{aliasId}", 
                        routeParameters: new Dictionary<string, object> {
                            { "id", id},
                            { "aliasId", aliasId},
                        },
                        queryParameters: new Dictionary<string, object> {
                        }
                    );

                request.Headers.TryAddWithoutValidation("Accept", "application/json");
                if (headers!=null)
                {
                    foreach (var header in headers)
                    {
                        request.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    }
                }

                request.Content = Marshalling.Serialize(alias); // http body (model) parameter

                // tell the underlying pipeline what scope we'd like to use
                if (scopes == null)
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, "code:all");
                }
                else
                {
                    request.Options.Set(ForgeConfiguration.ScopeKey, scopes);
                }

                request.Method = new HttpMethod("PATCH");

                // make the HTTP request
                var response = await this.Service.Client.SendAsync(request);

                if (throwOnError)
                {
                    await response.EnsureSuccessStatusCodeAsync();
                }
                else if (!response.IsSuccessStatusCode)
                {
                    return new ApiResponse<Alias>(response, default(Alias));
                }

                return new ApiResponse<Alias>(response, await Marshalling.DeserializeAsync<Alias>(response.Content));

            } // using
        }
    }
}