From daafde42f07f58a8c669044fb27a2966fd51b91e Mon Sep 17 00:00:00 2001
From: SergeyMenshykh <68852919+SergeyMenshykh@users.noreply.github.com>
Date: Thu, 7 Nov 2024 15:18:29 +0000
Subject: [PATCH] .Net: Rename OpenAPI model classes (#9595)

### Motivation, Context and Description
The public OpenAPI model classes that have "operation" in their name
were renamed to align with the other classes that do not have the word
in their name.
Additionally, the `RestApiPayloadProperty.Type`,
`RestApiParameter.Type`, and `RestApiParameter.ArrayItemType` were made
internal to simplify the update to OpenAPI.NET v2, where their types
have been changed.
---
 .../OpenApiFunctionExecutionParameters.cs     |  20 +-
 .../Extensions/RestApiOperationExtensions.cs  |  48 ++--
 .../Functions.OpenApi/HttpContentFactory.cs   |   2 +-
 ...Response.cs => RestApiExpectedResponse.cs} |   8 +-
 .../Model/RestApiOperation.cs                 |  40 +--
 ...rationParameter.cs => RestApiParameter.cs} |  20 +-
 ...ocation.cs => RestApiParameterLocation.cs} |   4 +-
 ...meterStyle.cs => RestApiParameterStyle.cs} |   4 +-
 ...iOperationPayload.cs => RestApiPayload.cs} |  10 +-
 ...dProperty.cs => RestApiPayloadProperty.cs} |  16 +-
 .../Model/RestApiSecurityScheme.cs            |   2 +-
 ...ApiOperationServer.cs => RestApiServer.cs} |  12 +-
 ...erVariable.cs => RestApiServerVariable.cs} |   8 +-
 .../Model/RestApiSpecification.cs             |   2 +-
 .../OpenApi/OpenApiDocumentParser.cs          |  46 ++--
 .../OpenApiKernelPluginFactory.cs             |   6 +-
 .../RestApiOperationRunner.cs                 |   6 +-
 .../FormStyleParameterSerializer.cs           |  18 +-
 .../PipeDelimitedStyleParameterSerializer.cs  |  18 +-
 .../SimpleStyleParameterSerializer.cs         |  18 +-
 .../SpaceDelimitedStyleParameterSerializer.cs |  18 +-
 .../RestApiOperationExtensionsTests.cs        |  32 +--
 .../OpenApi/OpenApiDocumentParserV20Tests.cs  |  22 +-
 .../OpenApi/OpenApiDocumentParserV30Tests.cs  |  22 +-
 .../OpenApi/OpenApiDocumentParserV31Tests.cs  |  20 +-
 .../OpenApi/RestApiOperationRunnerTests.cs    | 252 +++++++++---------
 .../OpenApi/RestApiOperationTests.cs          | 158 +++++------
 .../FormStyleParametersSerializerTests.cs     |  36 +--
 ...DelimitedStyleParametersSerializerTests.cs |  20 +-
 .../SimpleStyleParametersSerializerTests.cs   |  10 +-
 ...DelimitedStyleParametersSerializerTests.cs |  20 +-
 31 files changed, 460 insertions(+), 458 deletions(-)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationExpectedResponse.cs => RestApiExpectedResponse.cs} (76%)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationParameter.cs => RestApiParameter.cs} (87%)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationParameterLocation.cs => RestApiParameterLocation.cs} (86%)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationParameterStyle.cs => RestApiParameterStyle.cs} (90%)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationPayload.cs => RestApiPayload.cs} (72%)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationPayloadProperty.cs => RestApiPayloadProperty.cs} (84%)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationServer.cs => RestApiServer.cs} (78%)
 rename dotnet/src/Functions/Functions.OpenApi/Model/{RestApiOperationServerVariable.cs => RestApiServerVariable.cs} (85%)

diff --git a/dotnet/src/Functions/Functions.OpenApi/Extensions/OpenApiFunctionExecutionParameters.cs b/dotnet/src/Functions/Functions.OpenApi/Extensions/OpenApiFunctionExecutionParameters.cs
index 9673411bcbbb..f5a6ee3519bb 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Extensions/OpenApiFunctionExecutionParameters.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Extensions/OpenApiFunctionExecutionParameters.cs
@@ -23,13 +23,13 @@ public class OpenApiFunctionExecutionParameters
     public AuthenticateRequestAsyncCallback? AuthCallback { get; set; }
 
     /// <summary>
-    /// Override for REST API operation server url.
+    /// Override for REST API server url.
     /// </summary>
     public Uri? ServerUrlOverride { get; set; }
 
     /// <summary>
-    /// Flag indicating whether to ignore non-compliant errors or not.
-    /// If set to true, the operation execution will not throw exceptions for non-compliant documents.
+    /// Flag indicating whether to ignore non-compliant errors of the OpenAPI document or not.
+    /// If set to true, the execution will not throw exceptions for non-compliant documents.
     /// Please note that enabling this option may result in incomplete or inaccurate execution results.
     /// </summary>
     public bool IgnoreNonCompliantErrors { get; set; }
@@ -40,8 +40,8 @@ public class OpenApiFunctionExecutionParameters
     public string UserAgent { get; set; }
 
     /// <summary>
-    /// Determines whether the operation payload is constructed dynamically based on operation payload metadata.
-    /// If false, the operation payload must be provided via the 'payload' context variable.
+    /// Determines whether the REST API operation payload is constructed dynamically based on payload metadata.
+    /// If false, the payload must be provided via the 'payload' argument.
     /// </summary>
     public bool EnableDynamicPayload { get; set; }
 
@@ -75,13 +75,13 @@ public class OpenApiFunctionExecutionParameters
     /// </summary>
     /// <param name="httpClient">The HttpClient to use for sending HTTP requests.</param>
     /// <param name="authCallback">The callback for adding authentication data to HTTP requests.</param>
-    /// <param name="serverUrlOverride">The override for the REST API operation server URL.</param>
+    /// <param name="serverUrlOverride">The override for the REST API server URL.</param>
     /// <param name="userAgent">Optional user agent header value.</param>
-    /// <param name="ignoreNonCompliantErrors">A flag indicating whether to ignore non-compliant errors or not
-    /// If set to true, the operation execution will not throw exceptions for non-compliant documents.
+    /// <param name="ignoreNonCompliantErrors">A flag indicating whether to ignore non-compliant errors of the OpenAPI document or not
+    /// If set to true, the execution will not throw exceptions for non-compliant documents.
     /// Please note that enabling this option may result in incomplete or inaccurate execution results.</param>
-    /// <param name="enableDynamicOperationPayload">Determines whether the operation payload is constructed dynamically based on operation payload metadata.
-    /// If false, the operation payload must be provided via the 'payload' context variable.</param>
+    /// <param name="enableDynamicOperationPayload">Determines whether the REST API operation payload is constructed dynamically based on payload metadata.
+    /// If false, the REST API payload must be provided via the 'payload' argument.</param>
     /// <param name="enablePayloadNamespacing">Determines whether payload parameter names are augmented with namespaces.
     /// Namespaces prevent naming conflicts by adding the parent parameter name as a prefix, separated by dots.</param>
     /// <param name="operationsToExclude">Optional list of operations not to import, e.g. in case they are not supported</param>
diff --git a/dotnet/src/Functions/Functions.OpenApi/Extensions/RestApiOperationExtensions.cs b/dotnet/src/Functions/Functions.OpenApi/Extensions/RestApiOperationExtensions.cs
index 280300162db4..b16c37b372b1 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Extensions/RestApiOperationExtensions.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Extensions/RestApiOperationExtensions.cs
@@ -25,12 +25,12 @@ internal static partial class RestApiOperationExtensions
     /// the parameters 'sender.email' and 'receiver.mail' will be correctly resolved from arguments with the same names.
     /// </param>
     /// <returns>The list of parameters.</returns>
-    public static IReadOnlyList<RestApiOperationParameter> GetParameters(
+    public static IReadOnlyList<RestApiParameter> GetParameters(
         this RestApiOperation operation,
         bool addPayloadParamsFromMetadata = true,
         bool enablePayloadNamespacing = false)
     {
-        var parameters = new List<RestApiOperationParameter>(operation.Parameters);
+        var parameters = new List<RestApiParameter>(operation.Parameters);
 
         // Add payload parameters
         if (operation.Payload is not null)
@@ -55,7 +55,7 @@ public static IReadOnlyList<RestApiOperationParameter> GetParameters(
     /// <returns>The default return parameter metadata, if any.</returns>
     public static KernelReturnParameterMetadata? GetDefaultReturnParameter(this RestApiOperation operation, string[]? preferredResponses = null)
     {
-        RestApiOperationExpectedResponse? restOperationResponse = GetDefaultResponse(operation.Responses, preferredResponses ??= s_preferredResponses);
+        RestApiExpectedResponse? restOperationResponse = GetDefaultResponse(operation.Responses, preferredResponses ??= s_preferredResponses);
 
         var returnParameter =
             restOperationResponse is not null ? new KernelReturnParameterMetadata { Description = restOperationResponse.Description, Schema = restOperationResponse.Schema } : null;
@@ -64,12 +64,12 @@ public static IReadOnlyList<RestApiOperationParameter> GetParameters(
     }
 
     /// <summary>
-    /// Retrieves the default response for a given REST API operation.
+    /// Retrieves the default response.
     /// </summary>
-    /// <param name="responses">The REST API operation responses to parse.</param>
+    /// <param name="responses">Possible REST API responses.</param>
     /// <param name="preferredResponses">The preferred response codes to use when selecting the default response.</param>
     /// <returns>The default response, if any.</returns>
-    private static RestApiOperationExpectedResponse? GetDefaultResponse(IReadOnlyDictionary<string, RestApiOperationExpectedResponse> responses, string[] preferredResponses)
+    private static RestApiExpectedResponse? GetDefaultResponse(IReadOnlyDictionary<string, RestApiExpectedResponse> responses, string[] preferredResponses)
     {
         foreach (var code in preferredResponses)
         {
@@ -90,8 +90,8 @@ public static IReadOnlyList<RestApiOperationParameter> GetParameters(
     /// <param name="useParametersFromMetadata">Flag indicating whether to include parameters from metadata.
     /// If false or not specified, the 'payload' and 'content-type' parameters are added instead.</param>
     /// <param name="enableNamespacing">Flag indicating whether to namespace payload parameter names.</param>
-    /// <returns>A list of <see cref="RestApiOperationParameter"/> representing the payload parameters.</returns>
-    private static List<RestApiOperationParameter> GetPayloadParameters(RestApiOperation operation, bool useParametersFromMetadata, bool enableNamespacing)
+    /// <returns>A list of <see cref="RestApiParameter"/> representing the payload parameters.</returns>
+    private static List<RestApiParameter> GetPayloadParameters(RestApiOperation operation, bool useParametersFromMetadata, bool enableNamespacing)
     {
         if (useParametersFromMetadata)
         {
@@ -122,15 +122,15 @@ private static List<RestApiOperationParameter> GetPayloadParameters(RestApiOpera
     /// </summary>
     /// <param name="operation">The REST API operation.</param>
     /// <returns>The 'content-type' artificial parameter.</returns>
-    private static RestApiOperationParameter CreateContentTypeArtificialParameter(RestApiOperation operation)
+    private static RestApiParameter CreateContentTypeArtificialParameter(RestApiOperation operation)
     {
-        return new RestApiOperationParameter(
+        return new RestApiParameter(
             RestApiOperation.ContentTypeArgumentName,
             "string",
             isRequired: false,
             expand: false,
-            RestApiOperationParameterLocation.Body,
-            RestApiOperationParameterStyle.Simple,
+            RestApiParameterLocation.Body,
+            RestApiParameterStyle.Simple,
             description: "Content type of REST API request body.");
     }
 
@@ -139,31 +139,31 @@ private static RestApiOperationParameter CreateContentTypeArtificialParameter(Re
     /// </summary>
     /// <param name="operation">The REST API operation.</param>
     /// <returns>The 'payload' artificial parameter.</returns>
-    private static RestApiOperationParameter CreatePayloadArtificialParameter(RestApiOperation operation)
+    private static RestApiParameter CreatePayloadArtificialParameter(RestApiOperation operation)
     {
-        return new RestApiOperationParameter(
+        return new RestApiParameter(
             RestApiOperation.PayloadArgumentName,
             operation.Payload?.MediaType == MediaTypeTextPlain ? "string" : "object",
             isRequired: true,
             expand: false,
-            RestApiOperationParameterLocation.Body,
-            RestApiOperationParameterStyle.Simple,
+            RestApiParameterLocation.Body,
+            RestApiParameterStyle.Simple,
             description: operation.Payload?.Description ?? "REST API request body.",
             schema: operation.Payload?.Schema);
     }
 
     /// <summary>
-    /// Retrieves parameters from REST API operation payload metadata.
+    /// Retrieves parameters from REST API payload metadata.
     /// </summary>
-    /// <param name="properties">The REST API operation payload properties.</param>
+    /// <param name="properties">The REST API payload properties.</param>
     /// <param name="enableNamespacing">Determines whether property names are augmented with namespaces.
     /// Namespaces are created by prefixing property names with their root property names.
     /// </param>
     /// <param name="rootPropertyName">The root property name.</param>
     /// <returns>The list of payload parameters.</returns>
-    private static List<RestApiOperationParameter> GetParametersFromPayloadMetadata(IReadOnlyList<RestApiOperationPayloadProperty> properties, bool enableNamespacing = false, string? rootPropertyName = null)
+    private static List<RestApiParameter> GetParametersFromPayloadMetadata(IReadOnlyList<RestApiPayloadProperty> properties, bool enableNamespacing = false, string? rootPropertyName = null)
     {
-        var parameters = new List<RestApiOperationParameter>();
+        var parameters = new List<RestApiParameter>();
 
         foreach (var property in properties)
         {
@@ -171,13 +171,13 @@ private static List<RestApiOperationParameter> GetParametersFromPayloadMetadata(
 
             if (!property.Properties.Any())
             {
-                parameters.Add(new RestApiOperationParameter(
+                parameters.Add(new RestApiParameter(
                     name: parameterName,
                     type: property.Type,
                     isRequired: property.IsRequired,
                     expand: false,
-                    location: RestApiOperationParameterLocation.Body,
-                    style: RestApiOperationParameterStyle.Simple,
+                    location: RestApiParameterLocation.Body,
+                    style: RestApiParameterStyle.Simple,
                     defaultValue: property.DefaultValue,
                     description: property.Description,
                     format: property.Format,
@@ -197,7 +197,7 @@ private static List<RestApiOperationParameter> GetParametersFromPayloadMetadata(
     /// <param name="rootPropertyName">The root property name to be used for constructing the full property name.</param>
     /// <param name="enableNamespacing">Determines whether to add namespace to property name or not.</param>
     /// <returns>The property name.</returns>
-    private static string GetPropertyName(RestApiOperationPayloadProperty property, string? rootPropertyName, bool enableNamespacing = false)
+    private static string GetPropertyName(RestApiPayloadProperty property, string? rootPropertyName, bool enableNamespacing = false)
     {
         if (enableNamespacing)
         {
diff --git a/dotnet/src/Functions/Functions.OpenApi/HttpContentFactory.cs b/dotnet/src/Functions/Functions.OpenApi/HttpContentFactory.cs
index d7d270cdaea3..c3ebf9251e0a 100644
--- a/dotnet/src/Functions/Functions.OpenApi/HttpContentFactory.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/HttpContentFactory.cs
@@ -11,4 +11,4 @@ namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 /// <param name="payload">The operation payload metadata.</param>
 /// <param name="arguments">The operation arguments.</param>
 /// <returns>The object and HttpContent representing the operation payload.</returns>
-internal delegate (object? Payload, HttpContent Content) HttpContentFactory(RestApiOperationPayload? payload, IDictionary<string, object?> arguments);
+internal delegate (object? Payload, HttpContent Content) HttpContentFactory(RestApiPayload? payload, IDictionary<string, object?> arguments);
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationExpectedResponse.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiExpectedResponse.cs
similarity index 76%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationExpectedResponse.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiExpectedResponse.cs
index 176a78803cdf..e09a539573fb 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationExpectedResponse.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiExpectedResponse.cs
@@ -5,10 +5,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// The REST API operation response.
+/// REST API response.
 /// </summary>
 [Experimental("SKEXP0040")]
-public sealed class RestApiOperationExpectedResponse
+public sealed class RestApiExpectedResponse
 {
     /// <summary>
     /// Gets the description of the response.
@@ -26,12 +26,12 @@ public sealed class RestApiOperationExpectedResponse
     public KernelJsonSchema? Schema { get; }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="RestApiOperationResponse"/> class.
+    /// Initializes a new instance of the <see cref="RestApiExpectedResponse"/> class.
     /// </summary>
     /// <param name="description">The description of the response.</param>
     /// <param name="mediaType">The media type of the response.</param>
     /// <param name="schema">The schema against which the response body should be validated.</param>
-    internal RestApiOperationExpectedResponse(string description, string mediaType, KernelJsonSchema? schema = null)
+    internal RestApiExpectedResponse(string description, string mediaType, KernelJsonSchema? schema = null)
     {
         this.Description = description;
         this.MediaType = mediaType;
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperation.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperation.cs
index f2257e1b932a..ba0ca0b46006 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperation.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperation.cs
@@ -54,7 +54,7 @@ public sealed class RestApiOperation
     /// <summary>
     /// The server.
     /// </summary>
-    public IReadOnlyList<RestApiOperationServer> Servers { get; }
+    public IReadOnlyList<RestApiServer> Servers { get; }
 
     /// <summary>
     /// The security requirements.
@@ -64,17 +64,17 @@ public sealed class RestApiOperation
     /// <summary>
     /// The operation parameters.
     /// </summary>
-    public IReadOnlyList<RestApiOperationParameter> Parameters { get; }
+    public IReadOnlyList<RestApiParameter> Parameters { get; }
 
     /// <summary>
     /// The list of possible operation responses.
     /// </summary>
-    public IReadOnlyDictionary<string, RestApiOperationExpectedResponse> Responses { get; }
+    public IReadOnlyDictionary<string, RestApiExpectedResponse> Responses { get; }
 
     /// <summary>
     /// The operation payload.
     /// </summary>
-    public RestApiOperationPayload? Payload { get; }
+    public RestApiPayload? Payload { get; }
 
     /// <summary>
     /// Additional unstructured metadata about the operation.
@@ -95,14 +95,14 @@ public sealed class RestApiOperation
     /// <param name="payload">The operation payload.</param>
     internal RestApiOperation(
         string? id,
-        IReadOnlyList<RestApiOperationServer> servers,
+        IReadOnlyList<RestApiServer> servers,
         string path,
         HttpMethod method,
         string? description,
-        IReadOnlyList<RestApiOperationParameter> parameters,
-        IReadOnlyDictionary<string, RestApiOperationExpectedResponse> responses,
+        IReadOnlyList<RestApiParameter> parameters,
+        IReadOnlyDictionary<string, RestApiExpectedResponse> responses,
         IReadOnlyList<RestApiSecurityRequirement> securityRequirements,
-        RestApiOperationPayload? payload = null)
+        RestApiPayload? payload = null)
     {
         this.Id = id;
         this.Servers = servers;
@@ -113,6 +113,8 @@ internal RestApiOperation(
         this.Responses = responses;
         this.SecurityRequirements = securityRequirements;
         this.Payload = payload;
+        this.Responses = responses ?? new Dictionary<string, RestApiExpectedResponse>();
+        this.SecurityRequirements = securityRequirements;
     }
 
     /// <summary>
@@ -140,7 +142,7 @@ internal IDictionary<string, string> BuildHeaders(IDictionary<string, object?> a
     {
         var headers = new Dictionary<string, string>();
 
-        var parameters = this.Parameters.Where(p => p.Location == RestApiOperationParameterLocation.Header);
+        var parameters = this.Parameters.Where(p => p.Location == RestApiParameterLocation.Header);
 
         foreach (var parameter in parameters)
         {
@@ -156,7 +158,7 @@ internal IDictionary<string, string> BuildHeaders(IDictionary<string, object?> a
                 continue;
             }
 
-            var parameterStyle = parameter.Style ?? RestApiOperationParameterStyle.Simple;
+            var parameterStyle = parameter.Style ?? RestApiParameterStyle.Simple;
 
             if (!s_parameterSerializers.TryGetValue(parameterStyle, out var serializer))
             {
@@ -181,7 +183,7 @@ internal string BuildQueryString(IDictionary<string, object?> arguments)
     {
         var segments = new List<string>();
 
-        var parameters = this.Parameters.Where(p => p.Location == RestApiOperationParameterLocation.Query);
+        var parameters = this.Parameters.Where(p => p.Location == RestApiParameterLocation.Query);
 
         foreach (var parameter in parameters)
         {
@@ -197,7 +199,7 @@ internal string BuildQueryString(IDictionary<string, object?> arguments)
                 continue;
             }
 
-            var parameterStyle = parameter.Style ?? RestApiOperationParameterStyle.Form;
+            var parameterStyle = parameter.Style ?? RestApiParameterStyle.Form;
 
             if (!s_parameterSerializers.TryGetValue(parameterStyle, out var serializer))
             {
@@ -223,7 +225,7 @@ internal string BuildQueryString(IDictionary<string, object?> arguments)
     /// <returns>The path.</returns>
     private string BuildPath(string pathTemplate, IDictionary<string, object?> arguments)
     {
-        var parameters = this.Parameters.Where(p => p.Location == RestApiOperationParameterLocation.Path);
+        var parameters = this.Parameters.Where(p => p.Location == RestApiParameterLocation.Path);
 
         foreach (var parameter in parameters)
         {
@@ -239,7 +241,7 @@ private string BuildPath(string pathTemplate, IDictionary<string, object?> argum
                 continue;
             }
 
-            var parameterStyle = parameter.Style ?? RestApiOperationParameterStyle.Simple;
+            var parameterStyle = parameter.Style ?? RestApiParameterStyle.Simple;
 
             if (!s_parameterSerializers.TryGetValue(parameterStyle, out var serializer))
             {
@@ -307,12 +309,12 @@ private Uri GetServerUrl(Uri? serverUrlOverride, Uri? apiHostUrl, IDictionary<st
         return new Uri(serverUrlString);
     }
 
-    private static readonly Dictionary<RestApiOperationParameterStyle, Func<RestApiOperationParameter, JsonNode, string>> s_parameterSerializers = new()
+    private static readonly Dictionary<RestApiParameterStyle, Func<RestApiParameter, JsonNode, string>> s_parameterSerializers = new()
     {
-        { RestApiOperationParameterStyle.Simple, SimpleStyleParameterSerializer.Serialize },
-        { RestApiOperationParameterStyle.Form, FormStyleParameterSerializer.Serialize },
-        { RestApiOperationParameterStyle.SpaceDelimited, SpaceDelimitedStyleParameterSerializer.Serialize },
-        { RestApiOperationParameterStyle.PipeDelimited, PipeDelimitedStyleParameterSerializer.Serialize }
+        { RestApiParameterStyle.Simple, SimpleStyleParameterSerializer.Serialize },
+        { RestApiParameterStyle.Form, FormStyleParameterSerializer.Serialize },
+        { RestApiParameterStyle.SpaceDelimited, SpaceDelimitedStyleParameterSerializer.Serialize },
+        { RestApiParameterStyle.PipeDelimited, PipeDelimitedStyleParameterSerializer.Serialize }
     };
 
     # endregion
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameter.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameter.cs
similarity index 87%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameter.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameter.cs
index 712948ad6ca9..d000f699f68c 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameter.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameter.cs
@@ -5,10 +5,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// The REST API operation parameter.
+/// REST API parameter.
 /// </summary>
 [Experimental("SKEXP0040")]
-public sealed class RestApiOperationParameter
+public sealed class RestApiParameter
 {
     /// <summary>
     /// The parameter name.
@@ -23,7 +23,7 @@ public sealed class RestApiOperationParameter
     /// <summary>
     /// The parameter type - string, integer, number, boolean, array and object.
     /// </summary>
-    public string Type { get; }
+    internal string Type { get; }
 
     /// <summary>
     /// The parameter type modifier that refines the generic parameter type to a more specific one.
@@ -44,17 +44,17 @@ public sealed class RestApiOperationParameter
     /// <summary>
     /// The parameter location.
     /// </summary>
-    public RestApiOperationParameterLocation Location { get; }
+    public RestApiParameterLocation Location { get; }
 
     /// <summary>
     /// The parameter style - defines how multiple values are delimited.
     /// </summary>
-    public RestApiOperationParameterStyle? Style { get; }
+    public RestApiParameterStyle? Style { get; }
 
     /// <summary>
     /// Type of array item for parameters of "array" type.
     /// </summary>
-    public string? ArrayItemType { get; }
+    internal string? ArrayItemType { get; }
 
     /// <summary>
     /// The default value.
@@ -72,7 +72,7 @@ public sealed class RestApiOperationParameter
     public KernelJsonSchema? Schema { get; }
 
     /// <summary>
-    /// Creates an instance of a <see cref="RestApiOperationParameter"/> class.
+    /// Creates an instance of a <see cref="RestApiParameter"/> class.
     /// </summary>
     /// <param name="name">The parameter name.</param>
     /// <param name="type">The parameter type.</param>
@@ -86,13 +86,13 @@ public sealed class RestApiOperationParameter
     /// <param name="format">The parameter type modifier that refines the generic parameter type to a more specific one.
     /// More details can be found at https://swagger.io/docs/specification/data-models/data-types</param>
     /// <param name="schema">The parameter schema.</param>
-    internal RestApiOperationParameter(
+    internal RestApiParameter(
         string name,
         string type,
         bool isRequired,
         bool expand,
-        RestApiOperationParameterLocation location,
-        RestApiOperationParameterStyle? style = null,
+        RestApiParameterLocation location,
+        RestApiParameterStyle? style = null,
         string? arrayItemType = null,
         object? defaultValue = null,
         string? description = null,
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameterLocation.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameterLocation.cs
similarity index 86%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameterLocation.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameterLocation.cs
index 3785033961dd..f28aeb9e1a45 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameterLocation.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameterLocation.cs
@@ -5,10 +5,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// The REST API operation parameter location.
+/// REST API parameter location.
 /// </summary>
 [Experimental("SKEXP0040")]
-public enum RestApiOperationParameterLocation
+public enum RestApiParameterLocation
 {
     /// <summary>
     /// Query parameter.
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameterStyle.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameterStyle.cs
similarity index 90%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameterStyle.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameterStyle.cs
index 09171e8f3a73..7ba16905d718 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationParameterStyle.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiParameterStyle.cs
@@ -5,10 +5,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// The REST API operation parameter style.
+/// REST API parameter style.
 /// </summary>
 [Experimental("SKEXP0040")]
-public enum RestApiOperationParameterStyle
+public enum RestApiParameterStyle
 {
     /// <summary>
     /// Path-style parameters.
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationPayload.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiPayload.cs
similarity index 72%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationPayload.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiPayload.cs
index acfb1703f912..212877964865 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationPayload.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiPayload.cs
@@ -6,10 +6,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// The REST API operation payload.
+/// REST API payload.
 /// </summary>
 [Experimental("SKEXP0040")]
-public sealed class RestApiOperationPayload
+public sealed class RestApiPayload
 {
     /// <summary>
     /// The payload MediaType.
@@ -24,7 +24,7 @@ public sealed class RestApiOperationPayload
     /// <summary>
     /// The payload properties.
     /// </summary>
-    public IReadOnlyList<RestApiOperationPayloadProperty> Properties { get; }
+    public IReadOnlyList<RestApiPayloadProperty> Properties { get; }
 
     /// <summary>
     /// The schema of the parameter.
@@ -32,13 +32,13 @@ public sealed class RestApiOperationPayload
     public KernelJsonSchema? Schema { get; }
 
     /// <summary>
-    /// Creates an instance of a <see cref="RestApiOperationPayload"/> class.
+    /// Creates an instance of a <see cref="RestApiPayload"/> class.
     /// </summary>
     /// <param name="mediaType">The media type.</param>
     /// <param name="properties">The properties.</param>
     /// <param name="description">The description.</param>
     /// <param name="schema">The JSON Schema.</param>
-    internal RestApiOperationPayload(string mediaType, IReadOnlyList<RestApiOperationPayloadProperty> properties, string? description = null, KernelJsonSchema? schema = null)
+    internal RestApiPayload(string mediaType, IReadOnlyList<RestApiPayloadProperty> properties, string? description = null, KernelJsonSchema? schema = null)
     {
         this.MediaType = mediaType;
         this.Properties = properties;
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationPayloadProperty.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiPayloadProperty.cs
similarity index 84%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationPayloadProperty.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiPayloadProperty.cs
index 4aade01a636b..5967aaa6d272 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationPayloadProperty.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiPayloadProperty.cs
@@ -6,10 +6,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// The REST API operation payload property.
+/// REST API payload property.
 /// </summary>
 [Experimental("SKEXP0040")]
-public sealed class RestApiOperationPayloadProperty
+public sealed class RestApiPayloadProperty
 {
     /// <summary>
     /// The property name.
@@ -19,7 +19,7 @@ public sealed class RestApiOperationPayloadProperty
     /// <summary>
     /// The property type.
     /// </summary>
-    public string Type { get; }
+    internal string Type { get; }
 
     /// <summary>
     /// The property type modifier that refines the generic parameter type to a more specific one.
@@ -40,7 +40,7 @@ public sealed class RestApiOperationPayloadProperty
     /// <summary>
     /// The properties.
     /// </summary>
-    public IReadOnlyList<RestApiOperationPayloadProperty> Properties { get; }
+    public IReadOnlyList<RestApiPayloadProperty> Properties { get; }
 
     /// <summary>
     /// The schema of the parameter.
@@ -53,7 +53,7 @@ public sealed class RestApiOperationPayloadProperty
     public object? DefaultValue { get; }
 
     /// <summary>
-    /// Creates an instance of a <see cref="RestApiOperationPayloadProperty"/> class.
+    /// Creates an instance of a <see cref="RestApiPayloadProperty"/> class.
     /// </summary>
     /// <param name="name">The name of the property.</param>
     /// <param name="type">The type of the property.</param>
@@ -64,12 +64,12 @@ public sealed class RestApiOperationPayloadProperty
     /// More details can be found at https://swagger.io/docs/specification/data-models/data-types</param>
     /// <param name="schema">The schema of the payload property.</param>
     /// <param name="defaultValue">The default value of the property.</param>
-    /// <returns>Returns a new instance of the <see cref="RestApiOperationPayloadProperty"/> class.</returns>
-    internal RestApiOperationPayloadProperty(
+    /// <returns>Returns a new instance of the <see cref="RestApiPayloadProperty"/> class.</returns>
+    internal RestApiPayloadProperty(
         string name,
         string type,
         bool isRequired,
-        IReadOnlyList<RestApiOperationPayloadProperty> properties,
+        IReadOnlyList<RestApiPayloadProperty> properties,
         string? description = null,
         string? format = null,
         KernelJsonSchema? schema = null,
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSecurityScheme.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSecurityScheme.cs
index 87d7dc458c73..70c785a17642 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSecurityScheme.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSecurityScheme.cs
@@ -29,7 +29,7 @@ public sealed class RestApiSecurityScheme
     /// <summary>
     /// REQUIRED. The location of the API key. Valid values are "query", "header" or "cookie".
     /// </summary>
-    public RestApiOperationParameterLocation In { get; init; }
+    public RestApiParameterLocation In { get; init; }
 
     /// <summary>
     /// REQUIRED. The name of the HTTP Authorization scheme to be used
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationServer.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiServer.cs
similarity index 78%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationServer.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiServer.cs
index 16bba0f0de27..7113ac24862e 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationServer.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiServer.cs
@@ -6,10 +6,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// REST API Operation Server.
+/// REST API server.
 /// </summary>
 [Experimental("SKEXP0040")]
-public sealed class RestApiOperationServer
+public sealed class RestApiServer
 {
     /// <summary>
     /// A URL to the target host. This URL supports Server Variables and MAY be relative,
@@ -23,18 +23,18 @@ public sealed class RestApiOperationServer
     /// <summary>
     /// A map between a variable name and its value. The value is used for substitution in the server's URL template.
     /// </summary>
-    public IDictionary<string, RestApiOperationServerVariable> Variables { get; }
+    public IDictionary<string, RestApiServerVariable> Variables { get; }
 
     /// <summary>
-    /// Construct a new <see cref="RestApiOperationServer"/> object.
+    /// Construct a new <see cref="RestApiServer"/> object.
     /// </summary>
     /// <param name="url">URL to the target host</param>
     /// <param name="variables">Substitution variables for the server's URL template</param>
 #pragma warning disable CA1054 // URI-like parameters should not be strings
-    internal RestApiOperationServer(string? url = null, IDictionary<string, RestApiOperationServerVariable>? variables = null)
+    internal RestApiServer(string? url = null, IDictionary<string, RestApiServerVariable>? variables = null)
 #pragma warning restore CA1054 // URI-like parameters should not be strings
     {
         this.Url = string.IsNullOrEmpty(url) ? null : url;
-        this.Variables = variables ?? new Dictionary<string, RestApiOperationServerVariable>();
+        this.Variables = variables ?? new Dictionary<string, RestApiServerVariable>();
     }
 }
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationServerVariable.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiServerVariable.cs
similarity index 85%
rename from dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationServerVariable.cs
rename to dotnet/src/Functions/Functions.OpenApi/Model/RestApiServerVariable.cs
index fcbc7a1b1cef..79916f3ea3b8 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiOperationServerVariable.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiServerVariable.cs
@@ -7,10 +7,10 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// REST API Operation Server Variable.
+/// REST API server variable.
 /// </summary>
 [Experimental("SKEXP0040")]
-public sealed class RestApiOperationServerVariable
+public sealed class RestApiServerVariable
 {
     /// <summary>
     /// An optional description for the server variable. CommonMark syntax MAY be used for rich text representation.
@@ -29,12 +29,12 @@ public sealed class RestApiOperationServerVariable
     public IReadOnlyList<string>? Enum { get; }
 
     /// <summary>
-    /// Construct a new <see cref="RestApiOperationServerVariable"/> object.
+    /// Construct a new <see cref="RestApiServerVariable"/> object.
     /// </summary>
     /// <param name="defaultValue">The default value to use for substitution.</param>
     /// <param name="description">An optional description for the server variable.</param>
     /// <param name="enumValues">An enumeration of string values to be used if the substitution options are from a limited set.</param>
-    internal RestApiOperationServerVariable(string defaultValue, string? description = null, List<string>? enumValues = null)
+    internal RestApiServerVariable(string defaultValue, string? description = null, List<string>? enumValues = null)
     {
         this.Default = defaultValue;
         this.Description = description;
diff --git a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSpecification.cs b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSpecification.cs
index 870f47c662d9..b86661aa7512 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSpecification.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Model/RestApiSpecification.cs
@@ -5,7 +5,7 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// The REST API specification.
+/// REST API specification.
 /// </summary>
 internal sealed class RestApiSpecification
 {
diff --git a/dotnet/src/Functions/Functions.OpenApi/OpenApi/OpenApiDocumentParser.cs b/dotnet/src/Functions/Functions.OpenApi/OpenApi/OpenApiDocumentParser.cs
index c0c3b3b206ee..0f0da229afa5 100644
--- a/dotnet/src/Functions/Functions.OpenApi/OpenApi/OpenApiDocumentParser.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/OpenApi/OpenApiDocumentParser.cs
@@ -217,16 +217,16 @@ internal static List<RestApiOperation> CreateRestApiOperations(OpenApiDocument d
     }
 
     /// <summary>
-    /// Build a list of <see cref="RestApiOperationServer"/> objects from the given list of <see cref="OpenApiServer"/> objects.
+    /// Build a list of <see cref="RestApiServer"/> objects from the given list of <see cref="OpenApiServer"/> objects.
     /// </summary>
     /// <param name="servers">Represents servers which hosts the REST API.</param>
-    private static List<RestApiOperationServer> CreateRestApiOperationServers(IList<OpenApiServer> servers)
+    private static List<RestApiServer> CreateRestApiOperationServers(IList<OpenApiServer> servers)
     {
-        var result = new List<RestApiOperationServer>(servers.Count);
+        var result = new List<RestApiServer>(servers.Count);
 
         foreach (var server in servers)
         {
-            var variables = server.Variables.ToDictionary(item => item.Key, item => new RestApiOperationServerVariable(item.Value.Default, item.Value.Description, item.Value.Enum));
+            var variables = server.Variables.ToDictionary(item => item.Key, item => new RestApiServerVariable(item.Value.Default, item.Value.Description, item.Value.Enum));
             result.Add(new(server?.Url, variables));
         }
 
@@ -263,7 +263,7 @@ private static RestApiSecurityScheme CreateRestApiSecurityScheme(OpenApiSecurity
             SecuritySchemeType = securityScheme.Type.ToString(),
             Description = securityScheme.Description,
             Name = securityScheme.Name,
-            In = (RestApiOperationParameterLocation)Enum.Parse(typeof(RestApiOperationParameterLocation), securityScheme.In.ToString()!),
+            In = (RestApiParameterLocation)Enum.Parse(typeof(RestApiParameterLocation), securityScheme.In.ToString()!),
             Scheme = securityScheme.Scheme,
             BearerFormat = securityScheme.BearerFormat,
             Flows = CreateRestApiOAuthFlows(securityScheme.Flows),
@@ -304,7 +304,7 @@ private static RestApiSecurityScheme CreateRestApiSecurityScheme(OpenApiSecurity
     /// <summary>
     /// Build a list of <see cref="RestApiSecurityRequirement"/> objects from the given <see cref="OpenApiSecurityRequirement"/> objects.
     /// </summary>
-    /// <param name="security">The REST API operation security</param>
+    /// <param name="security">The REST API security.</param>
     internal static List<RestApiSecurityRequirement> CreateRestApiOperationSecurityRequirements(IList<OpenApiSecurityRequirement>? security)
     {
         var operationRequirements = new List<RestApiSecurityRequirement>();
@@ -374,14 +374,14 @@ internal static List<RestApiSecurityRequirement> CreateRestApiOperationSecurityR
     }
 
     /// <summary>
-    /// Creates REST API operation parameters.
+    /// Creates REST API parameters.
     /// </summary>
     /// <param name="operationId">The operation id.</param>
     /// <param name="parameters">The OpenAPI parameters.</param>
     /// <returns>The parameters.</returns>
-    private static List<RestApiOperationParameter> CreateRestApiOperationParameters(string operationId, IList<OpenApiParameter> parameters)
+    private static List<RestApiParameter> CreateRestApiOperationParameters(string operationId, IList<OpenApiParameter> parameters)
     {
-        var result = new List<RestApiOperationParameter>();
+        var result = new List<RestApiParameter>();
 
         foreach (var parameter in parameters)
         {
@@ -395,13 +395,13 @@ private static List<RestApiOperationParameter> CreateRestApiOperationParameters(
                 throw new KernelException($"Parameter style of {parameter.Name} parameter of {operationId} operation is undefined.");
             }
 
-            var restParameter = new RestApiOperationParameter(
+            var restParameter = new RestApiParameter(
                 parameter.Name,
                 parameter.Schema.Type,
                 parameter.Required,
                 parameter.Explode,
-                (RestApiOperationParameterLocation)Enum.Parse(typeof(RestApiOperationParameterLocation), parameter.In.ToString()!),
-                (RestApiOperationParameterStyle)Enum.Parse(typeof(RestApiOperationParameterStyle), parameter.Style.ToString()!),
+                (RestApiParameterLocation)Enum.Parse(typeof(RestApiParameterLocation), parameter.In.ToString()!),
+                (RestApiParameterStyle)Enum.Parse(typeof(RestApiParameterStyle), parameter.Style.ToString()!),
                 parameter.Schema.Items?.Type,
                 GetParameterValue(parameter.Schema.Default, "parameter", parameter.Name),
                 parameter.Description,
@@ -416,12 +416,12 @@ private static List<RestApiOperationParameter> CreateRestApiOperationParameters(
     }
 
     /// <summary>
-    /// Creates REST API operation payload.
+    /// Creates REST API payload.
     /// </summary>
     /// <param name="operationId">The operation id.</param>
     /// <param name="requestBody">The OpenAPI request body.</param>
-    /// <returns>The REST API operation payload.</returns>
-    private static RestApiOperationPayload? CreateRestApiOperationPayload(string operationId, OpenApiRequestBody requestBody)
+    /// <returns>The REST API payload.</returns>
+    private static RestApiPayload? CreateRestApiOperationPayload(string operationId, OpenApiRequestBody requestBody)
     {
         if (requestBody?.Content is null)
         {
@@ -433,10 +433,10 @@ private static List<RestApiOperationParameter> CreateRestApiOperationParameters(
 
         var payloadProperties = GetPayloadProperties(operationId, mediaTypeMetadata.Schema);
 
-        return new RestApiOperationPayload(mediaType, payloadProperties, requestBody.Description, mediaTypeMetadata?.Schema?.ToJsonSchema());
+        return new RestApiPayload(mediaType, payloadProperties, requestBody.Description, mediaTypeMetadata?.Schema?.ToJsonSchema());
     }
 
-    private static IEnumerable<(string, RestApiOperationExpectedResponse)> CreateRestApiOperationExpectedResponses(OpenApiResponses responses)
+    private static IEnumerable<(string, RestApiExpectedResponse)> CreateRestApiOperationExpectedResponses(OpenApiResponses responses)
     {
         foreach (var response in responses)
         {
@@ -446,19 +446,19 @@ private static List<RestApiOperationParameter> CreateRestApiOperationParameters(
                 var matchingSchema = response.Value.Content[mediaType].Schema;
                 var description = response.Value.Description ?? matchingSchema?.Description ?? string.Empty;
 
-                yield return (response.Key, new RestApiOperationExpectedResponse(description, mediaType, matchingSchema?.ToJsonSchema()));
+                yield return (response.Key, new RestApiExpectedResponse(description, mediaType, matchingSchema?.ToJsonSchema()));
             }
         }
     }
 
     /// <summary>
-    /// Returns REST API operation payload properties.
+    /// Returns REST API payload properties.
     /// </summary>
     /// <param name="operationId">The operation id.</param>
     /// <param name="schema">An OpenAPI document schema representing request body properties.</param>
     /// <param name="level">Current level in OpenAPI schema.</param>
-    /// <returns>The REST API operation payload properties.</returns>
-    private static List<RestApiOperationPayloadProperty> GetPayloadProperties(string operationId, OpenApiSchema? schema, int level = 0)
+    /// <returns>The REST API payload properties.</returns>
+    private static List<RestApiPayloadProperty> GetPayloadProperties(string operationId, OpenApiSchema? schema, int level = 0)
     {
         if (schema is null)
         {
@@ -470,7 +470,7 @@ private static List<RestApiOperationPayloadProperty> GetPayloadProperties(string
             throw new KernelException($"Max level {PayloadPropertiesHierarchyMaxDepth} of traversing payload properties of {operationId} operation is exceeded.");
         }
 
-        var result = new List<RestApiOperationPayloadProperty>();
+        var result = new List<RestApiPayloadProperty>();
 
         foreach (var propertyPair in schema.Properties)
         {
@@ -478,7 +478,7 @@ private static List<RestApiOperationPayloadProperty> GetPayloadProperties(string
 
             var propertySchema = propertyPair.Value;
 
-            var property = new RestApiOperationPayloadProperty(
+            var property = new RestApiPayloadProperty(
                 propertyName,
                 propertySchema.Type,
                 schema.Required.Contains(propertyName),
diff --git a/dotnet/src/Functions/Functions.OpenApi/OpenApiKernelPluginFactory.cs b/dotnet/src/Functions/Functions.OpenApi/OpenApiKernelPluginFactory.cs
index 113016c2f8a0..38d50fb6e450 100644
--- a/dotnet/src/Functions/Functions.OpenApi/OpenApiKernelPluginFactory.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/OpenApiKernelPluginFactory.cs
@@ -196,7 +196,7 @@ internal static KernelFunction CreateRestApiFunction(
         Uri? documentUri = null,
         ILoggerFactory? loggerFactory = null)
     {
-        IReadOnlyList<RestApiOperationParameter> restOperationParameters = operation.GetParameters(
+        IReadOnlyList<RestApiParameter> restOperationParameters = operation.GetParameters(
             executionParameters?.EnableDynamicPayload ?? true,
             executionParameters?.EnablePayloadNamespacing ?? false
         );
@@ -385,9 +385,9 @@ private static string ConvertOperationIdToValidFunctionName(string operationId,
     /// <summary>
     /// Converts the parameter type to a C# <see cref="Type"/> object.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter.</param>
+    /// <param name="parameter">The REST API parameter.</param>
     /// <returns></returns>
-    private static Type? ConvertParameterDataType(RestApiOperationParameter parameter)
+    private static Type? ConvertParameterDataType(RestApiParameter parameter)
     {
         return parameter.Type switch
         {
diff --git a/dotnet/src/Functions/Functions.OpenApi/RestApiOperationRunner.cs b/dotnet/src/Functions/Functions.OpenApi/RestApiOperationRunner.cs
index 6eee666b4e7f..95109a6f787e 100644
--- a/dotnet/src/Functions/Functions.OpenApi/RestApiOperationRunner.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/RestApiOperationRunner.cs
@@ -343,7 +343,7 @@ private async Task<RestApiOperationResponse> ReadContentAndCreateOperationRespon
     /// <param name="payloadMetadata">The payload meta-data.</param>
     /// <param name="arguments">The payload arguments.</param>
     /// <returns>The JSON payload the corresponding HttpContent.</returns>
-    private (object? Payload, HttpContent Content) BuildJsonPayload(RestApiOperationPayload? payloadMetadata, IDictionary<string, object?> arguments)
+    private (object? Payload, HttpContent Content) BuildJsonPayload(RestApiPayload? payloadMetadata, IDictionary<string, object?> arguments)
     {
         // Build operation payload dynamically
         if (this._enableDynamicPayload)
@@ -374,7 +374,7 @@ private async Task<RestApiOperationResponse> ReadContentAndCreateOperationRespon
     /// <param name="arguments">The arguments.</param>
     /// <param name="propertyNamespace">The namespace to add to the property name.</param>
     /// <returns>The JSON object.</returns>
-    private JsonObject BuildJsonObject(IReadOnlyList<RestApiOperationPayloadProperty> properties, IDictionary<string, object?> arguments, string? propertyNamespace = null)
+    private JsonObject BuildJsonObject(IReadOnlyList<RestApiPayloadProperty> properties, IDictionary<string, object?> arguments, string? propertyNamespace = null)
     {
         var result = new JsonObject();
 
@@ -436,7 +436,7 @@ private JsonObject BuildJsonObject(IReadOnlyList<RestApiOperationPayloadProperty
     /// <param name="payloadMetadata">The payload meta-data.</param>
     /// <param name="arguments">The payload arguments.</param>
     /// <returns>The text payload and corresponding HttpContent.</returns>
-    private (object? Payload, HttpContent Content) BuildPlainTextPayload(RestApiOperationPayload? payloadMetadata, IDictionary<string, object?> arguments)
+    private (object? Payload, HttpContent Content) BuildPlainTextPayload(RestApiPayload? payloadMetadata, IDictionary<string, object?> arguments)
     {
         if (!arguments.TryGetValue(RestApiOperation.PayloadArgumentName, out object? argument) || argument is not string payload)
         {
diff --git a/dotnet/src/Functions/Functions.OpenApi/Serialization/FormStyleParameterSerializer.cs b/dotnet/src/Functions/Functions.OpenApi/Serialization/FormStyleParameterSerializer.cs
index 917f94750a29..da296260e60a 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Serialization/FormStyleParameterSerializer.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Serialization/FormStyleParameterSerializer.cs
@@ -7,27 +7,27 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// Serializes REST API operation parameter of the 'Form' style.
+/// Serializes REST API parameter of the 'Form' style.
 /// </summary>
 internal static class FormStyleParameterSerializer
 {
     /// <summary>
-    /// Serializes a REST API operation `Form` style parameter.
+    /// Serializes a REST API `Form` style parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The parameter argument.</param>
     /// <returns>The serialized parameter.</returns>
-    public static string Serialize(RestApiOperationParameter parameter, JsonNode argument)
+    public static string Serialize(RestApiParameter parameter, JsonNode argument)
     {
         const string ArrayType = "array";
 
         Verify.NotNull(parameter);
         Verify.NotNull(argument);
 
-        var style = parameter.Style ?? RestApiOperationParameterStyle.Form;
-        if (style != RestApiOperationParameterStyle.Form)
+        var style = parameter.Style ?? RestApiParameterStyle.Form;
+        if (style != RestApiParameterStyle.Form)
         {
-            throw new NotSupportedException($"Unsupported Rest API operation parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
+            throw new NotSupportedException($"Unsupported Rest API parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
         }
 
         // Handling parameters of array type.
@@ -49,10 +49,10 @@ public static string Serialize(RestApiOperationParameter parameter, JsonNode arg
     /// <summary>
     /// Serializes an array-type parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The argument value.</param>
     /// <returns>The serialized parameter string.</returns>
-    private static string SerializeArrayParameter(RestApiOperationParameter parameter, JsonNode argument)
+    private static string SerializeArrayParameter(RestApiParameter parameter, JsonNode argument)
     {
         if (argument is not JsonArray array)
         {
diff --git a/dotnet/src/Functions/Functions.OpenApi/Serialization/PipeDelimitedStyleParameterSerializer.cs b/dotnet/src/Functions/Functions.OpenApi/Serialization/PipeDelimitedStyleParameterSerializer.cs
index 3ee0d9c7e79a..7a19dcf100c0 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Serialization/PipeDelimitedStyleParameterSerializer.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Serialization/PipeDelimitedStyleParameterSerializer.cs
@@ -6,31 +6,31 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// Serializes REST API operation parameter of the 'PipeDelimited' style.
+/// Serializes REST API parameter of the 'PipeDelimited' style.
 /// </summary>
 internal static class PipeDelimitedStyleParameterSerializer
 {
     /// <summary>
-    /// Serializes a REST API operation `PipeDelimited` style parameter.
+    /// Serializes a REST API `PipeDelimited` style parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The parameter argument.</param>
     /// <returns>The serialized parameter.</returns>
-    public static string Serialize(RestApiOperationParameter parameter, JsonNode argument)
+    public static string Serialize(RestApiParameter parameter, JsonNode argument)
     {
         const string ArrayType = "array";
 
         Verify.NotNull(parameter);
         Verify.NotNull(argument);
 
-        if (parameter.Style != RestApiOperationParameterStyle.PipeDelimited)
+        if (parameter.Style != RestApiParameterStyle.PipeDelimited)
         {
-            throw new NotSupportedException($"Unsupported Rest API operation parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
+            throw new NotSupportedException($"Unsupported Rest API parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
         }
 
         if (parameter.Type != ArrayType)
         {
-            throw new NotSupportedException($"Unsupported Rest API operation parameter type '{parameter.Type}' for parameter '{parameter.Name}'");
+            throw new NotSupportedException($"Unsupported Rest API parameter type '{parameter.Type}' for parameter '{parameter.Name}'");
         }
 
         return SerializeArrayParameter(parameter, argument);
@@ -39,10 +39,10 @@ public static string Serialize(RestApiOperationParameter parameter, JsonNode arg
     /// <summary>
     /// Serializes an array-type parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The argument value.</param>
     /// <returns>The serialized parameter string.</returns>
-    private static string SerializeArrayParameter(RestApiOperationParameter parameter, JsonNode argument)
+    private static string SerializeArrayParameter(RestApiParameter parameter, JsonNode argument)
     {
         if (argument is not JsonArray array)
         {
diff --git a/dotnet/src/Functions/Functions.OpenApi/Serialization/SimpleStyleParameterSerializer.cs b/dotnet/src/Functions/Functions.OpenApi/Serialization/SimpleStyleParameterSerializer.cs
index 9104ed9635dc..3a653c1b900e 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Serialization/SimpleStyleParameterSerializer.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Serialization/SimpleStyleParameterSerializer.cs
@@ -6,27 +6,27 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// Serializes REST API operation parameter of the 'Simple' style.
+/// Serializes REST API parameter of the 'Simple' style.
 /// </summary>
 internal static class SimpleStyleParameterSerializer
 {
     /// <summary>
-    /// Serializes a REST API operation `Simple` style parameter.
+    /// Serializes a REST API `Simple` style parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The parameter argument.</param>
     /// <returns>The serialized parameter.</returns>
-    public static string Serialize(RestApiOperationParameter parameter, JsonNode argument)
+    public static string Serialize(RestApiParameter parameter, JsonNode argument)
     {
         const string ArrayType = "array";
 
         Verify.NotNull(parameter);
         Verify.NotNull(argument);
 
-        var style = parameter.Style ?? RestApiOperationParameterStyle.Simple;
-        if (style != RestApiOperationParameterStyle.Simple)
+        var style = parameter.Style ?? RestApiParameterStyle.Simple;
+        if (style != RestApiParameterStyle.Simple)
         {
-            throw new NotSupportedException($"Unsupported Rest API operation parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
+            throw new NotSupportedException($"Unsupported Rest API parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
         }
 
         // Serializing parameters of array type.
@@ -48,10 +48,10 @@ public static string Serialize(RestApiOperationParameter parameter, JsonNode arg
     /// <summary>
     /// Serializes an array-type parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The argument value.</param>
     /// <returns>The serialized parameter string.</returns>
-    private static string SerializeArrayParameter(RestApiOperationParameter parameter, object argument)
+    private static string SerializeArrayParameter(RestApiParameter parameter, object argument)
     {
         if (argument is not JsonArray array)
         {
diff --git a/dotnet/src/Functions/Functions.OpenApi/Serialization/SpaceDelimitedStyleParameterSerializer.cs b/dotnet/src/Functions/Functions.OpenApi/Serialization/SpaceDelimitedStyleParameterSerializer.cs
index f42911ab0536..ec7f5f16ec99 100644
--- a/dotnet/src/Functions/Functions.OpenApi/Serialization/SpaceDelimitedStyleParameterSerializer.cs
+++ b/dotnet/src/Functions/Functions.OpenApi/Serialization/SpaceDelimitedStyleParameterSerializer.cs
@@ -6,30 +6,30 @@
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>
-/// Serializes REST API operation parameter of the 'SpaceDelimited' style.
+/// Serializes REST API parameter of the 'SpaceDelimited' style.
 /// </summary>
 internal static class SpaceDelimitedStyleParameterSerializer
 {
     /// <summary>
-    /// Serializes a REST API operation `SpaceDelimited` style parameter.
+    /// Serializes a REST API `SpaceDelimited` style parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The parameter argument.</param>
     /// <returns>The serialized parameter.</returns>
-    public static string Serialize(RestApiOperationParameter parameter, JsonNode argument)
+    public static string Serialize(RestApiParameter parameter, JsonNode argument)
     {
         const string ArrayType = "array";
 
         Verify.NotNull(parameter);
 
-        if (parameter.Style != RestApiOperationParameterStyle.SpaceDelimited)
+        if (parameter.Style != RestApiParameterStyle.SpaceDelimited)
         {
-            throw new NotSupportedException($"Unsupported Rest API operation parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
+            throw new NotSupportedException($"Unsupported Rest API parameter style '{parameter.Style}' for parameter '{parameter.Name}'");
         }
 
         if (parameter.Type != ArrayType)
         {
-            throw new NotSupportedException($"Unsupported Rest API operation parameter type '{parameter.Type}' for parameter '{parameter.Name}'");
+            throw new NotSupportedException($"Unsupported Rest API parameter type '{parameter.Type}' for parameter '{parameter.Name}'");
         }
 
         return SerializeArrayParameter(parameter, argument);
@@ -38,10 +38,10 @@ public static string Serialize(RestApiOperationParameter parameter, JsonNode arg
     /// <summary>
     /// Serializes an array-type parameter.
     /// </summary>
-    /// <param name="parameter">The REST API operation parameter to serialize.</param>
+    /// <param name="parameter">The REST API parameter to serialize.</param>
     /// <param name="argument">The argument value.</param>
     /// <returns>The serialized parameter string.</returns>
-    private static string SerializeArrayParameter(RestApiOperationParameter parameter, JsonNode argument)
+    private static string SerializeArrayParameter(RestApiParameter parameter, JsonNode argument)
     {
         if (argument is not JsonArray array)
         {
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Extensions/RestApiOperationExtensionsTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Extensions/RestApiOperationExtensionsTests.cs
index 4e59601167f5..e9ceb0ab6d94 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Extensions/RestApiOperationExtensionsTests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Extensions/RestApiOperationExtensionsTests.cs
@@ -231,10 +231,10 @@ public void ItShouldAddNamespaceToParametersDeclaredInPayloadMetadata(string met
     public void ItShouldSetAlternativeNameToParametersForPutAndPostOperation(string method)
     {
         //Arrange
-        var latitude = new RestApiOperationPayloadProperty("location.latitude", "number", false, []);
-        var place = new RestApiOperationPayloadProperty("place", "string", true, []);
+        var latitude = new RestApiPayloadProperty("location.latitude", "number", false, []);
+        var place = new RestApiPayloadProperty("place", "string", true, []);
 
-        var payload = new RestApiOperationPayload("application/json", [place, latitude]);
+        var payload = new RestApiPayload("application/json", [place, latitude]);
 
         var operation = CreateTestOperation(method, payload);
 
@@ -253,7 +253,7 @@ public void ItShouldSetAlternativeNameToParametersForPutAndPostOperation(string
         Assert.Equal("location_latitude", personNameProp.AlternativeName);
     }
 
-    private static RestApiOperation CreateTestOperation(string method, RestApiOperationPayload? payload = null, Uri? url = null)
+    private static RestApiOperation CreateTestOperation(string method, RestApiPayload? payload = null, Uri? url = null)
     {
         return new RestApiOperation(
             id: "fake-id",
@@ -262,66 +262,66 @@ private static RestApiOperation CreateTestOperation(string method, RestApiOperat
             method: new HttpMethod(method),
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload);
     }
 
-    private static RestApiOperationPayload CreateTestJsonPayload()
+    private static RestApiPayload CreateTestJsonPayload()
     {
-        var name = new RestApiOperationPayloadProperty(
+        var name = new RestApiPayloadProperty(
             name: "name",
             type: "string",
             isRequired: true,
             properties: [],
             description: "The name.");
 
-        var leader = new RestApiOperationPayloadProperty(
+        var leader = new RestApiPayloadProperty(
             name: "leader",
             type: "string",
             isRequired: true,
             properties: [],
             description: "The leader.");
 
-        var landmarks = new RestApiOperationPayloadProperty(
+        var landmarks = new RestApiPayloadProperty(
             name: "landmarks",
             type: "array",
             isRequired: false,
             properties: [],
             description: "The landmarks.");
 
-        var location = new RestApiOperationPayloadProperty(
+        var location = new RestApiPayloadProperty(
             name: "location",
             type: "object",
             isRequired: true,
             properties: [landmarks],
             description: "The location.");
 
-        var rulingCouncil = new RestApiOperationPayloadProperty(
+        var rulingCouncil = new RestApiPayloadProperty(
             name: "rulingCouncil",
             type: "object",
             isRequired: true,
             properties: [leader],
             description: "The ruling council.");
 
-        var population = new RestApiOperationPayloadProperty(
+        var population = new RestApiPayloadProperty(
             name: "population",
             type: "integer",
             isRequired: true,
             properties: [],
             description: "The population.");
 
-        var hasMagicWards = new RestApiOperationPayloadProperty(
+        var hasMagicWards = new RestApiPayloadProperty(
             name: "hasMagicWards",
             type: "boolean",
             isRequired: false,
             properties: []);
 
-        return new RestApiOperationPayload("application/json", [name, location, rulingCouncil, population, hasMagicWards]);
+        return new RestApiPayload("application/json", [name, location, rulingCouncil, population, hasMagicWards]);
     }
 
-    private static RestApiOperationPayload CreateTestTextPayload()
+    private static RestApiPayload CreateTestTextPayload()
     {
-        return new RestApiOperationPayload("text/plain", []);
+        return new RestApiPayload("text/plain", []);
     }
 }
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV20Tests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV20Tests.cs
index 3337d0e39eb4..099ab02042f9 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV20Tests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV20Tests.cs
@@ -123,14 +123,14 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var pathParameter = parameters.Single(p => p.Name == "secret-name"); //'secret-name' path parameter.
         Assert.True(pathParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Path, pathParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Path, pathParameter.Location);
         Assert.Null(pathParameter.DefaultValue);
         Assert.NotNull(pathParameter.Schema);
         Assert.Equal("string", pathParameter.Schema.RootElement.GetProperty("type").GetString());
 
         var apiVersionParameter = parameters.Single(p => p.Name == "api-version"); //'api-version' query string parameter.
         Assert.True(apiVersionParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Query, apiVersionParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Query, apiVersionParameter.Location);
         Assert.Equal("7.0", apiVersionParameter.DefaultValue);
         Assert.NotNull(apiVersionParameter.Schema);
         Assert.Equal("string", apiVersionParameter.Schema.RootElement.GetProperty("type").GetString());
@@ -138,7 +138,7 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var payloadParameter = parameters.Single(p => p.Name == "payload"); //'payload' artificial parameter.
         Assert.True(payloadParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Body, payloadParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Body, payloadParameter.Location);
         Assert.Null(payloadParameter.DefaultValue);
         Assert.Equal("REST API request body.", payloadParameter.Description);
         Assert.NotNull(payloadParameter.Schema);
@@ -146,7 +146,7 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var contentTypeParameter = parameters.Single(p => p.Name == "content-type"); //'content-type' artificial parameter.
         Assert.False(contentTypeParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Body, contentTypeParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Body, contentTypeParameter.Location);
         Assert.Null(contentTypeParameter.DefaultValue);
         Assert.Equal("Content type of REST API request body.", contentTypeParameter.Description);
         Assert.Null(contentTypeParameter.Schema);
@@ -174,7 +174,7 @@ public async Task ItCanExtractSimpleTypeHeaderParameterMetadataSuccessfullyAsync
         var restApi = await this._sut.ParseAsync(this._openApiDocument);
 
         //Assert string header parameter metadata
-        var accept = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "Accept");
+        var accept = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "Accept");
 
         Assert.Equal("string", accept.Type);
         Assert.Equal("application/json", accept.DefaultValue);
@@ -182,7 +182,7 @@ public async Task ItCanExtractSimpleTypeHeaderParameterMetadataSuccessfullyAsync
         Assert.False(accept.IsRequired);
 
         //Assert integer header parameter metadata
-        var apiVersion = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "X-API-Version");
+        var apiVersion = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "X-API-Version");
 
         Assert.Equal("integer", apiVersion.Type);
         Assert.Equal(10, apiVersion.DefaultValue);
@@ -197,12 +197,12 @@ public async Task ItCanExtractCsvStyleHeaderParameterMetadataSuccessfullyAsync()
         var restApi = await this._sut.ParseAsync(this._openApiDocument);
 
         //Assert header parameters metadata
-        var acceptParameter = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "X-Operation-Csv-Ids");
+        var acceptParameter = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "X-Operation-Csv-Ids");
 
         Assert.Null(acceptParameter.DefaultValue);
         Assert.False(acceptParameter.IsRequired);
         Assert.Equal("array", acceptParameter.Type);
-        Assert.Equal(RestApiOperationParameterStyle.Simple, acceptParameter.Style);
+        Assert.Equal(RestApiParameterStyle.Simple, acceptParameter.Style);
         Assert.Equal("The comma separated list of operation ids.", acceptParameter.Description);
         Assert.Equal("string", acceptParameter.ArrayItemType);
     }
@@ -218,7 +218,7 @@ public async Task ItCanExtractHeadersSuccessfullyAsync()
 
         var operation = restApi.Operations.Single(o => o.Id == "SetSecret");
 
-        var headerParameters = operation.Parameters.Where(p => p.Location == RestApiOperationParameterLocation.Header);
+        var headerParameters = operation.Parameters.Where(p => p.Location == RestApiParameterLocation.Header);
 
         Assert.NotNull(headerParameters);
         Assert.Equal(3, headerParameters.Count());
@@ -414,8 +414,8 @@ public async Task ItCanParsePropertiesOfObjectDataTypeAsync()
         Assert.Null(property.Format);
     }
 
-    private static RestApiOperationParameter GetParameterMetadata(IList<RestApiOperation> operations, string operationId,
-        RestApiOperationParameterLocation location, string name)
+    private static RestApiParameter GetParameterMetadata(IList<RestApiOperation> operations, string operationId,
+        RestApiParameterLocation location, string name)
     {
         Assert.True(operations.Any());
 
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV30Tests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV30Tests.cs
index fe013906944a..1a98185b68ab 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV30Tests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV30Tests.cs
@@ -124,14 +124,14 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var pathParameter = parameters.Single(p => p.Name == "secret-name"); //'secret-name' path parameter.
         Assert.True(pathParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Path, pathParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Path, pathParameter.Location);
         Assert.Null(pathParameter.DefaultValue);
         Assert.NotNull(pathParameter.Schema);
         Assert.Equal("string", pathParameter.Schema.RootElement.GetProperty("type").GetString());
 
         var apiVersionParameter = parameters.Single(p => p.Name == "api-version"); //'api-version' query string parameter.
         Assert.True(apiVersionParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Query, apiVersionParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Query, apiVersionParameter.Location);
         Assert.Equal("7.0", apiVersionParameter.DefaultValue);
         Assert.NotNull(apiVersionParameter.Schema);
         Assert.Equal("string", apiVersionParameter.Schema.RootElement.GetProperty("type").GetString());
@@ -139,7 +139,7 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var payloadParameter = parameters.Single(p => p.Name == "payload"); //'payload' artificial parameter.
         Assert.True(payloadParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Body, payloadParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Body, payloadParameter.Location);
         Assert.Null(payloadParameter.DefaultValue);
         Assert.Equal("REST API request body.", payloadParameter.Description);
         Assert.NotNull(payloadParameter.Schema);
@@ -147,7 +147,7 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var contentTypeParameter = parameters.Single(p => p.Name == "content-type"); //'content-type' artificial parameter.
         Assert.False(contentTypeParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Body, contentTypeParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Body, contentTypeParameter.Location);
         Assert.Null(contentTypeParameter.DefaultValue);
         Assert.Equal("Content type of REST API request body.", contentTypeParameter.Description);
         Assert.Null(contentTypeParameter.Schema);
@@ -160,7 +160,7 @@ public async Task ItCanExtractSimpleTypeHeaderParameterMetadataSuccessfullyAsync
         var restApi = await this._sut.ParseAsync(this._openApiDocument);
 
         //Assert string header parameter metadata
-        var accept = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "Accept");
+        var accept = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "Accept");
 
         Assert.Equal("string", accept.Type);
         Assert.Equal("application/json", accept.DefaultValue);
@@ -168,7 +168,7 @@ public async Task ItCanExtractSimpleTypeHeaderParameterMetadataSuccessfullyAsync
         Assert.False(accept.IsRequired);
 
         //Assert integer header parameter metadata
-        var apiVersion = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "X-API-Version");
+        var apiVersion = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "X-API-Version");
 
         Assert.Equal("integer", apiVersion.Type);
         Assert.Equal(10, apiVersion.DefaultValue);
@@ -198,12 +198,12 @@ public async Task ItCanExtractCsvStyleHeaderParameterMetadataSuccessfullyAsync()
         var restApi = await this._sut.ParseAsync(this._openApiDocument);
 
         //Assert header parameters metadata
-        var acceptParameter = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "X-Operation-Csv-Ids");
+        var acceptParameter = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "X-Operation-Csv-Ids");
 
         Assert.Null(acceptParameter.DefaultValue);
         Assert.False(acceptParameter.IsRequired);
         Assert.Equal("array", acceptParameter.Type);
-        Assert.Equal(RestApiOperationParameterStyle.Simple, acceptParameter.Style);
+        Assert.Equal(RestApiParameterStyle.Simple, acceptParameter.Style);
         Assert.Equal("The comma separated list of operation ids.", acceptParameter.Description);
         Assert.Equal("string", acceptParameter.ArrayItemType);
     }
@@ -219,7 +219,7 @@ public async Task ItCanExtractHeadersSuccessfullyAsync()
 
         var operation = restApi.Operations.Single(o => o.Id == "SetSecret");
 
-        var headerParameters = operation.Parameters.Where(p => p.Location == RestApiOperationParameterLocation.Header);
+        var headerParameters = operation.Parameters.Where(p => p.Location == RestApiParameterLocation.Header);
 
         Assert.NotNull(headerParameters);
         Assert.Equal(3, headerParameters.Count());
@@ -515,8 +515,8 @@ private static MemoryStream ModifyOpenApiDocument(Stream openApiDocument, Action
         return stream;
     }
 
-    private static RestApiOperationParameter GetParameterMetadata(IList<RestApiOperation> operations, string operationId,
-        RestApiOperationParameterLocation location, string name)
+    private static RestApiParameter GetParameterMetadata(IList<RestApiOperation> operations, string operationId,
+        RestApiParameterLocation location, string name)
     {
         Assert.True(operations.Any());
 
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV31Tests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV31Tests.cs
index d43a8a1cbba7..79f3d8330694 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV31Tests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/OpenApiDocumentParserV31Tests.cs
@@ -124,14 +124,14 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var pathParameter = parameters.Single(p => p.Name == "secret-name"); //'secret-name' path parameter.
         Assert.True(pathParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Path, pathParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Path, pathParameter.Location);
         Assert.Null(pathParameter.DefaultValue);
         Assert.NotNull(pathParameter.Schema);
         Assert.Equal("string", pathParameter.Schema.RootElement.GetProperty("type").GetString());
 
         var apiVersionParameter = parameters.Single(p => p.Name == "api-version"); //'api-version' query string parameter.
         Assert.True(apiVersionParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Query, apiVersionParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Query, apiVersionParameter.Location);
         Assert.Equal("7.0", apiVersionParameter.DefaultValue);
         Assert.NotNull(apiVersionParameter.Schema);
         Assert.Equal("string", apiVersionParameter.Schema.RootElement.GetProperty("type").GetString());
@@ -139,7 +139,7 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var payloadParameter = parameters.Single(p => p.Name == "payload"); //'payload' artificial parameter.
         Assert.True(payloadParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Body, payloadParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Body, payloadParameter.Location);
         Assert.Null(payloadParameter.DefaultValue);
         Assert.Equal("REST API request body.", payloadParameter.Description);
         Assert.NotNull(payloadParameter.Schema);
@@ -147,7 +147,7 @@ public async Task ItCanParsePutOperationMetadataSuccessfullyAsync()
 
         var contentTypeParameter = parameters.Single(p => p.Name == "content-type"); //'content-type' artificial parameter.
         Assert.False(contentTypeParameter.IsRequired);
-        Assert.Equal(RestApiOperationParameterLocation.Body, contentTypeParameter.Location);
+        Assert.Equal(RestApiParameterLocation.Body, contentTypeParameter.Location);
         Assert.Null(contentTypeParameter.DefaultValue);
         Assert.Equal("Content type of REST API request body.", contentTypeParameter.Description);
         Assert.Null(contentTypeParameter.Schema);
@@ -175,7 +175,7 @@ public async Task ItCanExtractSimpleTypeHeaderParameterMetadataSuccessfullyAsync
         var restApi = await this._sut.ParseAsync(this._openApiDocument);
 
         //Assert string header parameter metadata
-        var accept = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "Accept");
+        var accept = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "Accept");
 
         Assert.Equal("string", accept.Type);
         Assert.Equal("application/json", accept.DefaultValue);
@@ -183,7 +183,7 @@ public async Task ItCanExtractSimpleTypeHeaderParameterMetadataSuccessfullyAsync
         Assert.False(accept.IsRequired);
 
         //Assert integer header parameter metadata
-        var apiVersion = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "X-API-Version");
+        var apiVersion = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "X-API-Version");
 
         Assert.Equal("integer", apiVersion.Type);
         Assert.Equal(10, apiVersion.DefaultValue);
@@ -198,12 +198,12 @@ public async Task ItCanExtractCsvStyleHeaderParameterMetadataSuccessfullyAsync()
         var restApi = await this._sut.ParseAsync(this._openApiDocument);
 
         //Assert header parameters metadata
-        var acceptParameter = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiOperationParameterLocation.Header, "X-Operation-Csv-Ids");
+        var acceptParameter = GetParameterMetadata(restApi.Operations, "SetSecret", RestApiParameterLocation.Header, "X-Operation-Csv-Ids");
 
         Assert.Null(acceptParameter.DefaultValue);
         Assert.False(acceptParameter.IsRequired);
         Assert.Equal("array", acceptParameter.Type);
-        Assert.Equal(RestApiOperationParameterStyle.Simple, acceptParameter.Style);
+        Assert.Equal(RestApiParameterStyle.Simple, acceptParameter.Style);
         Assert.Equal("The comma separated list of operation ids.", acceptParameter.Description);
         Assert.Equal("string", acceptParameter.ArrayItemType);
     }
@@ -219,7 +219,7 @@ public async Task ItCanExtractHeadersSuccessfullyAsync()
 
         var operation = restApi.Operations.Single(o => o.Id == "SetSecret");
 
-        var headerParameters = operation.Parameters.Where(p => p.Location == RestApiOperationParameterLocation.Header);
+        var headerParameters = operation.Parameters.Where(p => p.Location == RestApiParameterLocation.Header);
 
         Assert.NotNull(headerParameters);
         Assert.Equal(3, headerParameters.Count());
@@ -497,7 +497,7 @@ private static MemoryStream ModifyOpenApiDocument(Stream openApiDocument, Action
         return stream;
     }
 
-    private static RestApiOperationParameter GetParameterMetadata(IList<RestApiOperation> operations, string operationId, RestApiOperationParameterLocation location, string name)
+    private static RestApiParameter GetParameterMetadata(IList<RestApiOperation> operations, string operationId, RestApiParameterLocation location, string name)
     {
         Assert.True(operations.Any());
 
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationRunnerTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationRunnerTests.cs
index 40bffc580478..b319b419481e 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationRunnerTests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationRunnerTests.cs
@@ -66,12 +66,12 @@ public async Task ItCanRunCreateAndUpdateOperationsWithJsonPayloadSuccessfullyAs
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: httpMethod,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -145,12 +145,12 @@ public async Task ItCanRunCreateAndUpdateOperationsWithPlainTextPayloadSuccessfu
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: httpMethod,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -194,30 +194,30 @@ public async Task ItCanRunCreateAndUpdateOperationsWithPlainTextPayloadSuccessfu
     public async Task ItShouldAddHeadersToHttpRequestAsync()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
-            new(name: "X-HS-1", type: "string", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HA-1", type: "array", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HA-2", type: "array", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HB-1", type: "boolean", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HB-2", type: "boolean", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HI-1", type: "integer", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HI-2", type: "integer", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HN-1", type: "number", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HN-2", type: "number", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HD-1", type: "string", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HD-2", type: "string", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "X-HD-3", type: "string", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
+            new(name: "X-HS-1", type: "string", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HA-1", type: "array", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HA-2", type: "array", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HB-1", type: "boolean", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HB-2", type: "boolean", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HI-1", type: "integer", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HI-2", type: "integer", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HN-1", type: "number", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HN-2", type: "number", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HD-1", type: "string", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HD-2", type: "string", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "X-HD-3", type: "string", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
         };
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -266,25 +266,25 @@ public async Task ItShouldAddHeadersToHttpRequestAsync()
     public async Task ItShouldAddUserAgentHeaderToHttpRequestIfConfiguredAsync()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
             new(
             name: "fake-header",
             type: "string",
             isRequired: true,
             expand: false,
-            location: RestApiOperationParameterLocation.Header,
-            style: RestApiOperationParameterStyle.Simple)
+            location: RestApiParameterLocation.Header,
+            style: RestApiParameterStyle.Simple)
         };
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -313,7 +313,7 @@ public async Task ItShouldBuildJsonPayloadDynamicallyAsync()
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("name", "string", true, []),
             new("attributes", "object", false,
@@ -322,16 +322,16 @@ public async Task ItShouldBuildJsonPayloadDynamicallyAsync()
             ])
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -375,7 +375,7 @@ public async Task ItShouldBuildJsonPayloadDynamicallyUsingPayloadMetadataDataTyp
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("name", "string", true, []),
             new("attributes", "object", false,
@@ -388,16 +388,16 @@ public async Task ItShouldBuildJsonPayloadDynamicallyUsingPayloadMetadataDataTyp
             ])
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -462,7 +462,7 @@ public async Task ItShouldBuildJsonPayloadDynamicallyResolvingArgumentsByFullNam
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("upn", "string", true, []),
             new("receiver", "object", false,
@@ -479,16 +479,16 @@ public async Task ItShouldBuildJsonPayloadDynamicallyResolvingArgumentsByFullNam
             ])
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -555,12 +555,12 @@ public async Task ItShouldThrowExceptionIfPayloadMetadataDoesNotHaveContentTypeA
         // Arrange
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: null
         );
@@ -584,12 +584,12 @@ public async Task ItShouldThrowExceptionIfContentTypeArgumentIsNotProvidedAsync(
         // Arrange
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: null
         );
@@ -613,16 +613,16 @@ public async Task ItShouldUsePayloadArgumentForPlainTextContentTypeWhenBuildingP
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Text.Plain);
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Text.Plain, []);
+        var payload = new RestApiPayload(MediaTypeNames.Text.Plain, []);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -659,12 +659,12 @@ public async Task ItShouldUsePayloadAndContentTypeArgumentsIfDynamicPayloadBuild
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: null
         );
@@ -698,21 +698,21 @@ public async Task ItShouldBuildJsonPayloadDynamicallyExcludingOptionalParameters
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("upn", "string", false, []),
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -746,21 +746,21 @@ public async Task ItShouldBuildJsonPayloadDynamicallyIncludingOptionalParameters
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("upn", "string", false, []),
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -794,30 +794,30 @@ public async Task ItShouldAddRequiredQueryStringParametersIfTheirArgumentsProvid
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        var firstParameter = new RestApiOperationParameter(
+        var firstParameter = new RestApiParameter(
             "p1",
             "string",
             isRequired: true, //Marking the parameter as required
             false,
-            RestApiOperationParameterLocation.Query,
-            RestApiOperationParameterStyle.Form);
+            RestApiParameterLocation.Query,
+            RestApiParameterStyle.Form);
 
-        var secondParameter = new RestApiOperationParameter(
+        var secondParameter = new RestApiParameter(
             "p2",
             "integer",
             isRequired: true, //Marking the parameter as required
             false,
-            RestApiOperationParameterLocation.Query,
-            RestApiOperationParameterStyle.Form);
+            RestApiParameterLocation.Query,
+            RestApiParameterStyle.Form);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: [firstParameter, secondParameter],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -843,30 +843,30 @@ public async Task ItShouldAddNotRequiredQueryStringParametersIfTheirArgumentsPro
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        var firstParameter = new RestApiOperationParameter(
+        var firstParameter = new RestApiParameter(
             "p1",
             "string",
             isRequired: false, //Marking the parameter as not required
             false,
-            RestApiOperationParameterLocation.Query,
-            RestApiOperationParameterStyle.Form);
+            RestApiParameterLocation.Query,
+            RestApiParameterStyle.Form);
 
-        var secondParameter = new RestApiOperationParameter(
+        var secondParameter = new RestApiParameter(
             "p2",
             "string",
             isRequired: false, //Marking the parameter as not required
             false,
-            RestApiOperationParameterLocation.Query,
-            RestApiOperationParameterStyle.Form);
+            RestApiParameterLocation.Query,
+            RestApiParameterStyle.Form);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: [firstParameter, secondParameter],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -892,30 +892,30 @@ public async Task ItShouldSkipNotRequiredQueryStringParametersIfNoArgumentsProvi
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        var firstParameter = new RestApiOperationParameter(
+        var firstParameter = new RestApiParameter(
             "p1",
             "string",
             isRequired: false, //Marking the parameter as not required
             false,
-            RestApiOperationParameterLocation.Query,
-            RestApiOperationParameterStyle.Form);
+            RestApiParameterLocation.Query,
+            RestApiParameterStyle.Form);
 
-        var secondParameter = new RestApiOperationParameter(
+        var secondParameter = new RestApiParameter(
             "p2",
             "string",
             isRequired: true, //Marking the parameter as required
             false,
-            RestApiOperationParameterLocation.Query,
-            RestApiOperationParameterStyle.Form);
+            RestApiParameterLocation.Query,
+            RestApiParameterStyle.Form);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: [firstParameter, secondParameter],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -940,22 +940,22 @@ public async Task ItShouldThrowExceptionIfNoArgumentProvidedForRequiredQueryStri
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
             "p1",
             "string",
             isRequired: true, //Marking the parameter as required
             false,
-            RestApiOperationParameterLocation.Query,
-            RestApiOperationParameterStyle.Form);
+            RestApiParameterLocation.Query,
+            RestApiParameterStyle.Form);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: [parameter],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -982,12 +982,12 @@ public async Task ItShouldReadContentAsStringSuccessfullyAsync(string contentTyp
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -1025,12 +1025,12 @@ public async Task ItShouldReadContentAsBytesSuccessfullyAsync(string contentType
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -1061,12 +1061,12 @@ public async Task ItShouldThrowExceptionForUnsupportedContentTypeAsync()
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -1092,7 +1092,7 @@ public async Task ItShouldReturnRequestUriAndContentAsync()
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("name", "string", true, []),
             new("attributes", "object", false,
@@ -1101,16 +1101,16 @@ public async Task ItShouldReturnRequestUriAndContentAsync()
             ])
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -1142,7 +1142,7 @@ public async Task ItShouldHandleNoContentAsync()
         // Arrange
         this._httpMessageHandlerStub!.ResponseToReturn = new HttpResponseMessage(System.Net.HttpStatusCode.NoContent);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("name", "string", true, []),
             new("attributes", "object", false,
@@ -1151,16 +1151,16 @@ public async Task ItShouldHandleNoContentAsync()
             ])
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -1192,7 +1192,7 @@ public async Task ItShouldSetHttpRequestMessageOptionsAsync()
         // Arrange
         this._httpMessageHandlerStub.ResponseToReturn.Content = new StringContent("fake-content", Encoding.UTF8, MediaTypeNames.Application.Json);
 
-        List<RestApiOperationPayloadProperty> payloadProperties =
+        List<RestApiPayloadProperty> payloadProperties =
         [
             new("name", "string", true, []),
             new("attributes", "object", false,
@@ -1201,16 +1201,16 @@ public async Task ItShouldSetHttpRequestMessageOptionsAsync()
             ])
         ];
 
-        var payload = new RestApiOperationPayload(MediaTypeNames.Application.Json, payloadProperties);
+        var payload = new RestApiPayload(MediaTypeNames.Application.Json, payloadProperties);
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: [],
             payload: payload
         );
@@ -1251,12 +1251,12 @@ public async Task ItShouldIncludeRequestDataWhenOperationCanceledExceptionIsThro
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Post,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -1282,12 +1282,12 @@ public async Task ItShouldUseCustomHttpResponseContentReaderAsync()
         // Arrange
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -1317,12 +1317,12 @@ public async Task ItShouldUseDefaultHttpResponseContentReaderIfCustomDoesNotRetu
 
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -1350,12 +1350,12 @@ public async Task ItShouldDisposeContentStreamAndHttpResponseContentMessageAsync
         // Arrange
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -1393,38 +1393,38 @@ public IEnumerator<object[]> GetEnumerator()
         {
             yield return new object[] {
                     "default",
-                    new (string, RestApiOperationExpectedResponse)[] {
-                        ("400", new RestApiOperationExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
-                        ("default", new RestApiOperationExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
+                    new (string, RestApiExpectedResponse)[] {
+                        ("400", new RestApiExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
+                        ("default", new RestApiExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
                     },
             };
             yield return new object[] {
                     "200",
-                    new (string, RestApiOperationExpectedResponse)[] {
-                        ("200", new RestApiOperationExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
-                        ("default", new RestApiOperationExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
+                    new (string, RestApiExpectedResponse)[] {
+                        ("200", new RestApiExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
+                        ("default", new RestApiExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
                     },
             };
             yield return new object[] {
                     "2XX",
-                    new (string, RestApiOperationExpectedResponse)[] {
-                        ("2XX", new RestApiOperationExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
-                        ("default", new RestApiOperationExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
+                    new (string, RestApiExpectedResponse)[] {
+                        ("2XX", new RestApiExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
+                        ("default", new RestApiExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
                     },
             };
             yield return new object[] {
                     "2XX",
-                    new (string, RestApiOperationExpectedResponse)[] {
-                        ("2XX", new RestApiOperationExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
-                        ("default", new RestApiOperationExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
+                    new (string, RestApiExpectedResponse)[] {
+                        ("2XX", new RestApiExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("FakeResponseSchema.json")))),
+                        ("default", new RestApiExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
                     },
             };
             yield return new object[] {
                     "200",
-                    new (string, RestApiOperationExpectedResponse)[] {
-                        ("default", new RestApiOperationExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
-                        ("2XX", new RestApiOperationExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("2XXFakeResponseSchema.json")))),
-                        ("200", new RestApiOperationExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("200FakeResponseSchema.json")))),
+                    new (string, RestApiExpectedResponse)[] {
+                        ("default", new RestApiExpectedResponse("Default response content", "application/json", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("DefaultResponseSchema.json")))),
+                        ("2XX", new RestApiExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("2XXFakeResponseSchema.json")))),
+                        ("200", new RestApiExpectedResponse("fake-content", "fake-content-type", KernelJsonSchema.Parse(ResourceResponseProvider.LoadFromResource("200FakeResponseSchema.json")))),
                     },
             };
         }
@@ -1434,11 +1434,11 @@ public IEnumerator<object[]> GetEnumerator()
 
     [Theory]
     [ClassData(typeof(SchemaTestData))]
-    public async Task ItShouldReturnExpectedSchemaAsync(string expectedStatusCode, params (string, RestApiOperationExpectedResponse)[] responses)
+    public async Task ItShouldReturnExpectedSchemaAsync(string expectedStatusCode, params (string, RestApiExpectedResponse)[] responses)
     {
         var operation = new RestApiOperation(
             id: "fake-id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path",
             method: HttpMethod.Get,
             description: "fake-description",
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationTests.cs
index 3d2ccd6c32d7..31f7accdc400 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationTests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationTests.cs
@@ -24,12 +24,12 @@ public void ItShouldUseHostUrlIfNoOverrideProvided()
         // Arrange
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "/",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -48,12 +48,12 @@ public void ItShouldUseHostUrlOverrideIfProvided()
         // Arrange
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "/",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -72,31 +72,31 @@ public void ItShouldUseHostUrlOverrideIfProvided()
     public void ItShouldBuildOperationUrlWithPathParametersFromArguments()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter> {
+        var parameters = new List<RestApiParameter> {
             new(
                 name: "p1",
                 type: "string",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Path,
-                style: RestApiOperationParameterStyle.Simple),
+                location: RestApiParameterLocation.Path,
+                style: RestApiParameterStyle.Simple),
             new(
                 name: "p2",
                 type: "number",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Path,
-                style: RestApiOperationParameterStyle.Simple)
+                location: RestApiParameterLocation.Path,
+                style: RestApiParameterStyle.Simple)
         };
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "/{p1}/{p2}/other_fake_path_section",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -117,31 +117,31 @@ public void ItShouldBuildOperationUrlWithPathParametersFromArguments()
     public void ItShouldBuildOperationUrlWithEncodedArguments()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter> {
+        var parameters = new List<RestApiParameter> {
             new(
                 name: "p1",
                 type: "string",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Path,
-                style: RestApiOperationParameterStyle.Simple),
+                location: RestApiParameterLocation.Path,
+                style: RestApiParameterStyle.Simple),
             new(
                 name: "p2",
                 type: "string",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Path,
-                style: RestApiOperationParameterStyle.Simple)
+                location: RestApiParameterLocation.Path,
+                style: RestApiParameterStyle.Simple)
         };
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "/{p1}/{p2}/other_fake_path_section",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -162,30 +162,30 @@ public void ItShouldBuildOperationUrlWithEncodedArguments()
     public void ShouldBuildResourceUrlWithoutQueryString()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter> {
+        var parameters = new List<RestApiParameter> {
             new(
                 name: "p1",
                 type: "string",
                 isRequired: false,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query,
+                location: RestApiParameterLocation.Query,
                 defaultValue: "dv1"),
             new(
                 name: "fake-path",
                 type: "string",
                 isRequired: false,
                 expand: false,
-                location: RestApiOperationParameterLocation.Path)
+                location: RestApiParameterLocation.Path)
         };
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "{fake-path}/",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -207,29 +207,29 @@ public void ShouldBuildResourceUrlWithoutQueryString()
     public void ItShouldBuildQueryString()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter> {
+        var parameters = new List<RestApiParameter> {
             new(
                 name: "since_create_time",
                 type: "string",
                 isRequired: false,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query),
+                location: RestApiParameterLocation.Query),
             new(
                 name: "before_create_time",
                 type: "string",
                 isRequired: false,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query),
+                location: RestApiParameterLocation.Query),
         };
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path/",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -250,23 +250,23 @@ public void ItShouldBuildQueryString()
     public void ItShouldBuildQueryStringWithQuotes()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter> {
+        var parameters = new List<RestApiParameter> {
             new(
                 name: "has_quotes",
                 type: "string",
                 isRequired: false,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query)
+                location: RestApiParameterLocation.Query)
         };
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path/",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -286,23 +286,23 @@ public void ItShouldBuildQueryStringWithQuotes()
     public void ItShouldBuildQueryStringForArray()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter> {
+        var parameters = new List<RestApiParameter> {
             new(
                 name: "times",
                 type: "array",
                 isRequired: false,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query),
+                location: RestApiParameterLocation.Query),
         };
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake-path/",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -322,23 +322,23 @@ public void ItShouldBuildQueryStringForArray()
     public void ItShouldRenderHeaderValuesFromArguments()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
             new(
                 name: "fake_header_one",
                 type: "string",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Header,
-                style: RestApiOperationParameterStyle.Simple),
+                location: RestApiParameterLocation.Header,
+                style: RestApiParameterStyle.Simple),
 
             new(
                 name: "fake_header_two",
                 type: "string",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Header,
-                style: RestApiOperationParameterStyle.Simple)
+                location: RestApiParameterLocation.Header,
+                style: RestApiParameterStyle.Simple)
         };
 
         var arguments = new Dictionary<string, object?>
@@ -349,12 +349,12 @@ public void ItShouldRenderHeaderValuesFromArguments()
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("http://fake_url")],
+            servers: [new RestApiServer("http://fake_url")],
             path: "fake_path",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -375,20 +375,20 @@ public void ItShouldRenderHeaderValuesFromArguments()
     public void ShouldThrowExceptionIfNoValueProvidedForRequiredHeader()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
-            new(name: "fake_header_one", type: "string", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "fake_header_two", type : "string", isRequired : false, expand : false, location : RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple)
+            new(name: "fake_header_one", type: "string", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "fake_header_two", type : "string", isRequired : false, expand : false, location : RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple)
         };
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("http://fake_url")],
+            servers: [new RestApiServer("http://fake_url")],
             path: "fake_path",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -403,10 +403,10 @@ public void ShouldThrowExceptionIfNoValueProvidedForRequiredHeader()
     public void ItShouldSkipOptionalHeaderHavingNoValue()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
-            new(name: "fake_header_one", type : "string", isRequired : true, expand : false, location : RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "fake_header_two", type : "string", isRequired : false, expand : false, location : RestApiOperationParameterLocation.Header, style : RestApiOperationParameterStyle.Simple)
+            new(name: "fake_header_one", type : "string", isRequired : true, expand : false, location : RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "fake_header_two", type : "string", isRequired : false, expand : false, location : RestApiParameterLocation.Header, style : RestApiParameterStyle.Simple)
         };
 
         var arguments = new Dictionary<string, object?>
@@ -416,12 +416,12 @@ public void ItShouldSkipOptionalHeaderHavingNoValue()
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("http://fake_url")],
+            servers: [new RestApiServer("http://fake_url")],
             path: "fake_path",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -439,10 +439,10 @@ public void ItShouldSkipOptionalHeaderHavingNoValue()
     public void ItShouldCreateHeaderWithCommaSeparatedValues()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
-            new( name: "h1", type: "array", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple, arrayItemType: "string"),
-            new( name: "h2", type: "array", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple, arrayItemType: "integer")
+            new( name: "h1", type: "array", isRequired: false, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple, arrayItemType: "string"),
+            new( name: "h2", type: "array", isRequired: false, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple, arrayItemType: "integer")
         };
 
         var arguments = new Dictionary<string, object?>
@@ -453,12 +453,12 @@ public void ItShouldCreateHeaderWithCommaSeparatedValues()
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake_path",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -477,10 +477,10 @@ public void ItShouldCreateHeaderWithCommaSeparatedValues()
     public void ItShouldCreateHeaderWithPrimitiveValue()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
-            new( name: "h1", type: "string", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new( name: "h2", type: "boolean", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple)
+            new( name: "h1", type: "string", isRequired: false, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new( name: "h2", type: "boolean", isRequired: false, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple)
         };
 
         var arguments = new Dictionary<string, object?>
@@ -491,12 +491,12 @@ public void ItShouldCreateHeaderWithPrimitiveValue()
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake_path",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -515,10 +515,10 @@ public void ItShouldCreateHeaderWithPrimitiveValue()
     public void ItShouldMixAndMatchHeadersOfDifferentValueTypes()
     {
         // Arrange
-        var parameters = new List<RestApiOperationParameter>
+        var parameters = new List<RestApiParameter>
         {
-            new(name: "h1", type: "array", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
-            new(name: "h2", type: "boolean", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple),
+            new(name: "h1", type: "array", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
+            new(name: "h2", type: "boolean", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple),
         };
 
         var arguments = new Dictionary<string, object?>
@@ -529,12 +529,12 @@ public void ItShouldMixAndMatchHeadersOfDifferentValueTypes()
 
         var sut = new RestApiOperation(
             id: "fake_id",
-            servers: [new RestApiOperationServer("https://fake-random-test-host")],
+            servers: [new RestApiServer("https://fake-random-test-host")],
             path: "fake_path",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: parameters,
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -784,14 +784,14 @@ public void ItShouldUseDefaultServerVariableIfNoOverrideProvided()
         var sut = new RestApiOperation(
             id: "fake_id",
             servers: [
-                new RestApiOperationServer("https://example.com/{version}", new Dictionary<string, RestApiOperationServerVariable> { { "version", new RestApiOperationServerVariable("v2") } }),
-                new RestApiOperationServer("https://ppe.example.com/{version}", new Dictionary<string, RestApiOperationServerVariable> { { "version", new RestApiOperationServerVariable("v2") } })
+                new RestApiServer("https://example.com/{version}", new Dictionary<string, RestApiServerVariable> { { "version", new RestApiServerVariable("v2") } }),
+                new RestApiServer("https://ppe.example.com/{version}", new Dictionary<string, RestApiServerVariable> { { "version", new RestApiServerVariable("v2") } })
             ],
             path: "/items",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -808,18 +808,18 @@ public void ItShouldUseDefaultServerVariableIfNoOverrideProvided()
     public void ItShouldUseDefaultServerVariableIfInvalidOverrideProvided()
     {
         // Arrange
-        var version = new RestApiOperationServerVariable("v2", null, ["v1", "v2"]);
+        var version = new RestApiServerVariable("v2", null, ["v1", "v2"]);
         var sut = new RestApiOperation(
             id: "fake_id",
             servers: [
-                new RestApiOperationServer("https://example.com/{version}", new Dictionary<string, RestApiOperationServerVariable> { { "version", version } }),
-                new RestApiOperationServer("https://ppe.example.com/{version}", new Dictionary<string, RestApiOperationServerVariable> { { "version", new RestApiOperationServerVariable("v2") } })
+                new RestApiServer("https://example.com/{version}", new Dictionary<string, RestApiServerVariable> { { "version", version } }),
+                new RestApiServer("https://ppe.example.com/{version}", new Dictionary<string, RestApiServerVariable> { { "version", new RestApiServerVariable("v2") } })
             ],
             path: "/items",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
@@ -836,18 +836,18 @@ public void ItShouldUseDefaultServerVariableIfInvalidOverrideProvided()
     public void ItShouldUseServerVariableOverrideIfProvided()
     {
         // Arrange
-        var version = new RestApiOperationServerVariable("v2", null, ["v1", "v2", "v3"]);
+        var version = new RestApiServerVariable("v2", null, ["v1", "v2", "v3"]);
         var sut = new RestApiOperation(
             id: "fake_id",
             servers: [
-                new RestApiOperationServer("https://example.com/{version}", new Dictionary<string, RestApiOperationServerVariable> { { "version", version } }),
-                new RestApiOperationServer("https://ppe.example.com/{version}", new Dictionary<string, RestApiOperationServerVariable> { { "version", new RestApiOperationServerVariable("v2") } })
+                new RestApiServer("https://example.com/{version}", new Dictionary<string, RestApiServerVariable> { { "version", version } }),
+                new RestApiServer("https://ppe.example.com/{version}", new Dictionary<string, RestApiServerVariable> { { "version", new RestApiServerVariable("v2") } })
             ],
             path: "/items",
             method: HttpMethod.Get,
             description: "fake_description",
             parameters: [],
-            responses: new Dictionary<string, RestApiOperationExpectedResponse>(),
+            responses: new Dictionary<string, RestApiExpectedResponse>(),
             securityRequirements: []
         );
 
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/FormStyleParametersSerializerTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/FormStyleParametersSerializerTests.cs
index 3d27259b0936..c33839f18c5a 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/FormStyleParametersSerializerTests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/FormStyleParametersSerializerTests.cs
@@ -13,13 +13,13 @@ public class FormStyleParametersSerializerTests
     public void ItShouldCreateAmpersandSeparatedParameterPerArrayItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "array",
                 isRequired: true,
                 expand: true, //Specify generating a separate parameter for each array item.
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.Form,
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.Form,
                 arrayItemType: "integer");
 
         // Act
@@ -35,13 +35,13 @@ public void ItShouldCreateAmpersandSeparatedParameterPerArrayItem()
     public void ItShouldCreateParameterWithCommaSeparatedValuePerArrayItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "array",
                 isRequired: true,
                 expand: false, //Specify generating a parameter with comma-separated values for each array item.
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.Form,
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.Form,
                 arrayItemType: "integer");
 
         // Act
@@ -57,13 +57,13 @@ public void ItShouldCreateParameterWithCommaSeparatedValuePerArrayItem()
     public void ItShouldCreateParameterForPrimitiveValue()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "integer",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.Form);
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.Form);
 
         // Act
         var result = FormStyleParameterSerializer.Serialize(parameter, "28");
@@ -78,13 +78,13 @@ public void ItShouldCreateParameterForPrimitiveValue()
     public void ItShouldCreateParameterForDateTimeValue()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "string",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.Form);
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.Form);
 
         // Act
         var result = FormStyleParameterSerializer.Serialize(parameter, JsonValue.Create(new DateTime(2023, 12, 06, 11, 53, 36, DateTimeKind.Utc)));
@@ -100,13 +100,13 @@ public void ItShouldCreateParameterForDateTimeValue()
     public void ItShouldCreateParameterForStringValue(string value, string encodedValue)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "string",
                 isRequired: true,
                 expand: false,
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.Form);
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.Form);
 
         // Act
         var result = FormStyleParameterSerializer.Serialize(parameter, JsonValue.Create(value));
@@ -125,7 +125,7 @@ public void ItShouldCreateParameterForStringValue(string value, string encodedVa
     public void ItShouldEncodeSpecialSymbolsInPrimitiveParameterValues(string specialSymbol, string encodedEquivalent)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter("id", "string", false, false, RestApiOperationParameterLocation.Query, RestApiOperationParameterStyle.Form);
+        var parameter = new RestApiParameter("id", "string", false, false, RestApiParameterLocation.Query, RestApiParameterStyle.Form);
 
         // Act
         var result = FormStyleParameterSerializer.Serialize(parameter, $"fake_query_param_value{specialSymbol}");
@@ -144,7 +144,7 @@ public void ItShouldEncodeSpecialSymbolsInPrimitiveParameterValues(string specia
     public void ItShouldEncodeSpecialSymbolsInAmpersandSeparatedParameterValues(string specialSymbol, string encodedEquivalent)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter("id", "array", false, true, RestApiOperationParameterLocation.Query, RestApiOperationParameterStyle.Form);
+        var parameter = new RestApiParameter("id", "array", false, true, RestApiParameterLocation.Query, RestApiParameterStyle.Form);
 
         // Act
         var result = FormStyleParameterSerializer.Serialize(parameter, new JsonArray($"{specialSymbol}"));
@@ -163,7 +163,7 @@ public void ItShouldEncodeSpecialSymbolsInAmpersandSeparatedParameterValues(stri
     public void ItShouldEncodeSpecialSymbolsInCommaSeparatedParameterValues(string specialSymbol, string encodedEquivalent)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter("id", "array", false, false, RestApiOperationParameterLocation.Query, RestApiOperationParameterStyle.Form);
+        var parameter = new RestApiParameter("id", "array", false, false, RestApiParameterLocation.Query, RestApiParameterStyle.Form);
 
         // Act
         var result = FormStyleParameterSerializer.Serialize(parameter, new JsonArray($"{specialSymbol}"));
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/PipeDelimitedStyleParametersSerializerTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/PipeDelimitedStyleParametersSerializerTests.cs
index 05fb125924ac..0169766a1495 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/PipeDelimitedStyleParametersSerializerTests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/PipeDelimitedStyleParametersSerializerTests.cs
@@ -13,7 +13,7 @@ public class PipeDelimitedStyleParametersSerializerTests
     public void ItShouldThrowExceptionForUnsupportedParameterStyle()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "p1", type: "string", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.Form);
+        var parameter = new RestApiParameter(name: "p1", type: "string", isRequired: false, expand: false, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.Form);
 
         // Act & Assert
         Assert.Throws<NotSupportedException>(() => PipeDelimitedStyleParameterSerializer.Serialize(parameter, "fake-argument"));
@@ -28,7 +28,7 @@ public void ItShouldThrowExceptionForUnsupportedParameterStyle()
     public void ItShouldThrowExceptionIfParameterTypeIsNotArray(string parameterType)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "p1", type: parameterType, isRequired: false, expand: false, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.PipeDelimited);
+        var parameter = new RestApiParameter(name: "p1", type: parameterType, isRequired: false, expand: false, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.PipeDelimited);
 
         // Act & Assert
         Assert.Throws<NotSupportedException>(() => PipeDelimitedStyleParameterSerializer.Serialize(parameter, "fake-argument"));
@@ -38,13 +38,13 @@ public void ItShouldThrowExceptionIfParameterTypeIsNotArray(string parameterType
     public void ItShouldCreateAmpersandSeparatedParameterPerArrayItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "array",
                 isRequired: true,
                 expand: true, //Specifies to generate a separate parameter for each array item.
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.PipeDelimited,
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.PipeDelimited,
                 arrayItemType: "integer");
 
         // Act
@@ -60,13 +60,13 @@ public void ItShouldCreateAmpersandSeparatedParameterPerArrayItem()
     public void ItShouldCreateParameterWithPipeSeparatedValuePerArrayItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "array",
                 isRequired: true,
                 expand: false, //Specify generating a parameter with pipe-separated values for each array item.
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.PipeDelimited,
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.PipeDelimited,
                 arrayItemType: "integer");
 
         // Act
@@ -86,7 +86,7 @@ public void ItShouldCreateParameterWithPipeSeparatedValuePerArrayItem()
     public void ItShouldEncodeSpecialSymbolsInPipeDelimitedParameterValues(string specialSymbol, string encodedEquivalent)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "array", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.PipeDelimited);
+        var parameter = new RestApiParameter(name: "id", type: "array", isRequired: false, expand: false, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.PipeDelimited);
 
         // Act
         var result = PipeDelimitedStyleParameterSerializer.Serialize(parameter, new JsonArray(specialSymbol));
@@ -105,7 +105,7 @@ public void ItShouldEncodeSpecialSymbolsInPipeDelimitedParameterValues(string sp
     public void ItShouldEncodeSpecialSymbolsInAmpersandDelimitedParameterValues(string specialSymbol, string encodedEquivalent)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "array", isRequired: false, expand: true, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.PipeDelimited);
+        var parameter = new RestApiParameter(name: "id", type: "array", isRequired: false, expand: true, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.PipeDelimited);
 
         // Act
         var result = PipeDelimitedStyleParameterSerializer.Serialize(parameter, new JsonArray(specialSymbol));
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SimpleStyleParametersSerializerTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SimpleStyleParametersSerializerTests.cs
index c29d2353c2d1..c912cf59a206 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SimpleStyleParametersSerializerTests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SimpleStyleParametersSerializerTests.cs
@@ -13,7 +13,7 @@ public class SimpleStyleParametersSerializerTests
     public void ItShouldCreateParameterWithCommaSeparatedValuePerArrayItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "array", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple, arrayItemType: "integer");
+        var parameter = new RestApiParameter(name: "id", type: "array", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple, arrayItemType: "integer");
 
         // Act
         var result = SimpleStyleParameterSerializer.Serialize(parameter, new JsonArray(1, 2, 3));
@@ -28,7 +28,7 @@ public void ItShouldCreateParameterWithCommaSeparatedValuePerArrayItem()
     public void ItShouldCreateParameterWithCommaSeparatedValuePerArrayStringItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "array", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple, arrayItemType: "integer");
+        var parameter = new RestApiParameter(name: "id", type: "array", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple, arrayItemType: "integer");
 
         // Act
         var result = SimpleStyleParameterSerializer.Serialize(parameter, new JsonArray("1", "2", "3"));
@@ -43,7 +43,7 @@ public void ItShouldCreateParameterWithCommaSeparatedValuePerArrayStringItem()
     public void ItShouldCreateParameterForPrimitiveValue()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "integer", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple);
+        var parameter = new RestApiParameter(name: "id", type: "integer", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple);
 
         // Act
         var result = SimpleStyleParameterSerializer.Serialize(parameter, "28");
@@ -62,7 +62,7 @@ public void ItShouldCreateParameterForPrimitiveValue()
     public void ItShouldNotEncodeSpecialSymbolsInPrimitiveParameterValues(string specialSymbol, string expectedSymbol)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "string", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple);
+        var parameter = new RestApiParameter(name: "id", type: "string", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple);
 
         // Act
         var result = SimpleStyleParameterSerializer.Serialize(parameter, $"fake_query_param_value{specialSymbol}");
@@ -81,7 +81,7 @@ public void ItShouldNotEncodeSpecialSymbolsInPrimitiveParameterValues(string spe
     public void ItShouldEncodeSpecialSymbolsInCommaSeparatedParameterValues(string specialSymbol, string expectedSymbol)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "array", isRequired: true, expand: false, location: RestApiOperationParameterLocation.Header, style: RestApiOperationParameterStyle.Simple);
+        var parameter = new RestApiParameter(name: "id", type: "array", isRequired: true, expand: false, location: RestApiParameterLocation.Header, style: RestApiParameterStyle.Simple);
 
         // Act
         var result = SimpleStyleParameterSerializer.Serialize(parameter, new JsonArray(specialSymbol));
diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SpaceDelimitedStyleParametersSerializerTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SpaceDelimitedStyleParametersSerializerTests.cs
index be37663b2ed6..6727842e5f9e 100644
--- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SpaceDelimitedStyleParametersSerializerTests.cs
+++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/Serialization/SpaceDelimitedStyleParametersSerializerTests.cs
@@ -13,7 +13,7 @@ public class SpaceDelimitedStyleParametersSerializerTests
     public void ItShouldThrowExceptionForUnsupportedParameterStyle()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "p1", type: "string", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.Label);
+        var parameter = new RestApiParameter(name: "p1", type: "string", isRequired: false, expand: false, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.Label);
 
         // Act & Assert
         Assert.Throws<NotSupportedException>(() => SpaceDelimitedStyleParameterSerializer.Serialize(parameter, "fake-argument"));
@@ -28,7 +28,7 @@ public void ItShouldThrowExceptionForUnsupportedParameterStyle()
     public void ItShouldThrowExceptionIfParameterTypeIsNotArray(string parameterType)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "p1", type: parameterType, isRequired: false, expand: false, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.SpaceDelimited);
+        var parameter = new RestApiParameter(name: "p1", type: parameterType, isRequired: false, expand: false, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.SpaceDelimited);
 
         // Act & Assert
         Assert.Throws<NotSupportedException>(() => SpaceDelimitedStyleParameterSerializer.Serialize(parameter, "fake-argument"));
@@ -38,13 +38,13 @@ public void ItShouldThrowExceptionIfParameterTypeIsNotArray(string parameterType
     public void ItShouldCreateAmpersandSeparatedParameterPerArrayItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "array",
                 isRequired: true,
                 expand: true, //Specifies to generate a separate parameter for each array item.
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.SpaceDelimited,
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.SpaceDelimited,
                 arrayItemType: "integer");
 
         // Act
@@ -60,13 +60,13 @@ public void ItShouldCreateAmpersandSeparatedParameterPerArrayItem()
     public void ItShouldCreateParameterWithSpaceSeparatedValuePerArrayItem()
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(
+        var parameter = new RestApiParameter(
                 name: "id",
                 type: "array",
                 isRequired: true,
                 expand: false, //Specify generating a parameter with space-separated values for each array item.
-                location: RestApiOperationParameterLocation.Query,
-                style: RestApiOperationParameterStyle.SpaceDelimited,
+                location: RestApiParameterLocation.Query,
+                style: RestApiParameterStyle.SpaceDelimited,
                 arrayItemType: "integer");
 
         // Act
@@ -86,7 +86,7 @@ public void ItShouldCreateParameterWithSpaceSeparatedValuePerArrayItem()
     public void ItShouldEncodeSpecialSymbolsInSpaceDelimitedParameterValues(string specialSymbol, string encodedEquivalent)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "array", isRequired: false, expand: false, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.SpaceDelimited);
+        var parameter = new RestApiParameter(name: "id", type: "array", isRequired: false, expand: false, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.SpaceDelimited);
 
         // Act
         var result = SpaceDelimitedStyleParameterSerializer.Serialize(parameter, new JsonArray(specialSymbol));
@@ -105,7 +105,7 @@ public void ItShouldEncodeSpecialSymbolsInSpaceDelimitedParameterValues(string s
     public void ItShouldEncodeSpecialSymbolsInAmpersandDelimitedParameterValues(string specialSymbol, string encodedEquivalent)
     {
         // Arrange
-        var parameter = new RestApiOperationParameter(name: "id", type: "array", isRequired: false, expand: true, location: RestApiOperationParameterLocation.Query, style: RestApiOperationParameterStyle.SpaceDelimited);
+        var parameter = new RestApiParameter(name: "id", type: "array", isRequired: false, expand: true, location: RestApiParameterLocation.Query, style: RestApiParameterStyle.SpaceDelimited);
 
         // Act
         var result = SpaceDelimitedStyleParameterSerializer.Serialize(parameter, new JsonArray(specialSymbol));