csharp.libraries.generichost.api.mustache Maven / Gradle / Ivy

// 
{{>partial_header}}
{{#nrt}}
#nullable enable

{{/nrt}}
using System;
using System.Collections.Generic;
using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using {{packageName}}.{{clientPackage}};
using {{packageName}}.{{apiPackage}};
{{#hasImport}}
using {{packageName}}.{{modelPackage}};
{{/hasImport}}

namespace {{packageName}}.{{apiPackage}}
{
    {{#operations}}
    /// 
    /// Represents a collection of functions to interact with the API endpoints
    /// This class is registered as transient.
    /// 
    {{>visibility}} interface {{interfacePrefix}}{{classname}} : IApi
    {
        /// 
        /// The class containing the events
        /// 
        {{classname}}Events Events { get; }

        {{#operation}}
        /// 
        /// {{summary}}
        /// 
        /// 
        /// {{notes}}
        /// 
        /// Thrown when fails to make API call
        {{#allParams}}
        /// {{description}}{{^required}} (optional{{#defaultValue}}, default to {{.}}{{/defaultValue}}){{/required}}
        {{/allParams}}
        /// Cancellation Token to cancel the request.
        /// Task<ApiResponse<{{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}object{{/returnType}}>>
        Task> {{operationId}}Async({{>OperationSignature}});

        /// 
        /// {{summary}}
        /// 
        /// 
        /// {{notes}}
        /// 
        {{#allParams}}
        /// {{description}}{{^required}} (optional{{#defaultValue}}, default to {{.}}{{/defaultValue}}){{/required}}
        {{/allParams}}
        /// Cancellation Token to cancel the request.
        /// Task<ApiResponse>{{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}object{{/returnType}}>{{nrt?}}>
        Task{{nrt?}}> {{operationId}}OrDefaultAsync({{>OperationSignature}});
        {{^-last}}

        {{/-last}}
        {{/operation}}
    }

    /// 
    /// Represents a collection of functions to interact with the API endpoints
    /// This class is registered as transient.
    /// 
    {{>visibility}} class {{classname}}Events
    {
        {{#lambda.trimTrailingWithNewLine}}
        {{#operation}}
        /// 
        /// The event raised after the server response
        /// 
        public event EventHandler>{{nrt?}} On{{operationId}};

        /// 
        /// The event raised after an error querying the server
        /// 
        public event EventHandler{{nrt?}} OnError{{operationId}};

        internal void ExecuteOn{{operationId}}(ApiResponse<{{{returnType}}}{{^returnType}}object{{/returnType}}> apiResponse)
        {
            On{{operationId}}?.Invoke(this, new ApiResponseEventArgs<{{{returnType}}}{{^returnType}}object{{/returnType}}>(apiResponse));
        }

        internal void ExecuteOnError{{operationId}}(Exception exception)
        {
            OnError{{operationId}}?.Invoke(this, new ExceptionEventArgs(exception));
        }

        {{/operation}}
        {{/lambda.trimTrailingWithNewLine}}
    }

    /// 
    /// Represents a collection of functions to interact with the API endpoints
    /// 
    {{>visibility}} sealed partial class {{classname}} : {{interfacePrefix}}{{classname}}
    {
        private JsonSerializerOptions _jsonSerializerOptions;

        /// 
        /// The logger
        /// 
        public ILogger<{{classname}}> Logger { get; }

        /// 
        /// The HttpClient
        /// 
        public HttpClient HttpClient { get; }

        /// 
        /// The class containing the events
        /// 
        public {{classname}}Events Events { get; }{{#hasApiKeyMethods}}

        /// 
        /// A token provider of type 
        /// 
        public TokenProvider ApiKeyProvider { get; }{{/hasApiKeyMethods}}{{#hasHttpBearerMethods}}

        /// 
        /// A token provider of type 
        /// 
        public TokenProvider BearerTokenProvider { get; }{{/hasHttpBearerMethods}}{{#hasHttpBasicMethods}}

        /// 
        /// A token provider of type 
        /// 
        public TokenProvider BasicTokenProvider { get; }{{/hasHttpBasicMethods}}{{#hasHttpSignatureMethods}}

        /// 
        /// A token provider of type 
        /// 
        public TokenProvider HttpSignatureTokenProvider { get; }{{/hasHttpSignatureMethods}}{{#hasOAuthMethods}}

        /// 
        /// A token provider of type 
        /// 
        public TokenProvider OauthTokenProvider { get; }{{/hasOAuthMethods}}

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// 
        public {{classname}}(ILogger<{{classname}}> logger, HttpClient httpClient, JsonSerializerOptionsProvider jsonSerializerOptionsProvider, {{classname}}Events {{#lambda.camelcase_param}}{{classname}}Events{{/lambda.camelcase_param}}{{#hasApiKeyMethods}},
            TokenProvider apiKeyProvider{{/hasApiKeyMethods}}{{#hasHttpBearerMethods}},
            TokenProvider bearerTokenProvider{{/hasHttpBearerMethods}}{{#hasHttpBasicMethods}},
            TokenProvider basicTokenProvider{{/hasHttpBasicMethods}}{{#hasHttpSignatureMethods}},
            TokenProvider httpSignatureTokenProvider{{/hasHttpSignatureMethods}}{{#hasOAuthMethods}},
            TokenProvider oauthTokenProvider{{/hasOAuthMethods}})
        {
            _jsonSerializerOptions = jsonSerializerOptionsProvider.Options;
            Logger = logger;
            HttpClient = httpClient;
            Events = {{#lambda.camelcase_param}}{{classname}}Events{{/lambda.camelcase_param}};{{#hasApiKeyMethods}}
            ApiKeyProvider = apiKeyProvider;{{/hasApiKeyMethods}}{{#hasHttpBearerMethods}}
            BearerTokenProvider = bearerTokenProvider;{{/hasHttpBearerMethods}}{{#hasHttpBasicMethods}}
            BasicTokenProvider = basicTokenProvider;{{/hasHttpBasicMethods}}{{#hasHttpSignatureMethods}}
            HttpSignatureTokenProvider = httpSignatureTokenProvider;{{/hasHttpSignatureMethods}}{{#hasOAuthMethods}}
            OauthTokenProvider = oauthTokenProvider;{{/hasOAuthMethods}}
        }
        {{#operation}}

        {{#allParams}}
        {{#-first}}
        partial void Format{{operationId}}({{#allParams}}{{#isPrimitiveType}}ref {{/isPrimitiveType}}{{^required}}Option<{{/required}}{{{dataType}}}{{>NullConditionalParameter}}{{^required}}>{{/required}} {{paramName}}{{^-last}}, {{/-last}}{{/allParams}});

        {{/-first}}
        {{/allParams}}
        {{#vendorExtensions.x-has-not-nullable-reference-types}}
        /// 
        /// Validates the request parameters
        /// 
        {{#vendorExtensions.x-not-nullable-reference-types}}
        /// 
        {{/vendorExtensions.x-not-nullable-reference-types}}
        /// 
        private void Validate{{operationId}}({{#vendorExtensions.x-not-nullable-reference-types}}{{^required}}Option<{{/required}}{{{dataType}}}{{>NullConditionalParameter}}{{^required}}>{{/required}} {{paramName}}{{^-last}}, {{/-last}}{{/vendorExtensions.x-not-nullable-reference-types}})
        {
            {{#lambda.trimTrailingWithNewLine}}
            {{#vendorExtensions.x-not-nullable-reference-types}}
            {{#required}}
            {{^vendorExtensions.x-is-value-type}}
            if ({{paramName}} == null)
                throw new ArgumentNullException(nameof({{paramName}}));

            {{/vendorExtensions.x-is-value-type}}
            {{/required}}
            {{^required}}
            {{^vendorExtensions.x-is-value-type}}
            if ({{paramName}}.IsSet && {{paramName}}.Value == null)
                throw new ArgumentNullException(nameof({{paramName}}));

            {{/vendorExtensions.x-is-value-type}}
            {{/required}}
            {{/vendorExtensions.x-not-nullable-reference-types}}
            {{/lambda.trimTrailingWithNewLine}}
        }

        {{/vendorExtensions.x-has-not-nullable-reference-types}}
        /// 
        /// Processes the server response
        /// 
        /// 
        {{#allParams}}
        /// 
        {{/allParams}}
        private void After{{operationId}}DefaultImplementation({{#lambda.joinWithComma}}ApiResponse<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}object{{/returnType}}> apiResponseLocalVar  {{#allParams}}{{^required}}Option<{{/required}}{{{dataType}}}{{>NullConditionalParameter}}{{^required}}>{{/required}} {{paramName}}  {{/allParams}}{{/lambda.joinWithComma}})
        {
            bool suppressDefaultLog = false;
            After{{operationId}}({{#lambda.joinWithComma}}ref suppressDefaultLog  apiResponseLocalVar  {{#allParams}}{{paramName}}  {{/allParams}}{{/lambda.joinWithComma}});
{{>AfterOperationDefaultImplementation}}
        }

        /// 
        /// Processes the server response
        /// 
        /// 
        /// 
        {{#allParams}}
        /// 
        {{/allParams}}
        partial void After{{operationId}}({{#lambda.joinWithComma}}ref bool suppressDefaultLog  ApiResponse<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}object{{/returnType}}> apiResponseLocalVar  {{#allParams}}{{^required}}Option<{{/required}}{{{dataType}}}{{>NullConditionalParameter}}{{^required}}>{{/required}} {{paramName}}  {{/allParams}}{{/lambda.joinWithComma}});

        /// 
        /// Logs exceptions that occur while retrieving the server response
        /// 
        /// 
        /// 
        /// 
        {{#allParams}}
        /// 
        {{/allParams}}
        private void OnError{{operationId}}DefaultImplementation({{#lambda.joinWithComma}}Exception exception  string pathFormat  string path  {{#allParams}}{{^required}}Option<{{/required}}{{{dataType}}}{{>NullConditionalParameter}}{{^required}}>{{/required}} {{paramName}}  {{/allParams}}{{/lambda.joinWithComma}})
        {
            bool suppressDefaultLog = false;
            OnError{{operationId}}({{#lambda.joinWithComma}}ref suppressDefaultLog  exception  pathFormat  path  {{#allParams}}{{paramName}}  {{/allParams}}{{/lambda.joinWithComma}});
{{>OnErrorDefaultImplementation}}
        }

        /// 
        /// A partial method that gives developers a way to provide customized exception handling
        /// 
        /// 
        /// 
        /// 
        /// 
        {{#allParams}}
        /// 
        {{/allParams}}
        partial void OnError{{operationId}}({{#lambda.joinWithComma}}ref bool suppressDefaultLog  Exception exception  string pathFormat  string path  {{#allParams}}{{^required}}Option<{{/required}}{{{dataType}}}{{>NullConditionalParameter}}{{^required}}>{{/required}} {{paramName}}  {{/allParams}}{{/lambda.joinWithComma}});

        /// 
        /// {{summary}} {{notes}}
        /// 
        {{#allParams}}
        /// {{description}}{{^required}} (optional{{#defaultValue}}, default to {{.}}{{/defaultValue}}){{/required}}
        {{/allParams}}
        /// Cancellation Token to cancel the request.
        /// <> where T : 
        public async Task{{nrt?}}> {{operationId}}OrDefaultAsync({{>OperationSignature}})
        {
            try
            {
                return await {{operationId}}Async({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}}{{#allParams.0}}, {{/allParams.0}}cancellationToken).ConfigureAwait(false);
            }
            catch (Exception)
            {
                return null;
            }
        }

        /// 
        /// {{summary}} {{notes}}
        /// 
        /// Thrown when fails to make API call
        {{#allParams}}
        /// {{description}}{{^required}} (optional{{#defaultValue}}, default to {{.}}{{/defaultValue}}){{/required}}
        {{/allParams}}
        /// Cancellation Token to cancel the request.
        /// <> where T : 
        public async Task> {{operationId}}Async({{>OperationSignature}})
        {
            {{#lambda.trimLineBreaks}}
            UriBuilder uriBuilderLocalVar = new UriBuilder();

            try
            {
                {{#vendorExtensions.x-has-not-nullable-reference-types}}
                Validate{{operationId}}({{#vendorExtensions.x-not-nullable-reference-types}}{{paramName}}{{^-last}}, {{/-last}}{{/vendorExtensions.x-not-nullable-reference-types}});

                {{/vendorExtensions.x-has-not-nullable-reference-types}}
                {{#allParams}}
                {{#-first}}
                Format{{operationId}}({{#allParams}}{{#isPrimitiveType}}ref {{/isPrimitiveType}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});

                {{/-first}}
                {{/allParams}}
                using (HttpRequestMessage httpRequestMessageLocalVar = new HttpRequestMessage())
                {
                    {{^servers}}
                    uriBuilderLocalVar.Host = HttpClient.BaseAddress{{nrt!}}.Host;
                    uriBuilderLocalVar.Port = HttpClient.BaseAddress.Port;
                    uriBuilderLocalVar.Scheme = HttpClient.BaseAddress.Scheme;
                    uriBuilderLocalVar.Path = ClientUtils.CONTEXT_PATH + "{{path}}";
                    {{/servers}}
                    {{#servers}}
                    {{#-first}}
                    Uri urlLocalVar = httpRequestMessageLocalVar.RequestUri = new Uri("{{url}}");
                    uriBuilderLocalVar.Host = urlLocalVar.Authority;
                    uriBuilderLocalVar.Scheme = urlLocalVar.Scheme;
                    uriBuilderLocalVar.Path = urlLocalVar.AbsolutePath;
                    {{/-first}}
                    {{/servers}}
                    {{#pathParams}}
                    {{#required}}
                    uriBuilderLocalVar.Path = uriBuilderLocalVar.Path.Replace("%7B{{baseName}}%7D", Uri.EscapeDataString({{paramName}}.ToString()));
                    {{/required}}
                    {{^required}}

                    if ({{paramName}}.IsSet)
                        uriBuilderLocalVar.Path = uriBuilderLocalVar.Path + $"/{ Uri.EscapeDataString({{paramName}}.Value).ToString()) }";
                    {{#-last}}

                    {{/-last}}
                    {{/required}}
                    {{/pathParams}}
                    {{#queryParams}}
                    {{#-first}}

                    System.Collections.Specialized.NameValueCollection parseQueryStringLocalVar = System.Web.HttpUtility.ParseQueryString(string.Empty);
                    {{/-first}}
                    {{/queryParams}}
                    {{^queryParams}}
                    {{#authMethods}}
                    {{#isApiKey}}
                    {{#isKeyInQuery}}

                    System.Collections.Specialized.NameValueCollection parseQueryStringLocalVar = System.Web.HttpUtility.ParseQueryString(string.Empty);
                    {{/isKeyInQuery}}
                    {{/isApiKey}}
                    {{/authMethods}}
                    {{/queryParams}}
                    {{#queryParams}}
                    {{#required}}
                    {{#-first}}

                    {{/-first}}
                    {{/required}}
                    {{#required}}
                    parseQueryStringLocalVar["{{baseName}}"] = {{paramName}}{{#isNullable}}{{nrt?}}{{^nrt}}{{#vendorExtensions.x-is-value-type}}?{{/vendorExtensions.x-is-value-type}}{{/nrt}}{{/isNullable}}.ToString();
                    {{/required}}
                    {{/queryParams}}

                    {{#queryParams}}
                    {{^required}}
                    if ({{paramName}}.IsSet)
                        parseQueryStringLocalVar["{{baseName}}"] = {{paramName}}.Value{{#isNullable}}{{nrt?}}{{^nrt}}{{#vendorExtensions.x-is-value-type}}?{{/vendorExtensions.x-is-value-type}}{{/nrt}}{{/isNullable}}.ToString();

                    {{/required}}
                    {{#-last}}
                    uriBuilderLocalVar.Query = parseQueryStringLocalVar.ToString();

                    {{/-last}}
                    {{/queryParams}}
                    {{#headerParams}}
                    {{#required}}
                    httpRequestMessageLocalVar.Headers.Add("{{baseName}}", ClientUtils.ParameterToString({{paramName}}));

                    {{/required}}
                    {{^required}}
                    if ({{paramName}}.IsSet)
                        httpRequestMessageLocalVar.Headers.Add("{{baseName}}", ClientUtils.ParameterToString({{paramName}}.Value));

                    {{/required}}
                    {{/headerParams}}
                    {{#formParams}}
                    {{#-first}}
                    MultipartContent multipartContentLocalVar = new MultipartContent();

                    httpRequestMessageLocalVar.Content = multipartContentLocalVar;

                    List> formParameterLocalVars = new List>();

                    multipartContentLocalVar.Add(new FormUrlEncodedContent(formParameterLocalVars));{{/-first}}{{^isFile}}{{#required}}

                    formParameterLocalVars.Add(new KeyValuePair("{{baseName}}", ClientUtils.ParameterToString({{paramName}})));

                    {{/required}}
                    {{^required}}
                    if ({{paramName}}.IsSet)
                        formParameterLocalVars.Add(new KeyValuePair("{{baseName}}", ClientUtils.ParameterToString({{paramName}}.Value)));

                    {{/required}}
                    {{/isFile}}
                    {{#isFile}}
                    {{#required}}
                    multipartContentLocalVar.Add(new StreamContent({{paramName}}));

                    {{/required}}
                    {{^required}}
                    if ({{paramName}}.IsSet)
                        multipartContentLocalVar.Add(new StreamContent({{paramName}}.Value));

                    {{/required}}
                    {{/isFile}}
                    {{/formParams}}
                    {{#bodyParam}}
                    {{#required}}
                    httpRequestMessageLocalVar.Content = ({{paramName}}{{^required}}.Value{{/required}} as object) is System.IO.Stream stream
                        ? httpRequestMessageLocalVar.Content = new StreamContent(stream)
                        : httpRequestMessageLocalVar.Content = new StringContent(JsonSerializer.Serialize({{paramName}}{{^required}}.Value{{/required}}, _jsonSerializerOptions));
                    {{/required}}
                    {{^required}}
                    if ({{paramName}}.IsSet)
                        httpRequestMessageLocalVar.Content = ({{paramName}}{{^required}}.Value{{/required}} as object) is System.IO.Stream stream
                            ? httpRequestMessageLocalVar.Content = new StreamContent(stream)
                            : httpRequestMessageLocalVar.Content = new StringContent(JsonSerializer.Serialize({{paramName}}{{^required}}.Value{{/required}}, _jsonSerializerOptions));
                    {{/required}}

                    {{/bodyParam}}
                    {{#authMethods}}
                    {{#-first}}
                    List tokenBaseLocalVars = new List();

                    {{/-first}}
                    {{#isApiKey}}
                    ApiKeyToken apiKeyTokenLocalVar = (ApiKeyToken) await ApiKeyProvider.GetAsync(cancellationToken).ConfigureAwait(false);

                    tokenBaseLocalVars.Add(apiKeyTokenLocalVar);{{#isKeyInHeader}}

                    apiKeyTokenLocalVar.UseInHeader(httpRequestMessageLocalVar, "{{keyParamName}}");
                    {{/isKeyInHeader}}
                    {{#isKeyInQuery}}

                    apiKeyTokenLocalVar.UseInQuery(httpRequestMessageLocalVar, uriBuilderLocalVar, parseQueryStringLocalVar, "{{keyParamName}}");

                    uriBuilderLocalVar.Query = parseQueryStringLocalVar.ToString();
                    {{/isKeyInQuery}}
                    {{/isApiKey}}
                    {{/authMethods}}

                    {{! below line must be after any UseInQuery calls, but before using the HttpSignatureToken}}
                    httpRequestMessageLocalVar.RequestUri = uriBuilderLocalVar.Uri;
                    {{#authMethods}}
                    {{#isBasicBasic}}

                    BasicToken basicTokenLocalVar = (BasicToken) await BasicTokenProvider.GetAsync(cancellationToken).ConfigureAwait(false);

                    tokenBaseLocalVars.Add(basicTokenLocalVar);

                    basicTokenLocalVar.UseInHeader(httpRequestMessageLocalVar, "{{keyParamName}}");
                    {{/isBasicBasic}}
                    {{#isBasicBearer}}

                    BearerToken bearerTokenLocalVar = (BearerToken) await BearerTokenProvider.GetAsync(cancellationToken).ConfigureAwait(false);

                    tokenBaseLocalVars.Add(bearerTokenLocalVar);

                    bearerTokenLocalVar.UseInHeader(httpRequestMessageLocalVar, "{{keyParamName}}");
                    {{/isBasicBearer}}
                    {{#isOAuth}}

                    OAuthToken oauthTokenLocalVar = (OAuthToken) await OauthTokenProvider.GetAsync(cancellationToken).ConfigureAwait(false);

                    tokenBaseLocalVars.Add(oauthTokenLocalVar);

                    oauthTokenLocalVar.UseInHeader(httpRequestMessageLocalVar, "{{keyParamName}}");
                    {{/isOAuth}}
                    {{#isHttpSignature}}

                    HttpSignatureToken httpSignatureTokenLocalVar = (HttpSignatureToken) await HttpSignatureTokenProvider.GetAsync(cancellationToken).ConfigureAwait(false);

                    tokenBaseLocalVars.Add(httpSignatureTokenLocalVar);

                    if (httpRequestMessageLocalVar.Content != null) {
                        string requestBodyLocalVar = await httpRequestMessageLocalVar.Content.ReadAsStringAsync({{#net60OrLater}}cancellationToken{{/net60OrLater}}).ConfigureAwait(false);

                        httpSignatureTokenLocalVar.UseInHeader(httpRequestMessageLocalVar, requestBodyLocalVar, cancellationToken);
                    }
                    {{/isHttpSignature}}
                    {{/authMethods}}
                    {{#consumes}}
                    {{#-first}}

                    {{=<% %>=}}
                    string[] contentTypes = new string[] {<%/-first%>
                    <%={{ }}=%>
                        "{{{mediaType}}}"{{^-last}},{{/-last}}{{#-last}}
                    };
                    {{/-last}}
                    {{/consumes}}
                    {{#consumes}}
                    {{#-first}}

                    string{{nrt?}} contentTypeLocalVar = ClientUtils.SelectHeaderContentType(contentTypes);

                    if (contentTypeLocalVar != null && httpRequestMessageLocalVar.Content != null)
                        httpRequestMessageLocalVar.Content.Headers.ContentType = new MediaTypeHeaderValue(contentTypeLocalVar);

                    {{/-first}}
                    {{/consumes}}
                    {{#produces}}
                    {{#-first}}

                    {{=<% %>=}}
                    string[] acceptLocalVars = new string[] {<%/-first%>
                    <%={{ }}=%>
                        "{{{mediaType}}}"{{^-last}},{{/-last}}{{#-last}}
                    };
                    {{/-last}}
                    {{/produces}}
                    {{#produces}}
                    {{#-first}}

                    string{{nrt?}} acceptLocalVar = ClientUtils.SelectHeaderAccept(acceptLocalVars);

                    if (acceptLocalVar != null)
                        httpRequestMessageLocalVar.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptLocalVar));
                    {{/-first}}
                    {{/produces}}
                    {{^netStandard}}

                    httpRequestMessageLocalVar.Method = HttpMethod.{{#lambda.titlecase}}{{#lambda.lowercase}}{{httpMethod}}{{/lambda.lowercase}}{{/lambda.titlecase}};
                    {{/netStandard}}
                    {{#netStandard}}
                    httpRequestMessageLocalVar.Method = new HttpMethod("{{#lambda.uppercase}}{{httpMethod}}{{/lambda.uppercase}}");
                    {{/netStandard}}

                    DateTime requestedAtLocalVar = DateTime.UtcNow;

                    using (HttpResponseMessage httpResponseMessageLocalVar = await HttpClient.SendAsync(httpRequestMessageLocalVar, cancellationToken).ConfigureAwait(false))
                    {
                        string responseContentLocalVar = await httpResponseMessageLocalVar.Content.ReadAsStringAsync({{#net60OrLater}}cancellationToken{{/net60OrLater}}).ConfigureAwait(false);

                        ApiResponse<{{{returnType}}}{{^returnType}}object{{/returnType}}> apiResponseLocalVar = new ApiResponse<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}object{{/returnType}}>(httpRequestMessageLocalVar, httpResponseMessageLocalVar, responseContentLocalVar, "{{path}}", requestedAtLocalVar, _jsonSerializerOptions);

                        After{{operationId}}DefaultImplementation({{#lambda.joinWithComma}}apiResponseLocalVar  {{#allParams}}{{paramName}}  {{/allParams}}{{/lambda.joinWithComma}});

                        Events.ExecuteOn{{operationId}}(apiResponseLocalVar);

                        {{#authMethods}}
                        if (apiResponseLocalVar.StatusCode == (HttpStatusCode) 429)
                            foreach(TokenBase tokenBaseLocalVar in tokenBaseLocalVars)
                                tokenBaseLocalVar.BeginRateLimit();

                        {{/authMethods}}
                        return apiResponseLocalVar;
                    }
                }
            }
            catch(Exception e)
            {
                OnError{{operationId}}DefaultImplementation({{#lambda.joinWithComma}}e  "{{path}}"  uriBuilderLocalVar.Path  {{#allParams}}{{paramName}}  {{/allParams}}{{/lambda.joinWithComma}});
                Events.ExecuteOnError{{operationId}}(e);
                throw;
            }
            {{/lambda.trimLineBreaks}}
        }
        {{/operation}}
    }
    {{/operations}}
}