protected virtual IEnumerable <StatementSyntax> GenerateStatements(
            ILocatedOpenApiElement <OpenApiOperation> operation)
        {
            ILocatedOpenApiElement <OpenApiResponses> responseSet     = operation.GetResponseSet();
            ILocatedOpenApiElement <OpenApiResponse>  primaryResponse = responseSet
                                                                        .GetResponses()
                                                                        .OrderBy(p => p.Key)
                                                                        .First();

            ILocatedOpenApiElement <OpenApiMediaType>?mediaType = MediaTypeSelector.Select(primaryResponse);

            if (mediaType != null)
            {
                yield return(ExpressionStatement(InvocationExpression(
                                                     SyntaxHelpers.MemberAccess(RequestMessageParameterName, "Headers", "Accept", "Add"))
                                                 .AddArgumentListArguments(
                                                     Argument(ObjectCreationExpression(WellKnownTypes.System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Name)
                                                              .AddArgumentListArguments(
                                                                  Argument(SyntaxHelpers.StringLiteral(mediaType.Key)))))));
            }

            var propertyNameFormatter = NameFormatterSelector.GetFormatter(NameKind.Property);

            foreach (var headerParameter in operation.Element.Parameters.Where(p => p.In == ParameterLocation.Header))
            {
                string propertyName = propertyNameFormatter.Format(headerParameter.Name);

                StatementSyntax statement = ExpressionStatement(InvocationExpression(
                                                                    SyntaxHelpers.MemberAccess(RequestMessageParameterName, "Headers", "Add"))
                                                                .AddArgumentListArguments(
                                                                    Argument(SyntaxHelpers.StringLiteral(headerParameter.Name)),
                                                                    Argument(InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                                                         SerializationNamespace.HeaderSerializerInstance,
                                                                                                                         IdentifierName("Serialize")))
                                                                             .AddArgumentListArguments(
                                                                                 Argument(IdentifierName(propertyName)),
                                                                                 Argument(headerParameter.Explode
                                    ? LiteralExpression(SyntaxKind.TrueLiteralExpression)
                                    : LiteralExpression(SyntaxKind.FalseLiteralExpression))))));

                if (!headerParameter.Required)
                {
                    statement = MethodHelpers.IfNotNull(
                        IdentifierName(propertyName),
                        Block(statement));
                }

                yield return(statement);
            }
        }
 protected override BlockSyntax GenerateApplyAsyncBody() =>
 Block(
     MethodHelpers.ThrowIfArgumentNull(MessageParameterName),
     MethodHelpers.IfNotNull(IdentifierName(BearerTokenPropertyName), Block(
                                 ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                                                          MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                                 MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                                                        IdentifierName(MessageParameterName),
                                                                                                                        IdentifierName("Headers")),
                                                                                                 IdentifierName("Authorization")),
                                                                          ObjectCreationExpression(WellKnownTypes.System.Net.Http.Headers.AuthenticationHeaderValue.Name)
                                                                          .AddArgumentListArguments(
                                                                              Argument(SyntaxHelpers.StringLiteral("Bearer")),
                                                                              Argument(IdentifierName(BearerTokenPropertyName))))))));
        protected virtual IEnumerable <StatementSyntax> GenerateStatements(ILocatedOpenApiElement <OpenApiOperation> operation)
        {
            yield return(MethodHelpers.ThrowIfArgumentNull(RequestParameterName));

            yield return(GenerateAuthenticatorVariable());

            yield return(GenerateRequestMessageVariable(operation));

            yield return(MethodHelpers.IfNotNull(
                             IdentifierName(AuthenticatorVariableName),
                             Block(ExpressionStatement(SyntaxHelpers.AwaitConfiguredFalse(InvocationExpression(
                                                                                              MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                                                     IdentifierName(AuthenticatorVariableName),
                                                                                                                     IdentifierName("ApplyAsync")))
                                                                                          .AddArgumentListArguments(
                                                                                              Argument(IdentifierName(RequestMessageVariableName)),
                                                                                              Argument(IdentifierName(MethodHelpers.CancellationTokenParameterName))))))));

            yield return(LocalDeclarationStatement(VariableDeclaration(IdentifierName("var"))
                                                   .AddVariables(VariableDeclarator("responseMessage")
                                                                 .WithInitializer(EqualsValueClause(
                                                                                      SyntaxHelpers.AwaitConfiguredFalse(InvocationExpression(
                                                                                                                             SyntaxHelpers.MemberAccess(TagTypeGenerator.HttpClientFieldName, "SendAsync"))
                                                                                                                         .AddArgumentListArguments(
                                                                                                                             Argument(IdentifierName(RequestMessageVariableName)),
                                                                                                                             Argument(IdentifierName(MethodHelpers.CancellationTokenParameterName)))))))));

            yield return(MethodHelpers.IfNotNull(
                             IdentifierName(AuthenticatorVariableName),
                             Block(ExpressionStatement(SyntaxHelpers.AwaitConfiguredFalse(InvocationExpression(
                                                                                              MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                                                     IdentifierName(AuthenticatorVariableName),
                                                                                                                     IdentifierName("ProcessResponseAsync")))
                                                                                          .AddArgumentListArguments(
                                                                                              Argument(IdentifierName("responseMessage")),
                                                                                              Argument(IdentifierName(MethodHelpers.CancellationTokenParameterName))))))));

            yield return(ReturnStatement(GenerateResponse(operation, IdentifierName("responseMessage"))));
        }