diff --git a/packages/http-client-csharp/emitter/src/lib/operation-converter.ts b/packages/http-client-csharp/emitter/src/lib/operation-converter.ts index a8effdf26fd..a061c8ee503 100644 --- a/packages/http-client-csharp/emitter/src/lib/operation-converter.ts +++ b/packages/http-client-csharp/emitter/src/lib/operation-converter.ts @@ -5,6 +5,7 @@ import { getClientNamespace, getClientOptions, getHttpOperationParameter, + getParamAlias, isHttpMetadata, SdkBodyParameter, SdkBuiltInKinds, @@ -562,6 +563,8 @@ export function fromMethodParameter( const parameterType = fromSdkType(sdkContext, p.type, p, namespace); + const paramAlias = p.__raw ? getParamAlias(sdkContext, p.__raw) : undefined; + retVar = { kind: "method", name: p.name, @@ -578,6 +581,7 @@ export function fromMethodParameter( readOnly: isReadOnly(p), access: p.access, decorators: p.decorators, + paramAlias, }; sdkContext.__typeCache.updateSdkMethodParameterReferences(p, retVar); diff --git a/packages/http-client-csharp/emitter/src/type/input-type.ts b/packages/http-client-csharp/emitter/src/type/input-type.ts index 2f5ffd7d5fe..96189e1a161 100644 --- a/packages/http-client-csharp/emitter/src/type/input-type.ts +++ b/packages/http-client-csharp/emitter/src/type/input-type.ts @@ -199,6 +199,7 @@ export interface InputMethodParameter extends InputPropertyTypeBase { location: RequestLocation; scope: InputParameterScope; serializedName: string; + paramAlias?: string; } export interface InputQueryParameter extends InputPropertyTypeBase { diff --git a/packages/http-client-csharp/emitter/test/Unit/client-initialization.test.ts b/packages/http-client-csharp/emitter/test/Unit/client-initialization.test.ts index 8715259052f..0af11ee1ccc 100644 --- a/packages/http-client-csharp/emitter/test/Unit/client-initialization.test.ts +++ b/packages/http-client-csharp/emitter/test/Unit/client-initialization.test.ts @@ -4,6 +4,7 @@ import { TestHost } from "@typespec/compiler/testing"; import { ok, strictEqual } from "assert"; import { beforeEach, describe, it, vi } from "vitest"; import { createModel } from "../../src/lib/client-model-builder.js"; +import { InputMethodParameter } from "../../src/type/input-type.js"; import { createCSharpSdkContext, createEmitterContext, @@ -123,4 +124,82 @@ describe("ClientInitialization", () => { ok("initializedBy" in childClient, "Child client should have initializedBy field"); } }); + + it("should include paramAlias on client parameters when @paramAlias is used", async () => { + const program = await typeSpecCompile( + ` + @service(#{ + title: "Test Service", + }) + @server("https://example.com", "Test endpoint") + namespace TestService; + + op upload(@path blobName: string): void; + + model TestServiceClientOptions { + @paramAlias("blobName") + blob: string; + } + + @@clientInitialization(TestService, {parameters: TestServiceClientOptions}); + `, + runner, + { IsNamespaceNeeded: false, IsTCGCNeeded: true }, + ); + + const context = createEmitterContext(program); + const sdkContext = await createCSharpSdkContext(context); + const root = createModel(sdkContext); + + const client = root.clients[0]; + ok(client, "Client should exist"); + ok(client.parameters, "Client should have parameters"); + + // Find the method parameter with paramAlias + const blobParam = client.parameters.find((p) => p.kind === "method" && p.name === "blob") as + | InputMethodParameter + | undefined; + ok(blobParam, "Should have a 'blob' method parameter"); + strictEqual(blobParam.paramAlias, "blobName", "paramAlias should be 'blobName'"); + }); + + it("should not include paramAlias when @paramAlias is not used", async () => { + const program = await typeSpecCompile( + ` + @service(#{ + title: "Test Service", + }) + @server("https://example.com", "Test endpoint") + namespace TestService; + + op upload(@path blobName: string): void; + + model TestServiceClientOptions { + blobName: string; + } + + @@clientInitialization(TestService, {parameters: TestServiceClientOptions}); + `, + runner, + { IsNamespaceNeeded: false, IsTCGCNeeded: true }, + ); + + const context = createEmitterContext(program); + const sdkContext = await createCSharpSdkContext(context); + const root = createModel(sdkContext); + + const client = root.clients[0]; + ok(client, "Client should exist"); + ok(client.parameters, "Client should have parameters"); + + const blobParam = client.parameters.find( + (p) => p.kind === "method" && p.name === "blobName", + ) as InputMethodParameter | undefined; + ok(blobParam, "Should have a 'blobName' method parameter"); + strictEqual( + blobParam.paramAlias, + undefined, + "paramAlias should be undefined when @paramAlias is not used", + ); + }); }); diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs index 7cb68c21967..9117161aafd 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs @@ -195,6 +195,7 @@ public ClientProvider(InputClient inputClient) _additionalClientFields = new(BuildAdditionalClientFields); _subClientInternalConstructorParams = new(GetSubClientInternalConstructorParameters); _clientParameters = new(GetClientParameters); + _effectiveClientParamNames = new(() => GetEffectiveParameterNames(_inputClient.Parameters)); _subClients = new(GetSubClients); _allClientParameters = GetAllClientParameters(); } @@ -316,15 +317,36 @@ private IReadOnlyList GetSubClientInternalConstructorParamete /// internal bool HasAccessorOnlyParameters(InputClient parentInputClient) { - var parentParamNames = parentInputClient.Parameters - .Select(p => p.Name) - .ToHashSet(StringComparer.OrdinalIgnoreCase); + var parentParamNames = GetEffectiveParameterNames(parentInputClient.Parameters); return _inputClient.Parameters .Where(p => !p.IsApiVersion && !(p is InputEndpointParameter ep && ep.IsEndpoint)) - .Any(p => !parentParamNames.Contains(p.Name)); + .Any(p => !IsSupersededByClientParameter(p, parentParamNames)); } + /// + /// Builds a set of effective parameter names. When a parameter has a ParamAlias, + /// the alias is used instead of the parameter name. + /// + private static HashSet GetEffectiveParameterNames(IReadOnlyList parameters) + { + var names = new HashSet(StringComparer.OrdinalIgnoreCase); + foreach (var p in parameters) + { + if (p is InputMethodParameter { ParamAlias: string alias }) + { + names.Add(alias); + } + else + { + names.Add(p.Name); + } + } + return names; + } + + private Lazy> _effectiveClientParamNames; + private Lazy> _clientParameters; internal IReadOnlyList ClientParameters => _clientParameters.Value; private IReadOnlyList GetClientParameters() @@ -1143,11 +1165,8 @@ protected override ScmMethodProvider[] BuildMethods() // Identify subclient-specific parameters by comparing with the parent's input parameters. // Parameters present on both parent and subclient are shared (sourced from parent fields/properties). - var parentInputParamNames = _inputClient.Parameters - .Select(p => p.Name) - .ToHashSet(StringComparer.OrdinalIgnoreCase); var subClientSpecificParamNames = subClient._inputClient.Parameters - .Where(p => !parentInputParamNames.Contains(p.Name)) + .Where(p => !IsSupersededByClientParameter(p, _effectiveClientParamNames.Value)) .Select(p => p.Name) .ToHashSet(StringComparer.OrdinalIgnoreCase); @@ -1497,10 +1516,17 @@ private IReadOnlyList GetSubClients() private IReadOnlyList GetAllClientParameters() { - // Get all parameters from the client and its methods, deduplicating by SerializedName to handle renamed parameters + var clientParamNames = _effectiveClientParamNames.Value; + + // Get all parameters from the client and its methods, deduplicating by SerializedName to handle renamed parameters. + // When @paramAlias is used (via @clientInitialization), an operation parameter may map + // to a client parameter via MethodParameterSegments or ParamAlias. Exclude such operation + // parameters since the client parameter supersedes them. var parameters = _inputClient.Parameters.Concat( _inputClient.Methods.SelectMany(m => m.Operation.Parameters) - .Where(p => p.Scope == InputParameterScope.Client)).DistinctBy(p => p.SerializedName ?? p.Name).ToArray(); + .Where(p => p.Scope == InputParameterScope.Client) + .Where(p => !IsSupersededByClientParameter(p, clientParamNames))) + .DistinctBy(p => p.SerializedName ?? p.Name).ToArray(); foreach (var subClient in _subClients.Value) { @@ -1512,6 +1538,26 @@ private IReadOnlyList GetAllClientParameters() return parameters; } + /// + /// Determines whether a parameter is superseded by an existing client parameter, + /// either by direct name match or via MethodParameterSegments. + /// + private static bool IsSupersededByClientParameter(InputParameter param, HashSet clientParamNames) + { + if (clientParamNames.Contains(param.Name)) + { + return true; + } + + if (param.MethodParameterSegments is { Count: > 0 } segments && + clientParamNames.Contains(segments[0].Name)) + { + return true; + } + + return false; + } + private FieldProvider BuildTokenCredentialScopesField(InputOAuth2Auth oauth2Auth, CSharpType tokenCredentialType) { return tokenCredentialType.Equals(ClientPipelineProvider.Instance.TokenCredentialType) diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/RestClientProvider.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/RestClientProvider.cs index 17c09257962..275644a5db7 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/RestClientProvider.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/RestClientProvider.cs @@ -201,6 +201,17 @@ private MethodBodyStatements BuildMessage( paramMap[param.Name] = param; } + // Register client parameters under their paramAlias names so that operation parameters + // (which use the original name) can find the corresponding client parameter. + foreach (var inputParam in _inputClient.Parameters) + { + if (inputParam is InputMethodParameter { ParamAlias: string alias } && + paramMap.TryGetValue(inputParam.Name, out var aliasedParam)) + { + paramMap[alias] = aliasedParam; + } + } + InputPagingServiceMethod? pagingServiceMethod = serviceMethod as InputPagingServiceMethod; var uriBuilderType = ScmCodeModelGenerator.Instance.TypeFactory.HttpRequestApi.ToExpression().UriBuilderType; @@ -715,7 +726,8 @@ private void AddUriSegments( /* when the parameter is in operation.uri, it is client parameter * It is not operation parameter and not in inputParamHash list. */ - var isClientParameter = ClientProvider.ClientParameters.Any(p => string.Equals(p.Name, paramName, StringComparison.OrdinalIgnoreCase)); + var isClientParameter = ClientProvider.ClientParameters.Any(p => string.Equals(p.Name, paramName, StringComparison.OrdinalIgnoreCase)) + || _inputClient.Parameters.Any(p => p is InputMethodParameter { ParamAlias: string alias } && string.Equals(alias, paramName, StringComparison.OrdinalIgnoreCase)); CSharpType? type; SerializationFormat? serializationFormat; ValueExpression? valueExpression; diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderSubClientTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderSubClientTests.cs index 2642f7e2798..46566e74c68 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderSubClientTests.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderSubClientTests.cs @@ -79,6 +79,45 @@ public void SubClientSummaryIsPopulatedWithDefaultDocs() Assert.AreEqual("/// The Test sub-client. \n", client!.XmlDocs.Summary!.ToDisplayString()); } + [Test] + public void HasAccessorOnlyParameters_ReturnsFalse_WhenSubClientParamMatchesParentAlias() + { + // Parent has parameter "blobName" with paramAlias "name" + // Subclient has parameter "name" + // The alias should make it recognized as a shared parameter, not subclient-specific + var parentClient = InputFactory.Client( + "ParentClient", + parameters: [InputFactory.MethodParameter("blobName", InputPrimitiveType.String, isRequired: true, scope: InputParameterScope.Client, paramAlias: "name")]); + var subClient = InputFactory.Client( + "SubClient", + parent: parentClient, + parameters: [InputFactory.MethodParameter("name", InputPrimitiveType.String, isRequired: true, scope: InputParameterScope.Client)]); + + MockHelpers.LoadMockGenerator(clients: () => [parentClient]); + + var subClientProvider = new ClientProvider(subClient); + Assert.IsFalse(subClientProvider.HasAccessorOnlyParameters(parentClient)); + } + + [Test] + public void HasAccessorOnlyParameters_ReturnsTrue_WhenSubClientParamDoesNotMatchParentAlias() + { + // Parent has parameter "blobName" with paramAlias "name" + // Subclient has parameter "color" — not matching either parent name or alias + var parentClient = InputFactory.Client( + "ParentClient", + parameters: [InputFactory.MethodParameter("blobName", InputPrimitiveType.String, isRequired: true, scope: InputParameterScope.Client, paramAlias: "name")]); + var subClient = InputFactory.Client( + "SubClient", + parent: parentClient, + parameters: [InputFactory.MethodParameter("color", InputPrimitiveType.String, isRequired: true, scope: InputParameterScope.Client)]); + + MockHelpers.LoadMockGenerator(clients: () => [parentClient]); + + var subClientProvider = new ClientProvider(subClient); + Assert.IsTrue(subClientProvider.HasAccessorOnlyParameters(parentClient)); + } + private class MockClientProvider : ClientProvider { private readonly string[] _expectedSubClientFactoryMethodNames; diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderTests.cs index aad50052792..127e1420d06 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderTests.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ClientProviders/ClientProviderTests.cs @@ -3997,6 +3997,189 @@ public void ConvertUriTemplate_WithMultiplePlaceholders() // Verify that the Uri is built according to the server template Assert.IsTrue(bodyText.Contains("$\"{endpoint}/{_apiVersion}/services/{_subscriptionId}\"")); } + + [Test] + public void TestParamAlias_ClientConstructorDoesNotDuplicateAliasedParameter() + { + // A client parameter "blob" with paramAlias "blobName" should not produce + // a duplicate field when the operation also declares "blobName" as client-scoped. + var clientParam = InputFactory.MethodParameter( + "blob", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client, + paramAlias: "blobName"); + + var operationParam = InputFactory.PathParameter( + "blobName", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client); + + var operation = InputFactory.Operation("Upload", parameters: [operationParam]); + var client = InputFactory.Client( + TestClientName, + methods: [InputFactory.BasicServiceMethod("Upload", operation)], + parameters: [ + InputFactory.EndpointParameter( + "endpoint", + InputPrimitiveType.String, + defaultValue: InputFactory.Constant.String("https://default.endpoint.io"), + scope: InputParameterScope.Client, + isEndpoint: true), + clientParam]); + + var clientProvider = new ClientProvider(client); + + Assert.IsNotNull(clientProvider); + + // Should have exactly one field for the blob/blobName parameter (not two) + var blobFields = clientProvider.Fields.Where(f => f.Name == "_blob" || f.Name == "_blobName").ToList(); + Assert.AreEqual(1, blobFields.Count, + $"Expected 1 field but found {blobFields.Count}: {string.Join(", ", blobFields.Select(f => f.Name))}"); + Assert.AreEqual("_blob", blobFields[0].Name); + + // ClientParameters should contain only the "blob" parameter + var blobParams = clientProvider.ClientParameters.Where( + p => p.Name == "blob" || p.Name == "blobName").ToList(); + Assert.AreEqual(1, blobParams.Count, + $"Expected 1 client parameter but found {blobParams.Count}: {string.Join(", ", blobParams.Select(p => p.Name))}"); + Assert.AreEqual("blob", blobParams[0].Name); + } + + [Test] + public void TestParamAlias_ClientConstructorKeepsBothWhenNoAlias() + { + // Without paramAlias, a client parameter "blob" and operation parameter "blobName" + // should both appear since they have different names. + var clientParam = InputFactory.MethodParameter( + "blob", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client); + + var operationParam = InputFactory.PathParameter( + "blobName", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client); + + var operation = InputFactory.Operation("Upload", parameters: [operationParam]); + var client = InputFactory.Client( + TestClientName, + methods: [InputFactory.BasicServiceMethod("Upload", operation)], + parameters: [ + InputFactory.EndpointParameter( + "endpoint", + InputPrimitiveType.String, + defaultValue: InputFactory.Constant.String("https://default.endpoint.io"), + scope: InputParameterScope.Client, + isEndpoint: true), + clientParam]); + + var clientProvider = new ClientProvider(client); + + Assert.IsNotNull(clientProvider); + + // Without alias, both fields should exist + var blobFields = clientProvider.Fields.Where(f => f.Name == "_blob" || f.Name == "_blobName").ToList(); + Assert.AreEqual(2, blobFields.Count, + $"Expected 2 fields but found {blobFields.Count}: {string.Join(", ", blobFields.Select(f => f.Name))}"); + } + + [Test] + public void TestParamAlias_MatchingNamesWithoutAliasDeduplicate() + { + // When the client parameter and operation parameter share the same name, + // deduplication occurs by name even without paramAlias. + var clientParam = InputFactory.MethodParameter( + "blobName", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client); + + var operationParam = InputFactory.PathParameter( + "blobName", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client); + + var operation = InputFactory.Operation("Upload", parameters: [operationParam]); + var client = InputFactory.Client( + TestClientName, + methods: [InputFactory.BasicServiceMethod("Upload", operation)], + parameters: [ + InputFactory.EndpointParameter( + "endpoint", + InputPrimitiveType.String, + defaultValue: InputFactory.Constant.String("https://default.endpoint.io"), + scope: InputParameterScope.Client, + isEndpoint: true), + clientParam]); + + var clientProvider = new ClientProvider(client); + + Assert.IsNotNull(clientProvider); + + // Same name means they get deduplicated to one field + var blobFields = clientProvider.Fields.Where(f => f.Name == "_blobName").ToList(); + Assert.AreEqual(1, blobFields.Count); + } + + [Test] + public void TestParamAlias_MethodParametersSkipAliasedClientParam() + { + // When a client parameter "blob" is aliased to "blobName" via @paramAlias, + // the generated operation method should NOT have "blobName" as a method parameter + // since it's already on the client. + var clientParam = InputFactory.MethodParameter( + "blob", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client, + paramAlias: "blobName"); + + var operationParam = InputFactory.PathParameter( + "blobName", + InputPrimitiveType.String, + isRequired: true, + scope: InputParameterScope.Client); + + var operation = InputFactory.Operation("Upload", parameters: [operationParam]); + var client = InputFactory.Client( + TestClientName, + methods: [InputFactory.BasicServiceMethod("Upload", operation)], + parameters: [ + InputFactory.EndpointParameter( + "endpoint", + InputPrimitiveType.String, + defaultValue: InputFactory.Constant.String("https://default.endpoint.io"), + scope: InputParameterScope.Client, + isEndpoint: true), + clientParam]); + + var clientProvider = new ClientProvider(client); + + Assert.IsNotNull(clientProvider); + + // Get the generated operation methods (excluding subclient accessors and constructors) + var operationMethods = clientProvider.Methods + .Where(m => m.Signature?.Name == "Upload" || m.Signature?.Name == "UploadAsync") + .ToList(); + + Assert.IsTrue(operationMethods.Count > 0, "Should have Upload methods"); + + foreach (var method in operationMethods) + { + var paramNames = method.Signature!.Parameters.Select(p => p.Name).ToList(); + Assert.IsFalse(paramNames.Contains("blobName"), + $"Method '{method.Signature.Name}' should not have 'blobName' parameter since it's an aliased client parameter. " + + $"Params: [{string.Join(", ", paramNames)}]"); + Assert.IsFalse(paramNames.Contains("blob"), + $"Method '{method.Signature.Name}' should not have 'blob' parameter since it's a client parameter. " + + $"Params: [{string.Join(", ", paramNames)}]"); + } + } } } diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputMethodParameter.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputMethodParameter.cs index 538dbef5efc..6a5b9cc5c83 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputMethodParameter.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputMethodParameter.cs @@ -24,5 +24,7 @@ public InputMethodParameter( } public InputRequestLocation Location { get; internal set; } + + public string? ParamAlias { get; internal set; } } } diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/Serialization/InputMethodParameterConverter.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/Serialization/InputMethodParameterConverter.cs index def2b8456b2..3e61c3d629a 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/Serialization/InputMethodParameterConverter.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/Serialization/InputMethodParameterConverter.cs @@ -62,6 +62,7 @@ internal static InputMethodParameter ReadInputMethodParameter(ref Utf8JsonReader string? defaultContentType = null; IReadOnlyList? decorators = null; string? location = null; + string? paramAlias = null; while (reader.TokenType != JsonTokenType.EndObject) { @@ -80,7 +81,8 @@ internal static InputMethodParameter ReadInputMethodParameter(ref Utf8JsonReader || reader.TryReadComplexType("contentTypes", options, ref contentTypes) || reader.TryReadComplexType("defaultContentType", options, ref defaultContentType) || reader.TryReadString("location", ref location) - || reader.TryReadComplexType("decorators", options, ref decorators); + || reader.TryReadComplexType("decorators", options, ref decorators) + || reader.TryReadString("paramAlias", ref paramAlias); if (!isKnownProperty) { @@ -107,6 +109,7 @@ internal static InputMethodParameter ReadInputMethodParameter(ref Utf8JsonReader } Enum.TryParse(location, ignoreCase: true, out var requestLocation); parameter.Location = requestLocation; + parameter.ParamAlias = paramAlias; return parameter; } diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/test/InputParameterTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/test/InputParameterTests.cs index 1c9ea38a4a8..3ffef9e25db 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/test/InputParameterTests.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/test/InputParameterTests.cs @@ -102,5 +102,23 @@ public void OriginalNameMatchesNameWhenNoUpdateOccurs() Assert.AreEqual("filter", parameter.Name); Assert.AreEqual("filter", parameter.OriginalName); } + + [Test] + public void ParamAliasIsSetFromFactory() + { + var parameter = InputFactory.MethodParameter("blobName", InputPrimitiveType.String, paramAlias: "name"); + + Assert.AreEqual("blobName", parameter.Name); + Assert.AreEqual("name", parameter.ParamAlias); + } + + [Test] + public void ParamAliasIsNullByDefault() + { + var parameter = InputFactory.MethodParameter("blobName", InputPrimitiveType.String); + + Assert.AreEqual("blobName", parameter.Name); + Assert.IsNull(parameter.ParamAlias); + } } } diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/common/InputFactory.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/common/InputFactory.cs index f23286ac277..570585e3abe 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/common/InputFactory.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/common/InputFactory.cs @@ -469,7 +469,8 @@ public static InputMethodParameter MethodParameter( string? doc = null, string? serializedName = null, InputRequestLocation location = InputRequestLocation.Body, - InputParameterScope scope = InputParameterScope.Method) + InputParameterScope scope = InputParameterScope.Method, + string? paramAlias = null) { return new InputMethodParameter( name: name, @@ -483,7 +484,10 @@ public static InputMethodParameter MethodParameter( scope: scope, access: null, location: location, - serializedName: serializedName ?? name); + serializedName: serializedName ?? name) + { + ParamAlias = paramAlias + }; } // Replace reflection with InternalsVisibleTo after fixing https://github.com/microsoft/typespec/issues/7075")] diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/Sample-TypeSpec.tsp b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/Sample-TypeSpec.tsp index ede0acbb6bd..05c5c0e7b26 100644 --- a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/Sample-TypeSpec.tsp +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/Sample-TypeSpec.tsp @@ -1 +1,29 @@ import "../../../../../../docs/samples/client/csharp/SampleService/main.tsp"; + +using TypeSpec.Http; +using Azure.ClientGenerator.Core; + +namespace SampleTypeSpec; + +// E2E example demonstrating @paramAlias with @clientInitialization. +// The client parameter "notebook" is aliased to the operation's "notebookName" path parameter, +// allowing a different parameter name in client initialization while mapping to the original +// operation parameter name on the wire. +model NotebookClientParams { + @paramAlias("notebookName") + notebook: string; +} + +@clientInitialization({ + initializedBy: InitializedBy.individually | InitializedBy.parent, + parameters: NotebookClientParams, +}) +interface Notebooks { + @doc("Get a notebook by name") + @get + @route("/notebooks/{notebookName}") + getNotebook(@path notebookName: string): { + name: string; + content: string; + }; +} diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/GetNotebookResponse.Serialization.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/GetNotebookResponse.Serialization.cs new file mode 100644 index 00000000000..9c34abe0624 --- /dev/null +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/GetNotebookResponse.Serialization.cs @@ -0,0 +1,159 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT License. + +// + +#nullable disable + +using System; +using System.ClientModel; +using System.ClientModel.Primitives; +using System.Collections.Generic; +using System.Text.Json; + +namespace SampleTypeSpec +{ + /// The GetNotebookResponse. + public partial class GetNotebookResponse : IJsonModel + { + /// Initializes a new instance of for deserialization. + internal GetNotebookResponse() + { + } + + /// The data to parse. + /// The client options for reading and writing models. + protected virtual GetNotebookResponse PersistableModelCreateCore(BinaryData data, ModelReaderWriterOptions options) + { + string format = options.Format == "W" ? ((IPersistableModel)this).GetFormatFromOptions(options) : options.Format; + switch (format) + { + case "J": + using (JsonDocument document = JsonDocument.Parse(data, ModelSerializationExtensions.JsonDocumentOptions)) + { + return DeserializeGetNotebookResponse(document.RootElement, options); + } + default: + throw new FormatException($"The model {nameof(GetNotebookResponse)} does not support reading '{options.Format}' format."); + } + } + + /// The client options for reading and writing models. + protected virtual BinaryData PersistableModelWriteCore(ModelReaderWriterOptions options) + { + string format = options.Format == "W" ? ((IPersistableModel)this).GetFormatFromOptions(options) : options.Format; + switch (format) + { + case "J": + return ModelReaderWriter.Write(this, options, SampleTypeSpecContext.Default); + default: + throw new FormatException($"The model {nameof(GetNotebookResponse)} does not support writing '{options.Format}' format."); + } + } + + /// The client options for reading and writing models. + BinaryData IPersistableModel.Write(ModelReaderWriterOptions options) => PersistableModelWriteCore(options); + + /// The data to parse. + /// The client options for reading and writing models. + GetNotebookResponse IPersistableModel.Create(BinaryData data, ModelReaderWriterOptions options) => PersistableModelCreateCore(data, options); + + /// The client options for reading and writing models. + string IPersistableModel.GetFormatFromOptions(ModelReaderWriterOptions options) => "J"; + + /// The to deserialize the from. + public static explicit operator GetNotebookResponse(ClientResult result) + { + PipelineResponse response = result.GetRawResponse(); + using JsonDocument document = JsonDocument.Parse(response.Content, ModelSerializationExtensions.JsonDocumentOptions); + return DeserializeGetNotebookResponse(document.RootElement, ModelSerializationExtensions.WireOptions); + } + + /// The JSON writer. + /// The client options for reading and writing models. + void IJsonModel.Write(Utf8JsonWriter writer, ModelReaderWriterOptions options) + { + writer.WriteStartObject(); + JsonModelWriteCore(writer, options); + writer.WriteEndObject(); + } + + /// The JSON writer. + /// The client options for reading and writing models. + protected virtual void JsonModelWriteCore(Utf8JsonWriter writer, ModelReaderWriterOptions options) + { + string format = options.Format == "W" ? ((IPersistableModel)this).GetFormatFromOptions(options) : options.Format; + if (format != "J") + { + throw new FormatException($"The model {nameof(GetNotebookResponse)} does not support writing '{format}' format."); + } + writer.WritePropertyName("name"u8); + writer.WriteStringValue(Name); + writer.WritePropertyName("content"u8); + writer.WriteStringValue(Content); + if (options.Format != "W" && _additionalBinaryDataProperties != null) + { + foreach (var item in _additionalBinaryDataProperties) + { + writer.WritePropertyName(item.Key); +#if NET6_0_OR_GREATER + writer.WriteRawValue(item.Value); +#else + using (JsonDocument document = JsonDocument.Parse(item.Value)) + { + JsonSerializer.Serialize(writer, document.RootElement); + } +#endif + } + } + } + + /// The JSON reader. + /// The client options for reading and writing models. + GetNotebookResponse IJsonModel.Create(ref Utf8JsonReader reader, ModelReaderWriterOptions options) => JsonModelCreateCore(ref reader, options); + + /// The JSON reader. + /// The client options for reading and writing models. + protected virtual GetNotebookResponse JsonModelCreateCore(ref Utf8JsonReader reader, ModelReaderWriterOptions options) + { + string format = options.Format == "W" ? ((IPersistableModel)this).GetFormatFromOptions(options) : options.Format; + if (format != "J") + { + throw new FormatException($"The model {nameof(GetNotebookResponse)} does not support reading '{format}' format."); + } + using JsonDocument document = JsonDocument.ParseValue(ref reader); + return DeserializeGetNotebookResponse(document.RootElement, options); + } + + /// The JSON element to deserialize. + /// The client options for reading and writing models. + internal static GetNotebookResponse DeserializeGetNotebookResponse(JsonElement element, ModelReaderWriterOptions options) + { + if (element.ValueKind == JsonValueKind.Null) + { + return null; + } + string name = default; + string content = default; + IDictionary additionalBinaryDataProperties = new ChangeTrackingDictionary(); + foreach (var prop in element.EnumerateObject()) + { + if (prop.NameEquals("name"u8)) + { + name = prop.Value.GetString(); + continue; + } + if (prop.NameEquals("content"u8)) + { + content = prop.Value.GetString(); + continue; + } + if (options.Format != "W") + { + additionalBinaryDataProperties.Add(prop.Name, BinaryData.FromString(prop.Value.GetRawText())); + } + } + return new GetNotebookResponse(name, content, additionalBinaryDataProperties); + } + } +} diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/GetNotebookResponse.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/GetNotebookResponse.cs new file mode 100644 index 00000000000..af0f633f72a --- /dev/null +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/GetNotebookResponse.cs @@ -0,0 +1,45 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT License. + +// + +#nullable disable + +using System; +using System.Collections.Generic; + +namespace SampleTypeSpec +{ + /// The GetNotebookResponse. + public partial class GetNotebookResponse + { + /// Keeps track of any properties unknown to the library. + private protected readonly IDictionary _additionalBinaryDataProperties; + + /// Initializes a new instance of . + /// + /// + internal GetNotebookResponse(string name, string content) + { + Name = name; + Content = content; + } + + /// Initializes a new instance of . + /// + /// + /// Keeps track of any properties unknown to the library. + internal GetNotebookResponse(string name, string content, IDictionary additionalBinaryDataProperties) + { + Name = name; + Content = content; + _additionalBinaryDataProperties = additionalBinaryDataProperties; + } + + /// Gets the Name. + public string Name { get; } + + /// Gets the Content. + public string Content { get; } + } +} diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/SampleTypeSpecContext.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/SampleTypeSpecContext.cs index bdeaf475d0a..c50862552e8 100644 --- a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/SampleTypeSpecContext.cs +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Models/SampleTypeSpecContext.cs @@ -19,6 +19,7 @@ namespace SampleTypeSpec [ModelReaderWriterBuildable(typeof(Dog))] [ModelReaderWriterBuildable(typeof(DynamicModel))] [ModelReaderWriterBuildable(typeof(Friend))] + [ModelReaderWriterBuildable(typeof(GetNotebookResponse))] [ModelReaderWriterBuildable(typeof(GetWidgetMetricsResponse))] [ModelReaderWriterBuildable(typeof(ListWithContinuationTokenHeaderResponseResponse))] [ModelReaderWriterBuildable(typeof(ListWithContinuationTokenResponse))] diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Notebooks.RestClient.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Notebooks.RestClient.cs new file mode 100644 index 00000000000..745de2d13b0 --- /dev/null +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Notebooks.RestClient.cs @@ -0,0 +1,32 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT License. + +// + +#nullable disable + +using System.ClientModel.Primitives; + +namespace SampleTypeSpec +{ + /// + public partial class Notebooks + { + private static PipelineMessageClassifier _pipelineMessageClassifier200; + + private static PipelineMessageClassifier PipelineMessageClassifier200 => _pipelineMessageClassifier200 ??= PipelineMessageClassifier.Create(stackalloc ushort[] { 200 }); + + internal PipelineMessage CreateGetNotebookRequest(RequestOptions options) + { + ClientUriBuilder uri = new ClientUriBuilder(); + uri.Reset(_endpoint); + uri.AppendPath("/notebooks/", false); + uri.AppendPath(_notebook, true); + PipelineMessage message = Pipeline.CreateMessage(uri.ToUri(), "GET", PipelineMessageClassifier200); + PipelineRequest request = message.Request; + request.Headers.Set("Accept", "application/json"); + message.Apply(options); + return message; + } + } +} diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Notebooks.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Notebooks.cs new file mode 100644 index 00000000000..27cc5179a09 --- /dev/null +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/Notebooks.cs @@ -0,0 +1,179 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT License. + +// + +#nullable disable + +using System; +using System.ClientModel; +using System.ClientModel.Primitives; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Threading; +using System.Threading.Tasks; + +namespace SampleTypeSpec +{ + /// The Notebooks sub-client. + public partial class Notebooks + { + private readonly Uri _endpoint; + private const string AuthorizationHeader = "my-api-key"; + /// The OAuth2 flows supported by the service. + private static readonly Dictionary[] _flows = new Dictionary[] + { + new Dictionary + { + { GetTokenOptions.ScopesPropertyName, new string[] { "read" } }, + { GetTokenOptions.AuthorizationUrlPropertyName, "https://api.example.com/oauth2/authorize" }, + { GetTokenOptions.RefreshUrlPropertyName, "https://api.example.com/oauth2/refresh" } + } + }; + private readonly string _notebook; + + /// Initializes a new instance of Notebooks for mocking. + protected Notebooks() + { + } + + /// Initializes a new instance of Notebooks. + /// The HTTP pipeline for sending and receiving REST requests and responses. + /// Service endpoint. + /// + internal Notebooks(ClientPipeline pipeline, Uri endpoint, string notebook) + { + _endpoint = endpoint; + Pipeline = pipeline; + _notebook = notebook; + } + + /// Initializes a new instance of Notebooks. + /// Service endpoint. + /// + /// A credential used to authenticate to the service. + /// , or is null. + /// is an empty string, and was expected to be non-empty. + public Notebooks(Uri endpoint, string notebook, ApiKeyCredential credential) : this(endpoint, notebook, credential, new SampleTypeSpecClientOptions()) + { + } + + /// Initializes a new instance of Notebooks. + /// Service endpoint. + /// + /// A credential provider used to authenticate to the service. + /// , or is null. + /// is an empty string, and was expected to be non-empty. + public Notebooks(Uri endpoint, string notebook, AuthenticationTokenProvider tokenProvider) : this(endpoint, notebook, tokenProvider, new SampleTypeSpecClientOptions()) + { + } + + /// Initializes a new instance of Notebooks. + /// The authentication policy to use for pipeline creation. + /// Service endpoint. + /// + /// The options for configuring the client. + internal Notebooks(AuthenticationPolicy authenticationPolicy, Uri endpoint, string notebook, SampleTypeSpecClientOptions options) + { + Argument.AssertNotNull(endpoint, nameof(endpoint)); + Argument.AssertNotNullOrEmpty(notebook, nameof(notebook)); + + options ??= new SampleTypeSpecClientOptions(); + + _endpoint = endpoint; + _notebook = notebook; + if (authenticationPolicy != null) + { + Pipeline = ClientPipeline.Create(options, Array.Empty(), new PipelinePolicy[] { new UserAgentPolicy(typeof(Notebooks).Assembly), authenticationPolicy }, Array.Empty()); + } + else + { + Pipeline = ClientPipeline.Create(options, Array.Empty(), new PipelinePolicy[] { new UserAgentPolicy(typeof(Notebooks).Assembly) }, Array.Empty()); + } + } + + /// Initializes a new instance of Notebooks. + /// Service endpoint. + /// + /// A credential used to authenticate to the service. + /// The options for configuring the client. + /// , or is null. + /// is an empty string, and was expected to be non-empty. + public Notebooks(Uri endpoint, string notebook, ApiKeyCredential credential, SampleTypeSpecClientOptions options) : this(ApiKeyAuthenticationPolicy.CreateHeaderApiKeyPolicy(credential, AuthorizationHeader), endpoint, notebook, options) + { + } + + /// Initializes a new instance of Notebooks. + /// Service endpoint. + /// + /// A credential provider used to authenticate to the service. + /// The options for configuring the client. + /// , or is null. + /// is an empty string, and was expected to be non-empty. + public Notebooks(Uri endpoint, string notebook, AuthenticationTokenProvider tokenProvider, SampleTypeSpecClientOptions options) : this(new BearerTokenPolicy(tokenProvider, _flows), endpoint, notebook, options) + { + } + + /// Initializes a new instance of Notebooks from a . + /// The settings for Notebooks. + [Experimental("SCME0002")] + public Notebooks(NotebooksSettings settings) : this(AuthenticationPolicy.Create(settings), settings?.SampleTypeSpecUrl, settings?.Notebook, settings?.Options) + { + } + + /// The HTTP pipeline for sending and receiving REST requests and responses. + public ClientPipeline Pipeline { get; } + + /// + /// [Protocol Method] Get a notebook by name + /// + /// + /// This protocol method allows explicit creation of the request and processing of the response for advanced scenarios. + /// + /// + /// + /// The request options, which can override default behaviors of the client pipeline on a per-call basis. + /// Service returned a non-success status code. + /// The response returned from the service. + public virtual ClientResult GetNotebook(RequestOptions options) + { + using PipelineMessage message = CreateGetNotebookRequest(options); + return ClientResult.FromResponse(Pipeline.ProcessMessage(message, options)); + } + + /// + /// [Protocol Method] Get a notebook by name + /// + /// + /// This protocol method allows explicit creation of the request and processing of the response for advanced scenarios. + /// + /// + /// + /// The request options, which can override default behaviors of the client pipeline on a per-call basis. + /// Service returned a non-success status code. + /// The response returned from the service. + public virtual async Task GetNotebookAsync(RequestOptions options) + { + using PipelineMessage message = CreateGetNotebookRequest(options); + return ClientResult.FromResponse(await Pipeline.ProcessMessageAsync(message, options).ConfigureAwait(false)); + } + + /// Get a notebook by name. + /// The cancellation token that can be used to cancel the operation. + /// Service returned a non-success status code. + public virtual ClientResult GetNotebook(CancellationToken cancellationToken = default) + { + ClientResult result = GetNotebook(cancellationToken.ToRequestOptions()); + return ClientResult.FromValue((GetNotebookResponse)result, result.GetRawResponse()); + } + + /// Get a notebook by name. + /// The cancellation token that can be used to cancel the operation. + /// Service returned a non-success status code. + public virtual async Task> GetNotebookAsync(CancellationToken cancellationToken = default) + { + ClientResult result = await GetNotebookAsync(cancellationToken.ToRequestOptions()).ConfigureAwait(false); + return ClientResult.FromValue((GetNotebookResponse)result, result.GetRawResponse()); + } + } +} diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/NotebooksSettings.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/NotebooksSettings.cs new file mode 100644 index 00000000000..576a053e6bb --- /dev/null +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/NotebooksSettings.cs @@ -0,0 +1,48 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT License. + +// + +#nullable disable + +using System; +using System.ClientModel.Primitives; +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.Configuration; + +namespace SampleTypeSpec +{ + /// Represents the settings used to configure a that can be loaded from an . + [Experimental("SCME0002")] + public partial class NotebooksSettings : ClientSettings + { + /// Gets or sets the SampleTypeSpecUrl. + public Uri SampleTypeSpecUrl { get; set; } + + /// Gets or sets the Notebook. + public string Notebook { get; set; } + + /// Gets or sets the Options. + public SampleTypeSpecClientOptions Options { get; set; } + + /// Binds configuration values from the given section. + /// The configuration section. + protected override void BindCore(IConfigurationSection section) + { + if (Uri.TryCreate(section["SampleTypeSpecUrl"], UriKind.Absolute, out Uri sampleTypeSpecUrl)) + { + SampleTypeSpecUrl = sampleTypeSpecUrl; + } + string notebook = section["Notebook"]; + if (!string.IsNullOrEmpty(notebook)) + { + Notebook = notebook; + } + IConfigurationSection optionsSection = section.GetSection("Options"); + if (optionsSection.Exists()) + { + Options = new SampleTypeSpecClientOptions(optionsSection); + } + } + } +} diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs index a97f4d223f0..40fd96ecae8 100644 --- a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs @@ -1889,6 +1889,16 @@ public virtual async Task> UpdateXmlAdvancedModel return ClientResult.FromValue((XmlAdvancedModel)result, result.GetRawResponse()); } + /// Initializes a new instance of Notebooks. + /// + /// is null. + public virtual Notebooks GetNotebooksClient(string notebook) + { + Argument.AssertNotNull(notebook, nameof(notebook)); + + return new Notebooks(Pipeline, _endpoint, notebook); + } + /// Initializes a new instance of AnimalOperations. public virtual AnimalOperations GetAnimalOperationsClient() { diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecModelFactory.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecModelFactory.cs index 2438564a8c3..6df3c63a85a 100644 --- a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecModelFactory.cs +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecModelFactory.cs @@ -377,6 +377,15 @@ public static XmlModelWithNamespace XmlModelWithNamespace(string foo = default) return new XmlModelWithNamespace(foo, additionalBinaryDataProperties: null); } + /// The GetNotebookResponse. + /// + /// + /// A new instance for mocking. + public static GetNotebookResponse GetNotebookResponse(string name = default, string content = default) + { + return new GetNotebookResponse(name, content, additionalBinaryDataProperties: null); + } + /// /// Base animal with discriminator /// Please note this is the abstract base class. The derived classes available for instantiation are: and . diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tspCodeModel.json b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tspCodeModel.json index 459ab161e6f..b387bdf191f 100644 --- a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tspCodeModel.json +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tspCodeModel.json @@ -1743,7 +1743,7 @@ { "$id": "188", "kind": "constant", - "name": "updatePetAsAnimalContentType", + "name": "getNotebookContentType", "namespace": "", "usage": "None", "valueType": { @@ -1759,7 +1759,7 @@ { "$id": "190", "kind": "constant", - "name": "updatePetAsAnimalContentType1", + "name": "updatePetAsAnimalContentType", "namespace": "", "usage": "None", "valueType": { @@ -1775,7 +1775,7 @@ { "$id": "192", "kind": "constant", - "name": "updateDogAsAnimalContentType", + "name": "updatePetAsAnimalContentType1", "namespace": "", "usage": "None", "valueType": { @@ -1791,7 +1791,7 @@ { "$id": "194", "kind": "constant", - "name": "updateDogAsAnimalContentType1", + "name": "updateDogAsAnimalContentType", "namespace": "", "usage": "None", "valueType": { @@ -1807,7 +1807,7 @@ { "$id": "196", "kind": "constant", - "name": "updatePetAsPetContentType", + "name": "updateDogAsAnimalContentType1", "namespace": "", "usage": "None", "valueType": { @@ -1823,7 +1823,7 @@ { "$id": "198", "kind": "constant", - "name": "updatePetAsPetContentType1", + "name": "updatePetAsPetContentType", "namespace": "", "usage": "None", "valueType": { @@ -1839,7 +1839,7 @@ { "$id": "200", "kind": "constant", - "name": "updateDogAsPetContentType", + "name": "updatePetAsPetContentType1", "namespace": "", "usage": "None", "valueType": { @@ -1855,7 +1855,7 @@ { "$id": "202", "kind": "constant", - "name": "updateDogAsPetContentType1", + "name": "updateDogAsPetContentType", "namespace": "", "usage": "None", "valueType": { @@ -1871,7 +1871,7 @@ { "$id": "204", "kind": "constant", - "name": "updateDogAsDogContentType", + "name": "updateDogAsPetContentType1", "namespace": "", "usage": "None", "valueType": { @@ -1887,7 +1887,7 @@ { "$id": "206", "kind": "constant", - "name": "updateDogAsDogContentType1", + "name": "updateDogAsDogContentType", "namespace": "", "usage": "None", "valueType": { @@ -1903,7 +1903,7 @@ { "$id": "208", "kind": "constant", - "name": "getTreeContentType", + "name": "updateDogAsDogContentType1", "namespace": "", "usage": "None", "valueType": { @@ -1913,13 +1913,13 @@ "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, - "value": "application/xml", + "value": "application/json", "decorators": [] }, { "$id": "210", "kind": "constant", - "name": "GetXmlAdvancedModelResponseContentType4", + "name": "getTreeContentType", "namespace": "", "usage": "None", "valueType": { @@ -1935,7 +1935,7 @@ { "$id": "212", "kind": "constant", - "name": "getTreeAsJsonContentType", + "name": "GetXmlAdvancedModelResponseContentType4", "namespace": "", "usage": "None", "valueType": { @@ -1945,13 +1945,13 @@ "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, - "value": "application/json", + "value": "application/xml", "decorators": [] }, { "$id": "214", "kind": "constant", - "name": "GetTreeAsJsonResponseContentType", + "name": "getTreeAsJsonContentType", "namespace": "", "usage": "None", "valueType": { @@ -1967,7 +1967,7 @@ { "$id": "216", "kind": "constant", - "name": "GetXmlAdvancedModelResponseContentType5", + "name": "GetTreeAsJsonResponseContentType", "namespace": "", "usage": "None", "valueType": { @@ -1977,13 +1977,13 @@ "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, - "value": "application/xml", + "value": "application/json", "decorators": [] }, { "$id": "218", "kind": "constant", - "name": "GetXmlAdvancedModelResponseContentType6", + "name": "GetXmlAdvancedModelResponseContentType5", "namespace": "", "usage": "None", "valueType": { @@ -1999,7 +1999,7 @@ { "$id": "220", "kind": "constant", - "name": "updateTreeContentType", + "name": "GetXmlAdvancedModelResponseContentType6", "namespace": "", "usage": "None", "valueType": { @@ -2015,7 +2015,7 @@ { "$id": "222", "kind": "constant", - "name": "GetXmlAdvancedModelResponseContentType7", + "name": "updateTreeContentType", "namespace": "", "usage": "None", "valueType": { @@ -2031,7 +2031,7 @@ { "$id": "224", "kind": "constant", - "name": "GetTreeAsJsonResponseContentType1", + "name": "GetXmlAdvancedModelResponseContentType7", "namespace": "", "usage": "None", "valueType": { @@ -2041,13 +2041,13 @@ "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, - "value": "application/json", + "value": "application/xml", "decorators": [] }, { "$id": "226", "kind": "constant", - "name": "GetTreeAsJsonResponseContentType2", + "name": "GetTreeAsJsonResponseContentType1", "namespace": "", "usage": "None", "valueType": { @@ -2063,7 +2063,7 @@ { "$id": "228", "kind": "constant", - "name": "updateTreeAsJsonContentType", + "name": "GetTreeAsJsonResponseContentType2", "namespace": "", "usage": "None", "valueType": { @@ -2079,7 +2079,7 @@ { "$id": "230", "kind": "constant", - "name": "GetTreeAsJsonResponseContentType3", + "name": "updateTreeAsJsonContentType", "namespace": "", "usage": "None", "valueType": { @@ -2095,7 +2095,7 @@ { "$id": "232", "kind": "constant", - "name": "getWidgetMetricsContentType", + "name": "GetTreeAsJsonResponseContentType3", "namespace": "", "usage": "None", "valueType": { @@ -2107,11 +2107,27 @@ }, "value": "application/json", "decorators": [] + }, + { + "$id": "234", + "kind": "constant", + "name": "getWidgetMetricsContentType", + "namespace": "", + "usage": "None", + "valueType": { + "$id": "235", + "kind": "string", + "name": "string", + "crossLanguageDefinitionId": "TypeSpec.string", + "decorators": [] + }, + "value": "application/json", + "decorators": [] } ], "models": [ { - "$id": "234", + "$id": "236", "kind": "model", "name": "Thing", "namespace": "SampleTypeSpec", @@ -2126,13 +2142,13 @@ }, "properties": [ { - "$id": "235", + "$id": "237", "kind": "property", "name": "name", "serializedName": "name", "doc": "name of the Thing", "type": { - "$id": "236", + "$id": "238", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2152,29 +2168,29 @@ "isHttpMetadata": false }, { - "$id": "237", + "$id": "239", "kind": "property", "name": "requiredUnion", "serializedName": "requiredUnion", "doc": "required Union", "type": { - "$id": "238", + "$id": "240", "kind": "union", "name": "ThingRequiredUnion", "variantTypes": [ { - "$id": "239", + "$id": "241", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, { - "$id": "240", + "$id": "242", "kind": "array", "name": "Array", "valueType": { - "$id": "241", + "$id": "243", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2184,7 +2200,7 @@ "decorators": [] }, { - "$id": "242", + "$id": "244", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -2208,7 +2224,7 @@ "isHttpMetadata": false }, { - "$id": "243", + "$id": "245", "kind": "property", "name": "requiredLiteralString", "serializedName": "requiredLiteralString", @@ -2230,16 +2246,16 @@ "isHttpMetadata": false }, { - "$id": "244", + "$id": "246", "kind": "property", "name": "requiredNullableString", "serializedName": "requiredNullableString", "doc": "required nullable string", "type": { - "$id": "245", + "$id": "247", "kind": "nullable", "type": { - "$id": "246", + "$id": "248", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2261,16 +2277,16 @@ "isHttpMetadata": false }, { - "$id": "247", + "$id": "249", "kind": "property", "name": "optionalNullableString", "serializedName": "optionalNullableString", "doc": "required optional string", "type": { - "$id": "248", + "$id": "250", "kind": "nullable", "type": { - "$id": "249", + "$id": "251", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2292,7 +2308,7 @@ "isHttpMetadata": false }, { - "$id": "250", + "$id": "252", "kind": "property", "name": "requiredLiteralInt", "serializedName": "requiredLiteralInt", @@ -2314,7 +2330,7 @@ "isHttpMetadata": false }, { - "$id": "251", + "$id": "253", "kind": "property", "name": "requiredLiteralFloat", "serializedName": "requiredLiteralFloat", @@ -2336,7 +2352,7 @@ "isHttpMetadata": false }, { - "$id": "252", + "$id": "254", "kind": "property", "name": "requiredLiteralBool", "serializedName": "requiredLiteralBool", @@ -2358,7 +2374,7 @@ "isHttpMetadata": false }, { - "$id": "253", + "$id": "255", "kind": "property", "name": "optionalLiteralString", "serializedName": "optionalLiteralString", @@ -2380,13 +2396,13 @@ "isHttpMetadata": false }, { - "$id": "254", + "$id": "256", "kind": "property", "name": "requiredNullableLiteralString", "serializedName": "requiredNullableLiteralString", "doc": "required nullable literal string", "type": { - "$id": "255", + "$id": "257", "kind": "nullable", "type": { "$ref": "5" @@ -2407,7 +2423,7 @@ "isHttpMetadata": false }, { - "$id": "256", + "$id": "258", "kind": "property", "name": "optionalLiteralInt", "serializedName": "optionalLiteralInt", @@ -2429,7 +2445,7 @@ "isHttpMetadata": false }, { - "$id": "257", + "$id": "259", "kind": "property", "name": "optionalLiteralFloat", "serializedName": "optionalLiteralFloat", @@ -2451,7 +2467,7 @@ "isHttpMetadata": false }, { - "$id": "258", + "$id": "260", "kind": "property", "name": "optionalLiteralBool", "serializedName": "optionalLiteralBool", @@ -2473,13 +2489,13 @@ "isHttpMetadata": false }, { - "$id": "259", + "$id": "261", "kind": "property", "name": "requiredBadDescription", "serializedName": "requiredBadDescription", "doc": "description with xml <|endoftext|>", "type": { - "$id": "260", + "$id": "262", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2499,20 +2515,20 @@ "isHttpMetadata": false }, { - "$id": "261", + "$id": "263", "kind": "property", "name": "optionalNullableList", "serializedName": "optionalNullableList", "doc": "optional nullable collection", "type": { - "$id": "262", + "$id": "264", "kind": "nullable", "type": { - "$id": "263", + "$id": "265", "kind": "array", "name": "Array1", "valueType": { - "$id": "264", + "$id": "266", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -2537,16 +2553,16 @@ "isHttpMetadata": false }, { - "$id": "265", + "$id": "267", "kind": "property", "name": "requiredNullableList", "serializedName": "requiredNullableList", "doc": "required nullable collection", "type": { - "$id": "266", + "$id": "268", "kind": "nullable", "type": { - "$ref": "263" + "$ref": "265" }, "namespace": "SampleTypeSpec" }, @@ -2564,13 +2580,13 @@ "isHttpMetadata": false }, { - "$id": "267", + "$id": "269", "kind": "property", "name": "propertyWithSpecialDocs", "serializedName": "propertyWithSpecialDocs", "doc": "This tests:\n- Simple bullet point. This bullet point is going to be very long to test how text wrapping is handled in bullet points within documentation comments. It should properly indent the wrapped lines.\n- Another bullet point with **bold text**. This bullet point is also intentionally long to see how the formatting is preserved when the text wraps onto multiple lines in the generated documentation.\n- Third bullet point with *italic text*. Similar to the previous points, this one is extended to ensure that the wrapping and formatting are correctly applied in the output.\n- Complex bullet point with **bold** and *italic* combined. This bullet point combines both bold and italic formatting and is long enough to test the wrapping behavior in such cases.\n- **Bold bullet point**: A bullet point that is entirely bolded. This point is also made lengthy to observe how the bold formatting is maintained across wrapped lines.\n- *Italic bullet point*: A bullet point that is entirely italicized. This final point is extended to verify that italic formatting is correctly applied even when the text spans multiple lines.", "type": { - "$id": "268", + "$id": "270", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2592,7 +2608,7 @@ ] }, { - "$id": "269", + "$id": "271", "kind": "model", "name": "RoundTripModel", "namespace": "SampleTypeSpec", @@ -2607,13 +2623,13 @@ }, "properties": [ { - "$id": "270", + "$id": "272", "kind": "property", "name": "requiredString", "serializedName": "requiredString", "doc": "Required string, illustrating a reference type property.", "type": { - "$id": "271", + "$id": "273", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2633,13 +2649,13 @@ "isHttpMetadata": false }, { - "$id": "272", + "$id": "274", "kind": "property", "name": "requiredInt", "serializedName": "requiredInt", "doc": "Required int, illustrating a value type property.", "type": { - "$id": "273", + "$id": "275", "kind": "int32", "name": "int32", "encode": "string", @@ -2660,13 +2676,13 @@ "isHttpMetadata": false }, { - "$id": "274", + "$id": "276", "kind": "property", "name": "requiredCollection", "serializedName": "requiredCollection", "doc": "Required collection of enums", "type": { - "$id": "275", + "$id": "277", "kind": "array", "name": "ArrayStringFixedEnum", "valueType": { @@ -2689,16 +2705,16 @@ "isHttpMetadata": false }, { - "$id": "276", + "$id": "278", "kind": "property", "name": "requiredDictionary", "serializedName": "requiredDictionary", "doc": "Required dictionary of enums", "type": { - "$id": "277", + "$id": "279", "kind": "dict", "keyType": { - "$id": "278", + "$id": "280", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -2723,13 +2739,13 @@ "isHttpMetadata": false }, { - "$id": "279", + "$id": "281", "kind": "property", "name": "requiredModel", "serializedName": "requiredModel", "doc": "Required model", "type": { - "$ref": "234" + "$ref": "236" }, "optional": false, "readOnly": false, @@ -2745,7 +2761,7 @@ "isHttpMetadata": false }, { - "$id": "280", + "$id": "282", "kind": "property", "name": "intExtensibleEnum", "serializedName": "intExtensibleEnum", @@ -2767,13 +2783,13 @@ "isHttpMetadata": false }, { - "$id": "281", + "$id": "283", "kind": "property", "name": "intExtensibleEnumCollection", "serializedName": "intExtensibleEnumCollection", "doc": "this is a collection of int based extensible enum", "type": { - "$id": "282", + "$id": "284", "kind": "array", "name": "ArrayIntExtensibleEnum", "valueType": { @@ -2796,7 +2812,7 @@ "isHttpMetadata": false }, { - "$id": "283", + "$id": "285", "kind": "property", "name": "floatExtensibleEnum", "serializedName": "floatExtensibleEnum", @@ -2818,7 +2834,7 @@ "isHttpMetadata": false }, { - "$id": "284", + "$id": "286", "kind": "property", "name": "floatExtensibleEnumWithIntValue", "serializedName": "floatExtensibleEnumWithIntValue", @@ -2840,13 +2856,13 @@ "isHttpMetadata": false }, { - "$id": "285", + "$id": "287", "kind": "property", "name": "floatExtensibleEnumCollection", "serializedName": "floatExtensibleEnumCollection", "doc": "this is a collection of float based extensible enum", "type": { - "$id": "286", + "$id": "288", "kind": "array", "name": "ArrayFloatExtensibleEnum", "valueType": { @@ -2869,7 +2885,7 @@ "isHttpMetadata": false }, { - "$id": "287", + "$id": "289", "kind": "property", "name": "floatFixedEnum", "serializedName": "floatFixedEnum", @@ -2891,7 +2907,7 @@ "isHttpMetadata": false }, { - "$id": "288", + "$id": "290", "kind": "property", "name": "floatFixedEnumWithIntValue", "serializedName": "floatFixedEnumWithIntValue", @@ -2913,13 +2929,13 @@ "isHttpMetadata": false }, { - "$id": "289", + "$id": "291", "kind": "property", "name": "floatFixedEnumCollection", "serializedName": "floatFixedEnumCollection", "doc": "this is a collection of float based fixed enum", "type": { - "$id": "290", + "$id": "292", "kind": "array", "name": "ArrayFloatFixedEnum", "valueType": { @@ -2942,7 +2958,7 @@ "isHttpMetadata": false }, { - "$id": "291", + "$id": "293", "kind": "property", "name": "intFixedEnum", "serializedName": "intFixedEnum", @@ -2964,13 +2980,13 @@ "isHttpMetadata": false }, { - "$id": "292", + "$id": "294", "kind": "property", "name": "intFixedEnumCollection", "serializedName": "intFixedEnumCollection", "doc": "this is a collection of int based fixed enum", "type": { - "$id": "293", + "$id": "295", "kind": "array", "name": "ArrayIntFixedEnum", "valueType": { @@ -2993,7 +3009,7 @@ "isHttpMetadata": false }, { - "$id": "294", + "$id": "296", "kind": "property", "name": "stringFixedEnum", "serializedName": "stringFixedEnum", @@ -3015,13 +3031,13 @@ "isHttpMetadata": false }, { - "$id": "295", + "$id": "297", "kind": "property", "name": "requiredUnknown", "serializedName": "requiredUnknown", "doc": "required unknown", "type": { - "$id": "296", + "$id": "298", "kind": "unknown", "name": "unknown", "crossLanguageDefinitionId": "", @@ -3041,13 +3057,13 @@ "isHttpMetadata": false }, { - "$id": "297", + "$id": "299", "kind": "property", "name": "optionalUnknown", "serializedName": "optionalUnknown", "doc": "optional unknown", "type": { - "$id": "298", + "$id": "300", "kind": "unknown", "name": "unknown", "crossLanguageDefinitionId": "", @@ -3067,23 +3083,23 @@ "isHttpMetadata": false }, { - "$id": "299", + "$id": "301", "kind": "property", "name": "requiredRecordUnknown", "serializedName": "requiredRecordUnknown", "doc": "required record of unknown", "type": { - "$id": "300", + "$id": "302", "kind": "dict", "keyType": { - "$id": "301", + "$id": "303", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$id": "302", + "$id": "304", "kind": "unknown", "name": "unknown", "crossLanguageDefinitionId": "", @@ -3105,13 +3121,13 @@ "isHttpMetadata": false }, { - "$id": "303", + "$id": "305", "kind": "property", "name": "optionalRecordUnknown", "serializedName": "optionalRecordUnknown", "doc": "optional record of unknown", "type": { - "$ref": "300" + "$ref": "302" }, "optional": true, "readOnly": false, @@ -3127,13 +3143,13 @@ "isHttpMetadata": false }, { - "$id": "304", + "$id": "306", "kind": "property", "name": "readOnlyRequiredRecordUnknown", "serializedName": "readOnlyRequiredRecordUnknown", "doc": "required readonly record of unknown", "type": { - "$ref": "300" + "$ref": "302" }, "optional": false, "readOnly": true, @@ -3149,13 +3165,13 @@ "isHttpMetadata": false }, { - "$id": "305", + "$id": "307", "kind": "property", "name": "readOnlyOptionalRecordUnknown", "serializedName": "readOnlyOptionalRecordUnknown", "doc": "optional readonly record of unknown", "type": { - "$ref": "300" + "$ref": "302" }, "optional": true, "readOnly": true, @@ -3171,13 +3187,13 @@ "isHttpMetadata": false }, { - "$id": "306", + "$id": "308", "kind": "property", "name": "modelWithRequiredNullable", "serializedName": "modelWithRequiredNullable", "doc": "this is a model with required nullable properties", "type": { - "$id": "307", + "$id": "309", "kind": "model", "name": "ModelWithRequiredNullableProperties", "namespace": "SampleTypeSpec", @@ -3192,16 +3208,16 @@ }, "properties": [ { - "$id": "308", + "$id": "310", "kind": "property", "name": "requiredNullablePrimitive", "serializedName": "requiredNullablePrimitive", "doc": "required nullable primitive type", "type": { - "$id": "309", + "$id": "311", "kind": "nullable", "type": { - "$id": "310", + "$id": "312", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -3223,13 +3239,13 @@ "isHttpMetadata": false }, { - "$id": "311", + "$id": "313", "kind": "property", "name": "requiredExtensibleEnum", "serializedName": "requiredExtensibleEnum", "doc": "required nullable extensible enum type", "type": { - "$id": "312", + "$id": "314", "kind": "nullable", "type": { "$ref": "22" @@ -3250,13 +3266,13 @@ "isHttpMetadata": false }, { - "$id": "313", + "$id": "315", "kind": "property", "name": "requiredFixedEnum", "serializedName": "requiredFixedEnum", "doc": "required nullable fixed enum type", "type": { - "$id": "314", + "$id": "316", "kind": "nullable", "type": { "$ref": "17" @@ -3292,13 +3308,13 @@ "isHttpMetadata": false }, { - "$id": "315", + "$id": "317", "kind": "property", "name": "requiredBytes", "serializedName": "requiredBytes", "doc": "Required bytes", "type": { - "$id": "316", + "$id": "318", "kind": "bytes", "name": "bytes", "encode": "base64", @@ -3321,10 +3337,10 @@ ] }, { - "$ref": "307" + "$ref": "309" }, { - "$id": "317", + "$id": "319", "kind": "model", "name": "Wrapper", "namespace": "SampleTypeSpec", @@ -3334,12 +3350,12 @@ "serializationOptions": {}, "properties": [ { - "$id": "318", + "$id": "320", "kind": "property", "name": "p1", "doc": "header parameter", "type": { - "$id": "319", + "$id": "321", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3355,12 +3371,12 @@ "isHttpMetadata": true }, { - "$id": "320", + "$id": "322", "kind": "property", "name": "action", "doc": "body parameter", "type": { - "$ref": "269" + "$ref": "271" }, "optional": false, "readOnly": false, @@ -3372,12 +3388,12 @@ "isHttpMetadata": false }, { - "$id": "321", + "$id": "323", "kind": "property", "name": "p2", "doc": "path parameter", "type": { - "$id": "322", + "$id": "324", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3395,7 +3411,7 @@ ] }, { - "$id": "323", + "$id": "325", "kind": "model", "name": "Friend", "namespace": "SampleTypeSpec", @@ -3410,13 +3426,13 @@ }, "properties": [ { - "$id": "324", + "$id": "326", "kind": "property", "name": "name", "serializedName": "name", "doc": "name of the NotFriend", "type": { - "$id": "325", + "$id": "327", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3438,7 +3454,7 @@ ] }, { - "$id": "326", + "$id": "328", "kind": "model", "name": "RenamedModel", "namespace": "SampleTypeSpec", @@ -3453,13 +3469,13 @@ }, "properties": [ { - "$id": "327", + "$id": "329", "kind": "property", "name": "otherName", "serializedName": "otherName", "doc": "name of the ModelWithClientName", "type": { - "$id": "328", + "$id": "330", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3481,7 +3497,7 @@ ] }, { - "$id": "329", + "$id": "331", "kind": "model", "name": "ReturnsAnonymousModelResponse", "namespace": "SampleTypeSpec", @@ -3496,7 +3512,7 @@ "properties": [] }, { - "$id": "330", + "$id": "332", "kind": "model", "name": "ListWithNextLinkResponse", "namespace": "SampleTypeSpec", @@ -3510,16 +3526,16 @@ }, "properties": [ { - "$id": "331", + "$id": "333", "kind": "property", "name": "things", "serializedName": "things", "type": { - "$id": "332", + "$id": "334", "kind": "array", "name": "ArrayThing", "valueType": { - "$ref": "234" + "$ref": "236" }, "crossLanguageDefinitionId": "TypeSpec.Array", "decorators": [] @@ -3538,12 +3554,12 @@ "isHttpMetadata": false }, { - "$id": "333", + "$id": "335", "kind": "property", "name": "next", "serializedName": "next", "type": { - "$id": "334", + "$id": "336", "kind": "url", "name": "url", "crossLanguageDefinitionId": "TypeSpec.url", @@ -3565,7 +3581,7 @@ ] }, { - "$id": "335", + "$id": "337", "kind": "model", "name": "ListWithStringNextLinkResponse", "namespace": "SampleTypeSpec", @@ -3579,12 +3595,12 @@ }, "properties": [ { - "$id": "336", + "$id": "338", "kind": "property", "name": "things", "serializedName": "things", "type": { - "$ref": "332" + "$ref": "334" }, "optional": false, "readOnly": false, @@ -3600,12 +3616,12 @@ "isHttpMetadata": false }, { - "$id": "337", + "$id": "339", "kind": "property", "name": "next", "serializedName": "next", "type": { - "$id": "338", + "$id": "340", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3627,7 +3643,7 @@ ] }, { - "$id": "339", + "$id": "341", "kind": "model", "name": "ListWithContinuationTokenResponse", "namespace": "SampleTypeSpec", @@ -3641,12 +3657,12 @@ }, "properties": [ { - "$id": "340", + "$id": "342", "kind": "property", "name": "things", "serializedName": "things", "type": { - "$ref": "332" + "$ref": "334" }, "optional": false, "readOnly": false, @@ -3662,12 +3678,12 @@ "isHttpMetadata": false }, { - "$id": "341", + "$id": "343", "kind": "property", "name": "nextToken", "serializedName": "nextToken", "type": { - "$id": "342", + "$id": "344", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3689,7 +3705,7 @@ ] }, { - "$id": "343", + "$id": "345", "kind": "model", "name": "ListWithContinuationTokenHeaderResponseResponse", "namespace": "", @@ -3703,12 +3719,12 @@ }, "properties": [ { - "$id": "344", + "$id": "346", "kind": "property", "name": "things", "serializedName": "things", "type": { - "$ref": "332" + "$ref": "334" }, "optional": false, "readOnly": false, @@ -3726,7 +3742,7 @@ ] }, { - "$id": "345", + "$id": "347", "kind": "model", "name": "PageThing", "namespace": "SampleTypeSpec", @@ -3740,12 +3756,12 @@ }, "properties": [ { - "$id": "346", + "$id": "348", "kind": "property", "name": "items", "serializedName": "items", "type": { - "$ref": "332" + "$ref": "334" }, "optional": false, "readOnly": false, @@ -3763,7 +3779,7 @@ ] }, { - "$id": "347", + "$id": "349", "kind": "model", "name": "ModelWithEmbeddedNonBodyParameters", "namespace": "SampleTypeSpec", @@ -3777,13 +3793,13 @@ }, "properties": [ { - "$id": "348", + "$id": "350", "kind": "property", "name": "name", "serializedName": "name", "doc": "name of the ModelWithEmbeddedNonBodyParameters", "type": { - "$id": "349", + "$id": "351", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3803,13 +3819,13 @@ "isHttpMetadata": false }, { - "$id": "350", + "$id": "352", "kind": "property", "name": "requiredHeader", "serializedName": "requiredHeader", "doc": "required header parameter", "type": { - "$id": "351", + "$id": "353", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3829,13 +3845,13 @@ "isHttpMetadata": true }, { - "$id": "352", + "$id": "354", "kind": "property", "name": "optionalHeader", "serializedName": "optionalHeader", "doc": "optional header parameter", "type": { - "$id": "353", + "$id": "355", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3855,13 +3871,13 @@ "isHttpMetadata": true }, { - "$id": "354", + "$id": "356", "kind": "property", "name": "requiredQuery", "serializedName": "requiredQuery", "doc": "required query parameter", "type": { - "$id": "355", + "$id": "357", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3881,13 +3897,13 @@ "isHttpMetadata": true }, { - "$id": "356", + "$id": "358", "kind": "property", "name": "optionalQuery", "serializedName": "optionalQuery", "doc": "optional query parameter", "type": { - "$id": "357", + "$id": "359", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3909,7 +3925,7 @@ ] }, { - "$id": "358", + "$id": "360", "kind": "model", "name": "DynamicModel", "namespace": "SampleTypeSpec", @@ -3929,12 +3945,12 @@ }, "properties": [ { - "$id": "359", + "$id": "361", "kind": "property", "name": "name", "serializedName": "name", "type": { - "$id": "360", + "$id": "362", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -3954,12 +3970,12 @@ "isHttpMetadata": false }, { - "$id": "361", + "$id": "363", "kind": "property", "name": "optionalUnknown", "serializedName": "optionalUnknown", "type": { - "$id": "362", + "$id": "364", "kind": "unknown", "name": "unknown", "crossLanguageDefinitionId": "", @@ -3979,12 +3995,12 @@ "isHttpMetadata": false }, { - "$id": "363", + "$id": "365", "kind": "property", "name": "optionalInt", "serializedName": "optionalInt", "type": { - "$id": "364", + "$id": "366", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -4004,15 +4020,15 @@ "isHttpMetadata": false }, { - "$id": "365", + "$id": "367", "kind": "property", "name": "optionalNullableList", "serializedName": "optionalNullableList", "type": { - "$id": "366", + "$id": "368", "kind": "nullable", "type": { - "$ref": "263" + "$ref": "265" }, "namespace": "SampleTypeSpec" }, @@ -4030,15 +4046,15 @@ "isHttpMetadata": false }, { - "$id": "367", + "$id": "369", "kind": "property", "name": "requiredNullableList", "serializedName": "requiredNullableList", "type": { - "$id": "368", + "$id": "370", "kind": "nullable", "type": { - "$ref": "263" + "$ref": "265" }, "namespace": "SampleTypeSpec" }, @@ -4056,25 +4072,25 @@ "isHttpMetadata": false }, { - "$id": "369", + "$id": "371", "kind": "property", "name": "optionalNullableDictionary", "serializedName": "optionalNullableDictionary", "type": { - "$id": "370", + "$id": "372", "kind": "nullable", "type": { - "$id": "371", + "$id": "373", "kind": "dict", "keyType": { - "$id": "372", + "$id": "374", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$id": "373", + "$id": "375", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -4098,15 +4114,15 @@ "isHttpMetadata": false }, { - "$id": "374", + "$id": "376", "kind": "property", "name": "requiredNullableDictionary", "serializedName": "requiredNullableDictionary", "type": { - "$id": "375", + "$id": "377", "kind": "nullable", "type": { - "$ref": "371" + "$ref": "373" }, "namespace": "SampleTypeSpec" }, @@ -4124,12 +4140,12 @@ "isHttpMetadata": false }, { - "$id": "376", + "$id": "378", "kind": "property", "name": "primitiveDictionary", "serializedName": "primitiveDictionary", "type": { - "$ref": "371" + "$ref": "373" }, "optional": false, "readOnly": false, @@ -4145,12 +4161,12 @@ "isHttpMetadata": false }, { - "$id": "377", + "$id": "379", "kind": "property", "name": "foo", "serializedName": "foo", "type": { - "$id": "378", + "$id": "380", "kind": "model", "name": "AnotherDynamicModel", "namespace": "SampleTypeSpec", @@ -4170,12 +4186,12 @@ }, "properties": [ { - "$id": "379", + "$id": "381", "kind": "property", "name": "bar", "serializedName": "bar", "type": { - "$id": "380", + "$id": "382", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4210,16 +4226,16 @@ "isHttpMetadata": false }, { - "$id": "381", + "$id": "383", "kind": "property", "name": "listFoo", "serializedName": "listFoo", "type": { - "$id": "382", + "$id": "384", "kind": "array", "name": "ArrayAnotherDynamicModel", "valueType": { - "$ref": "378" + "$ref": "380" }, "crossLanguageDefinitionId": "TypeSpec.Array", "decorators": [] @@ -4238,16 +4254,16 @@ "isHttpMetadata": false }, { - "$id": "383", + "$id": "385", "kind": "property", "name": "listOfListFoo", "serializedName": "listOfListFoo", "type": { - "$id": "384", + "$id": "386", "kind": "array", "name": "ArrayArray", "valueType": { - "$ref": "382" + "$ref": "384" }, "crossLanguageDefinitionId": "TypeSpec.Array", "decorators": [] @@ -4266,22 +4282,22 @@ "isHttpMetadata": false }, { - "$id": "385", + "$id": "387", "kind": "property", "name": "dictionaryFoo", "serializedName": "dictionaryFoo", "type": { - "$id": "386", + "$id": "388", "kind": "dict", "keyType": { - "$id": "387", + "$id": "389", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$ref": "378" + "$ref": "380" }, "decorators": [] }, @@ -4299,22 +4315,22 @@ "isHttpMetadata": false }, { - "$id": "388", + "$id": "390", "kind": "property", "name": "dictionaryOfDictionaryFoo", "serializedName": "dictionaryOfDictionaryFoo", "type": { - "$id": "389", + "$id": "391", "kind": "dict", "keyType": { - "$id": "390", + "$id": "392", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$ref": "386" + "$ref": "388" }, "decorators": [] }, @@ -4332,22 +4348,22 @@ "isHttpMetadata": false }, { - "$id": "391", + "$id": "393", "kind": "property", "name": "dictionaryListFoo", "serializedName": "dictionaryListFoo", "type": { - "$id": "392", + "$id": "394", "kind": "dict", "keyType": { - "$id": "393", + "$id": "395", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$ref": "382" + "$ref": "384" }, "decorators": [] }, @@ -4365,16 +4381,16 @@ "isHttpMetadata": false }, { - "$id": "394", + "$id": "396", "kind": "property", "name": "listOfDictionaryFoo", "serializedName": "listOfDictionaryFoo", "type": { - "$id": "395", + "$id": "397", "kind": "array", "name": "ArrayRecord", "valueType": { - "$ref": "386" + "$ref": "388" }, "crossLanguageDefinitionId": "TypeSpec.Array", "decorators": [] @@ -4395,10 +4411,10 @@ ] }, { - "$ref": "378" + "$ref": "380" }, { - "$id": "396", + "$id": "398", "kind": "model", "name": "XmlAdvancedModel", "namespace": "SampleTypeSpec", @@ -4422,13 +4438,13 @@ }, "properties": [ { - "$id": "397", + "$id": "399", "kind": "property", "name": "name", "serializedName": "name", "doc": "A simple string property", "type": { - "$id": "398", + "$id": "400", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4450,13 +4466,13 @@ "isHttpMetadata": false }, { - "$id": "399", + "$id": "401", "kind": "property", "name": "age", "serializedName": "age", "doc": "An integer property", "type": { - "$id": "400", + "$id": "402", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -4478,13 +4494,13 @@ "isHttpMetadata": false }, { - "$id": "401", + "$id": "403", "kind": "property", "name": "enabled", "serializedName": "enabled", "doc": "A boolean property", "type": { - "$id": "402", + "$id": "404", "kind": "boolean", "name": "boolean", "crossLanguageDefinitionId": "TypeSpec.boolean", @@ -4506,13 +4522,13 @@ "isHttpMetadata": false }, { - "$id": "403", + "$id": "405", "kind": "property", "name": "score", "serializedName": "score", "doc": "A float property", "type": { - "$id": "404", + "$id": "406", "kind": "float32", "name": "float32", "crossLanguageDefinitionId": "TypeSpec.float32", @@ -4534,13 +4550,13 @@ "isHttpMetadata": false }, { - "$id": "405", + "$id": "407", "kind": "property", "name": "optionalString", "serializedName": "optionalString", "doc": "An optional string", "type": { - "$id": "406", + "$id": "408", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4562,13 +4578,13 @@ "isHttpMetadata": false }, { - "$id": "407", + "$id": "409", "kind": "property", "name": "optionalInt", "serializedName": "optionalInt", "doc": "An optional integer", "type": { - "$id": "408", + "$id": "410", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -4590,16 +4606,16 @@ "isHttpMetadata": false }, { - "$id": "409", + "$id": "411", "kind": "property", "name": "nullableString", "serializedName": "nullableString", "doc": "A nullable string", "type": { - "$id": "410", + "$id": "412", "kind": "nullable", "type": { - "$id": "411", + "$id": "413", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4623,13 +4639,13 @@ "isHttpMetadata": false }, { - "$id": "412", + "$id": "414", "kind": "property", "name": "id", "serializedName": "id", "doc": "A string as XML attribute", "type": { - "$id": "413", + "$id": "415", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4656,13 +4672,13 @@ "isHttpMetadata": false }, { - "$id": "414", + "$id": "416", "kind": "property", "name": "version", "serializedName": "version", "doc": "An integer as XML attribute", "type": { - "$id": "415", + "$id": "417", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -4689,13 +4705,13 @@ "isHttpMetadata": false }, { - "$id": "416", + "$id": "418", "kind": "property", "name": "isActive", "serializedName": "isActive", "doc": "A boolean as XML attribute", "type": { - "$id": "417", + "$id": "419", "kind": "boolean", "name": "boolean", "crossLanguageDefinitionId": "TypeSpec.boolean", @@ -4722,13 +4738,13 @@ "isHttpMetadata": false }, { - "$id": "418", + "$id": "420", "kind": "property", "name": "originalName", "serializedName": "RenamedProperty", "doc": "A property with a custom XML element name", "type": { - "$id": "419", + "$id": "421", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4757,13 +4773,13 @@ "isHttpMetadata": false }, { - "$id": "420", + "$id": "422", "kind": "property", "name": "xmlIdentifier", "serializedName": "xml-id", "doc": "An attribute with a custom XML name", "type": { - "$id": "421", + "$id": "423", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4796,13 +4812,13 @@ "isHttpMetadata": false }, { - "$id": "422", + "$id": "424", "kind": "property", "name": "content", "serializedName": "content", "doc": "Text content in the element (unwrapped string)", "type": { - "$id": "423", + "$id": "425", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4829,13 +4845,13 @@ "isHttpMetadata": false }, { - "$id": "424", + "$id": "426", "kind": "property", "name": "unwrappedStrings", "serializedName": "unwrappedStrings", "doc": "An unwrapped array of strings - items appear directly without wrapper", "type": { - "$ref": "240" + "$ref": "242" }, "optional": false, "readOnly": false, @@ -4859,13 +4875,13 @@ "isHttpMetadata": false }, { - "$id": "425", + "$id": "427", "kind": "property", "name": "unwrappedCounts", "serializedName": "unwrappedCounts", "doc": "An unwrapped array of integers", "type": { - "$ref": "263" + "$ref": "265" }, "optional": false, "readOnly": false, @@ -4889,17 +4905,17 @@ "isHttpMetadata": false }, { - "$id": "426", + "$id": "428", "kind": "property", "name": "unwrappedItems", "serializedName": "unwrappedItems", "doc": "An unwrapped array of models", "type": { - "$id": "427", + "$id": "429", "kind": "array", "name": "ArrayXmlItem", "valueType": { - "$id": "428", + "$id": "430", "kind": "model", "name": "XmlItem", "namespace": "SampleTypeSpec", @@ -4923,13 +4939,13 @@ }, "properties": [ { - "$id": "429", + "$id": "431", "kind": "property", "name": "itemName", "serializedName": "itemName", "doc": "The item name", "type": { - "$id": "430", + "$id": "432", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -4951,13 +4967,13 @@ "isHttpMetadata": false }, { - "$id": "431", + "$id": "433", "kind": "property", "name": "itemValue", "serializedName": "itemValue", "doc": "The item value", "type": { - "$id": "432", + "$id": "434", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -4979,13 +4995,13 @@ "isHttpMetadata": false }, { - "$id": "433", + "$id": "435", "kind": "property", "name": "itemId", "serializedName": "itemId", "doc": "Item ID as attribute", "type": { - "$id": "434", + "$id": "436", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -5038,13 +5054,13 @@ "isHttpMetadata": false }, { - "$id": "435", + "$id": "437", "kind": "property", "name": "wrappedColors", "serializedName": "wrappedColors", "doc": "A wrapped array of strings (default)", "type": { - "$ref": "240" + "$ref": "242" }, "optional": false, "readOnly": false, @@ -5063,13 +5079,13 @@ "isHttpMetadata": false }, { - "$id": "436", + "$id": "438", "kind": "property", "name": "items", "serializedName": "ItemCollection", "doc": "A wrapped array with custom wrapper name", "type": { - "$ref": "427" + "$ref": "429" }, "optional": false, "readOnly": false, @@ -5095,13 +5111,13 @@ "isHttpMetadata": false }, { - "$id": "437", + "$id": "439", "kind": "property", "name": "nestedModel", "serializedName": "nestedModel", "doc": "A nested model property", "type": { - "$id": "438", + "$id": "440", "kind": "model", "name": "XmlNestedModel", "namespace": "SampleTypeSpec", @@ -5118,13 +5134,13 @@ }, "properties": [ { - "$id": "439", + "$id": "441", "kind": "property", "name": "value", "serializedName": "value", "doc": "The value of the nested model", "type": { - "$id": "440", + "$id": "442", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -5146,13 +5162,13 @@ "isHttpMetadata": false }, { - "$id": "441", + "$id": "443", "kind": "property", "name": "nestedId", "serializedName": "nestedId", "doc": "An attribute on the nested model", "type": { - "$id": "442", + "$id": "444", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -5196,13 +5212,13 @@ "isHttpMetadata": false }, { - "$id": "443", + "$id": "445", "kind": "property", "name": "optionalNestedModel", "serializedName": "optionalNestedModel", "doc": "An optional nested model", "type": { - "$ref": "438" + "$ref": "440" }, "optional": true, "readOnly": false, @@ -5220,23 +5236,23 @@ "isHttpMetadata": false }, { - "$id": "444", + "$id": "446", "kind": "property", "name": "metadata", "serializedName": "metadata", "doc": "A dictionary property", "type": { - "$id": "445", + "$id": "447", "kind": "dict", "keyType": { - "$id": "446", + "$id": "448", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$id": "447", + "$id": "449", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -5260,18 +5276,18 @@ "isHttpMetadata": false }, { - "$id": "448", + "$id": "450", "kind": "property", "name": "createdAt", "serializedName": "createdAt", "doc": "A date-time property", "type": { - "$id": "449", + "$id": "451", "kind": "utcDateTime", "name": "utcDateTime", "encode": "rfc3339", "wireType": { - "$id": "450", + "$id": "452", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -5296,18 +5312,18 @@ "isHttpMetadata": false }, { - "$id": "451", + "$id": "453", "kind": "property", "name": "duration", "serializedName": "duration", "doc": "A duration property", "type": { - "$id": "452", + "$id": "454", "kind": "duration", "name": "duration", "encode": "ISO8601", "wireType": { - "$id": "453", + "$id": "455", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -5332,13 +5348,13 @@ "isHttpMetadata": false }, { - "$id": "454", + "$id": "456", "kind": "property", "name": "data", "serializedName": "data", "doc": "A bytes property", "type": { - "$id": "455", + "$id": "457", "kind": "bytes", "name": "bytes", "encode": "base64", @@ -5361,13 +5377,13 @@ "isHttpMetadata": false }, { - "$id": "456", + "$id": "458", "kind": "property", "name": "optionalRecordUnknown", "serializedName": "optionalRecordUnknown", "doc": "optional record of unknown", "type": { - "$ref": "300" + "$ref": "302" }, "optional": true, "readOnly": false, @@ -5385,7 +5401,7 @@ "isHttpMetadata": false }, { - "$id": "457", + "$id": "459", "kind": "property", "name": "fixedEnum", "serializedName": "fixedEnum", @@ -5409,7 +5425,7 @@ "isHttpMetadata": false }, { - "$id": "458", + "$id": "460", "kind": "property", "name": "extensibleEnum", "serializedName": "extensibleEnum", @@ -5433,7 +5449,7 @@ "isHttpMetadata": false }, { - "$id": "459", + "$id": "461", "kind": "property", "name": "optionalFixedEnum", "serializedName": "optionalFixedEnum", @@ -5457,7 +5473,7 @@ "isHttpMetadata": false }, { - "$id": "460", + "$id": "462", "kind": "property", "name": "optionalExtensibleEnum", "serializedName": "optionalExtensibleEnum", @@ -5481,12 +5497,12 @@ "isHttpMetadata": false }, { - "$id": "461", + "$id": "463", "kind": "property", "name": "label", "serializedName": "label", "type": { - "$id": "462", + "$id": "464", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -5501,13 +5517,13 @@ "name": "TypeSpec.Xml.@ns", "arguments": { "ns": { - "$id": "463", + "$id": "465", "kind": "enumvalue", "decorators": [], "name": "ns1", "value": "https://example.com/ns1", "enumType": { - "$id": "464", + "$id": "466", "kind": "enum", "decorators": [ { @@ -5519,7 +5535,7 @@ "isGeneratedName": false, "namespace": "SampleTypeSpec", "valueType": { - "$id": "465", + "$id": "467", "kind": "string", "decorators": [], "doc": "A sequence of textual characters.", @@ -5528,30 +5544,30 @@ }, "values": [ { - "$id": "466", + "$id": "468", "kind": "enumvalue", "decorators": [], "name": "ns1", "value": "https://example.com/ns1", "enumType": { - "$ref": "464" + "$ref": "466" }, "valueType": { - "$ref": "465" + "$ref": "467" }, "crossLanguageDefinitionId": "SampleTypeSpec.XmlNamespaces.ns1" }, { - "$id": "467", + "$id": "469", "kind": "enumvalue", "decorators": [], "name": "ns2", "value": "https://example.com/ns2", "enumType": { - "$ref": "464" + "$ref": "466" }, "valueType": { - "$ref": "465" + "$ref": "467" }, "crossLanguageDefinitionId": "SampleTypeSpec.XmlNamespaces.ns2" } @@ -5569,7 +5585,7 @@ "__accessSet": true }, "valueType": { - "$ref": "465" + "$ref": "467" }, "crossLanguageDefinitionId": "SampleTypeSpec.XmlNamespaces.ns1" } @@ -5595,12 +5611,12 @@ "isHttpMetadata": false }, { - "$id": "468", + "$id": "470", "kind": "property", "name": "daysUsed", "serializedName": "daysUsed", "type": { - "$id": "469", + "$id": "471", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -5615,16 +5631,16 @@ "name": "TypeSpec.Xml.@ns", "arguments": { "ns": { - "$id": "470", + "$id": "472", "kind": "enumvalue", "decorators": [], "name": "ns2", "value": "https://example.com/ns2", "enumType": { - "$ref": "464" + "$ref": "466" }, "valueType": { - "$ref": "465" + "$ref": "467" }, "crossLanguageDefinitionId": "SampleTypeSpec.XmlNamespaces.ns2" } @@ -5646,12 +5662,12 @@ "isHttpMetadata": false }, { - "$id": "471", + "$id": "473", "kind": "property", "name": "fooItems", "serializedName": "fooItems", "type": { - "$ref": "240" + "$ref": "242" }, "optional": false, "readOnly": false, @@ -5682,12 +5698,12 @@ "isHttpMetadata": false }, { - "$id": "472", + "$id": "474", "kind": "property", "name": "anotherModel", "serializedName": "anotherModel", "type": { - "$ref": "438" + "$ref": "440" }, "optional": false, "readOnly": false, @@ -5717,16 +5733,16 @@ "isHttpMetadata": false }, { - "$id": "473", + "$id": "475", "kind": "property", "name": "modelsWithNamespaces", "serializedName": "modelsWithNamespaces", "type": { - "$id": "474", + "$id": "476", "kind": "array", "name": "ArrayXmlModelWithNamespace", "valueType": { - "$id": "475", + "$id": "477", "kind": "model", "name": "XmlModelWithNamespace", "namespace": "SampleTypeSpec", @@ -5754,12 +5770,12 @@ }, "properties": [ { - "$id": "476", + "$id": "478", "kind": "property", "name": "foo", "serializedName": "foo", "type": { - "$id": "477", + "$id": "479", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -5806,12 +5822,12 @@ "isHttpMetadata": false }, { - "$id": "478", + "$id": "480", "kind": "property", "name": "unwrappedModelsWithNamespaces", "serializedName": "unwrappedModelsWithNamespaces", "type": { - "$ref": "474" + "$ref": "476" }, "optional": false, "readOnly": false, @@ -5835,16 +5851,16 @@ "isHttpMetadata": false }, { - "$id": "479", + "$id": "481", "kind": "property", "name": "listOfListFoo", "serializedName": "listOfListFoo", "type": { - "$id": "480", + "$id": "482", "kind": "array", "name": "ArrayArray1", "valueType": { - "$ref": "427" + "$ref": "429" }, "crossLanguageDefinitionId": "TypeSpec.Array", "decorators": [] @@ -5866,22 +5882,22 @@ "isHttpMetadata": false }, { - "$id": "481", + "$id": "483", "kind": "property", "name": "dictionaryFoo", "serializedName": "dictionaryFoo", "type": { - "$id": "482", + "$id": "484", "kind": "dict", "keyType": { - "$id": "483", + "$id": "485", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$ref": "428" + "$ref": "430" }, "decorators": [] }, @@ -5901,22 +5917,22 @@ "isHttpMetadata": false }, { - "$id": "484", + "$id": "486", "kind": "property", "name": "dictionaryOfDictionaryFoo", "serializedName": "dictionaryOfDictionaryFoo", "type": { - "$id": "485", + "$id": "487", "kind": "dict", "keyType": { - "$id": "486", + "$id": "488", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$ref": "482" + "$ref": "484" }, "decorators": [] }, @@ -5936,22 +5952,22 @@ "isHttpMetadata": false }, { - "$id": "487", + "$id": "489", "kind": "property", "name": "dictionaryListFoo", "serializedName": "dictionaryListFoo", "type": { - "$id": "488", + "$id": "490", "kind": "dict", "keyType": { - "$id": "489", + "$id": "491", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", "decorators": [] }, "valueType": { - "$ref": "427" + "$ref": "429" }, "decorators": [] }, @@ -5971,16 +5987,16 @@ "isHttpMetadata": false }, { - "$id": "490", + "$id": "492", "kind": "property", "name": "listOfDictionaryFoo", "serializedName": "listOfDictionaryFoo", "type": { - "$id": "491", + "$id": "493", "kind": "array", "name": "ArrayRecord1", "valueType": { - "$ref": "482" + "$ref": "484" }, "crossLanguageDefinitionId": "TypeSpec.Array", "decorators": [] @@ -6004,16 +6020,82 @@ ] }, { - "$ref": "428" + "$ref": "430" + }, + { + "$ref": "440" }, { - "$ref": "438" + "$ref": "477" }, { - "$ref": "475" + "$id": "494", + "kind": "model", + "name": "GetNotebookResponse", + "namespace": "SampleTypeSpec", + "crossLanguageDefinitionId": "SampleTypeSpec.getNotebook.Response.anonymous", + "usage": "Output,Json", + "decorators": [], + "serializationOptions": { + "json": { + "name": "" + } + }, + "properties": [ + { + "$id": "495", + "kind": "property", + "name": "name", + "serializedName": "name", + "type": { + "$id": "496", + "kind": "string", + "name": "string", + "crossLanguageDefinitionId": "TypeSpec.string", + "decorators": [] + }, + "optional": false, + "readOnly": false, + "discriminator": false, + "flatten": false, + "decorators": [], + "crossLanguageDefinitionId": "SampleTypeSpec.getNotebook.Response.anonymous.name", + "serializationOptions": { + "json": { + "name": "name" + } + }, + "isHttpMetadata": false + }, + { + "$id": "497", + "kind": "property", + "name": "content", + "serializedName": "content", + "type": { + "$id": "498", + "kind": "string", + "name": "string", + "crossLanguageDefinitionId": "TypeSpec.string", + "decorators": [] + }, + "optional": false, + "readOnly": false, + "discriminator": false, + "flatten": false, + "decorators": [], + "crossLanguageDefinitionId": "SampleTypeSpec.getNotebook.Response.anonymous.content", + "serializationOptions": { + "json": { + "name": "content" + } + }, + "isHttpMetadata": false + } + ] }, { - "$id": "492", + "$id": "499", "kind": "model", "name": "Animal", "namespace": "SampleTypeSpec", @@ -6027,13 +6109,13 @@ } }, "discriminatorProperty": { - "$id": "493", + "$id": "500", "kind": "property", "name": "kind", "serializedName": "kind", "doc": "The kind of animal", "type": { - "$id": "494", + "$id": "501", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6054,16 +6136,16 @@ }, "properties": [ { - "$ref": "493" + "$ref": "500" }, { - "$id": "495", + "$id": "502", "kind": "property", "name": "name", "serializedName": "name", "doc": "Name of the animal", "type": { - "$id": "496", + "$id": "503", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6085,7 +6167,7 @@ ], "discriminatedSubtypes": { "pet": { - "$id": "497", + "$id": "504", "kind": "model", "name": "Pet", "namespace": "SampleTypeSpec", @@ -6100,7 +6182,7 @@ } }, "discriminatorProperty": { - "$id": "498", + "$id": "505", "kind": "property", "name": "kind", "serializedName": "kind", @@ -6121,20 +6203,20 @@ "isHttpMetadata": false }, "baseModel": { - "$ref": "492" + "$ref": "499" }, "properties": [ { - "$ref": "498" + "$ref": "505" }, { - "$id": "499", + "$id": "506", "kind": "property", "name": "trained", "serializedName": "trained", "doc": "Whether the pet is trained", "type": { - "$id": "500", + "$id": "507", "kind": "boolean", "name": "boolean", "crossLanguageDefinitionId": "TypeSpec.boolean", @@ -6156,7 +6238,7 @@ ], "discriminatedSubtypes": { "dog": { - "$id": "501", + "$id": "508", "kind": "model", "name": "Dog", "namespace": "SampleTypeSpec", @@ -6171,11 +6253,11 @@ } }, "baseModel": { - "$ref": "497" + "$ref": "504" }, "properties": [ { - "$id": "502", + "$id": "509", "kind": "property", "name": "kind", "serializedName": "kind", @@ -6196,13 +6278,13 @@ "isHttpMetadata": false }, { - "$id": "503", + "$id": "510", "kind": "property", "name": "breed", "serializedName": "breed", "doc": "The breed of the dog", "type": { - "$id": "504", + "$id": "511", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6226,18 +6308,18 @@ } }, "dog": { - "$ref": "501" + "$ref": "508" } } }, { - "$ref": "497" + "$ref": "504" }, { - "$ref": "501" + "$ref": "508" }, { - "$id": "505", + "$id": "512", "kind": "model", "name": "Tree", "namespace": "SampleTypeSpec", @@ -6257,7 +6339,7 @@ } }, "baseModel": { - "$id": "506", + "$id": "513", "kind": "model", "name": "Plant", "namespace": "SampleTypeSpec", @@ -6276,13 +6358,13 @@ } }, "discriminatorProperty": { - "$id": "507", + "$id": "514", "kind": "property", "name": "species", "serializedName": "species", "doc": "The species of plant", "type": { - "$id": "508", + "$id": "515", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6308,16 +6390,16 @@ }, "properties": [ { - "$ref": "507" + "$ref": "514" }, { - "$id": "509", + "$id": "516", "kind": "property", "name": "id", "serializedName": "id", "doc": "The unique identifier of the plant", "type": { - "$id": "510", + "$id": "517", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6342,13 +6424,13 @@ "isHttpMetadata": false }, { - "$id": "511", + "$id": "518", "kind": "property", "name": "height", "serializedName": "height", "doc": "The height of the plant in centimeters", "type": { - "$id": "512", + "$id": "519", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -6375,13 +6457,13 @@ ], "discriminatedSubtypes": { "tree": { - "$ref": "505" + "$ref": "512" } } }, "properties": [ { - "$id": "513", + "$id": "520", "kind": "property", "name": "species", "serializedName": "species", @@ -6407,13 +6489,13 @@ "isHttpMetadata": false }, { - "$id": "514", + "$id": "521", "kind": "property", "name": "age", "serializedName": "age", "doc": "The age of the tree in years", "type": { - "$id": "515", + "$id": "522", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -6440,10 +6522,10 @@ ] }, { - "$ref": "506" + "$ref": "513" }, { - "$id": "516", + "$id": "523", "kind": "model", "name": "GetWidgetMetricsResponse", "namespace": "SampleTypeSpec", @@ -6457,12 +6539,12 @@ }, "properties": [ { - "$id": "517", + "$id": "524", "kind": "property", "name": "numSold", "serializedName": "numSold", "type": { - "$id": "518", + "$id": "525", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -6482,12 +6564,12 @@ "isHttpMetadata": false }, { - "$id": "519", + "$id": "526", "kind": "property", "name": "averagePrice", "serializedName": "averagePrice", "type": { - "$id": "520", + "$id": "527", "kind": "float32", "name": "float32", "crossLanguageDefinitionId": "TypeSpec.float32", @@ -6511,14 +6593,14 @@ ], "clients": [ { - "$id": "521", + "$id": "528", "kind": "client", "name": "SampleTypeSpecClient", "namespace": "SampleTypeSpec", "doc": "This is a sample typespec project.", "methods": [ { - "$id": "522", + "$id": "529", "kind": "basic", "name": "sayHi", "accessibility": "public", @@ -6528,19 +6610,19 @@ ], "doc": "Return hi", "operation": { - "$id": "523", + "$id": "530", "name": "sayHi", "resourceName": "SampleTypeSpec", "doc": "Return hi", "accessibility": "public", "parameters": [ { - "$id": "524", + "$id": "531", "kind": "header", "name": "headParameter", "serializedName": "head-parameter", "type": { - "$id": "525", + "$id": "532", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6555,12 +6637,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.sayHi.headParameter", "methodParameterSegments": [ { - "$id": "526", + "$id": "533", "kind": "method", "name": "headParameter", "serializedName": "head-parameter", "type": { - "$id": "527", + "$id": "534", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6578,12 +6660,12 @@ ] }, { - "$id": "528", + "$id": "535", "kind": "query", "name": "queryParameter", "serializedName": "queryParameter", "type": { - "$id": "529", + "$id": "536", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6598,12 +6680,12 @@ "readOnly": false, "methodParameterSegments": [ { - "$id": "530", + "$id": "537", "kind": "method", "name": "queryParameter", "serializedName": "queryParameter", "type": { - "$id": "531", + "$id": "538", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6621,12 +6703,12 @@ ] }, { - "$id": "532", + "$id": "539", "kind": "query", "name": "optionalQuery", "serializedName": "optionalQuery", "type": { - "$id": "533", + "$id": "540", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6641,12 +6723,12 @@ "readOnly": false, "methodParameterSegments": [ { - "$id": "534", + "$id": "541", "kind": "method", "name": "optionalQuery", "serializedName": "optionalQuery", "type": { - "$id": "535", + "$id": "542", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6664,7 +6746,7 @@ ] }, { - "$id": "536", + "$id": "543", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -6680,7 +6762,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.sayHi.accept", "methodParameterSegments": [ { - "$id": "537", + "$id": "544", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -6705,7 +6787,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -6726,21 +6808,21 @@ }, "parameters": [ { - "$ref": "526" + "$ref": "533" }, { - "$ref": "530" + "$ref": "537" }, { - "$ref": "534" + "$ref": "541" }, { - "$ref": "537" + "$ref": "544" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -6749,7 +6831,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.sayHi" }, { - "$id": "538", + "$id": "545", "kind": "basic", "name": "helloAgain", "accessibility": "public", @@ -6759,19 +6841,19 @@ ], "doc": "Return hi again", "operation": { - "$id": "539", + "$id": "546", "name": "helloAgain", "resourceName": "SampleTypeSpec", "doc": "Return hi again", "accessibility": "public", "parameters": [ { - "$id": "540", + "$id": "547", "kind": "header", "name": "p1", "serializedName": "p1", "type": { - "$id": "541", + "$id": "548", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6786,12 +6868,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloAgain.p1", "methodParameterSegments": [ { - "$id": "542", + "$id": "549", "kind": "method", "name": "p1", "serializedName": "p1", "type": { - "$id": "543", + "$id": "550", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6809,7 +6891,7 @@ ] }, { - "$id": "544", + "$id": "551", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -6825,7 +6907,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloAgain.contentType", "methodParameterSegments": [ { - "$id": "545", + "$id": "552", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -6844,12 +6926,12 @@ ] }, { - "$id": "546", + "$id": "553", "kind": "path", "name": "p2", "serializedName": "p2", "type": { - "$id": "547", + "$id": "554", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6867,12 +6949,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloAgain.p2", "methodParameterSegments": [ { - "$id": "548", + "$id": "555", "kind": "method", "name": "p2", "serializedName": "p2", "type": { - "$id": "549", + "$id": "556", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -6890,7 +6972,7 @@ ] }, { - "$id": "550", + "$id": "557", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -6906,7 +6988,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloAgain.accept", "methodParameterSegments": [ { - "$id": "551", + "$id": "558", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -6925,12 +7007,12 @@ ] }, { - "$id": "552", + "$id": "559", "kind": "body", "name": "action", "serializedName": "action", "type": { - "$ref": "269" + "$ref": "271" }, "isApiVersion": false, "contentTypes": [ @@ -6944,12 +7026,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloAgain.action", "methodParameterSegments": [ { - "$id": "553", + "$id": "560", "kind": "method", "name": "action", "serializedName": "action", "type": { - "$ref": "269" + "$ref": "271" }, "location": "Body", "isApiVersion": false, @@ -6969,7 +7051,7 @@ 200 ], "bodyType": { - "$ref": "269" + "$ref": "271" }, "headers": [], "isErrorResponse": false, @@ -6993,24 +7075,24 @@ }, "parameters": [ { - "$ref": "542" + "$ref": "549" }, { - "$ref": "553" + "$ref": "560" }, { - "$ref": "545" + "$ref": "552" }, { - "$ref": "548" + "$ref": "555" }, { - "$ref": "551" + "$ref": "558" } ], "response": { "type": { - "$ref": "269" + "$ref": "271" } }, "isOverride": false, @@ -7019,7 +7101,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloAgain" }, { - "$id": "554", + "$id": "561", "kind": "basic", "name": "noContentType", "accessibility": "public", @@ -7029,19 +7111,19 @@ ], "doc": "Return hi again", "operation": { - "$id": "555", + "$id": "562", "name": "noContentType", "resourceName": "SampleTypeSpec", "doc": "Return hi again", "accessibility": "public", "parameters": [ { - "$id": "556", + "$id": "563", "kind": "header", "name": "p1", "serializedName": "p1", "type": { - "$id": "557", + "$id": "564", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -7056,12 +7138,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.noContentType.p1", "methodParameterSegments": [ { - "$id": "558", + "$id": "565", "kind": "method", "name": "info", "serializedName": "info", "type": { - "$ref": "317" + "$ref": "319" }, "location": "", "isApiVersion": false, @@ -7073,13 +7155,13 @@ "decorators": [] }, { - "$id": "559", + "$id": "566", "kind": "method", "name": "p1", "serializedName": "p1", "doc": "header parameter", "type": { - "$ref": "319" + "$ref": "321" }, "location": "", "isApiVersion": false, @@ -7093,12 +7175,12 @@ ] }, { - "$id": "560", + "$id": "567", "kind": "path", "name": "p2", "serializedName": "p2", "type": { - "$id": "561", + "$id": "568", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -7116,16 +7198,16 @@ "crossLanguageDefinitionId": "SampleTypeSpec.noContentType.p2", "methodParameterSegments": [ { - "$ref": "558" + "$ref": "565" }, { - "$id": "562", + "$id": "569", "kind": "method", "name": "p2", "serializedName": "p2", "doc": "path parameter", "type": { - "$ref": "322" + "$ref": "324" }, "location": "", "isApiVersion": false, @@ -7139,7 +7221,7 @@ ] }, { - "$id": "563", + "$id": "570", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -7156,7 +7238,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.noContentType.contentType", "methodParameterSegments": [ { - "$id": "564", + "$id": "571", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -7176,7 +7258,7 @@ ] }, { - "$id": "565", + "$id": "572", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -7192,7 +7274,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.noContentType.accept", "methodParameterSegments": [ { - "$id": "566", + "$id": "573", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -7211,12 +7293,12 @@ ] }, { - "$id": "567", + "$id": "574", "kind": "body", "name": "action", "serializedName": "action", "type": { - "$ref": "269" + "$ref": "271" }, "isApiVersion": false, "contentTypes": [ @@ -7230,16 +7312,16 @@ "crossLanguageDefinitionId": "SampleTypeSpec.noContentType.action", "methodParameterSegments": [ { - "$ref": "558" + "$ref": "565" }, { - "$id": "568", + "$id": "575", "kind": "method", "name": "action", "serializedName": "action", "doc": "body parameter", "type": { - "$ref": "269" + "$ref": "271" }, "location": "", "isApiVersion": false, @@ -7259,7 +7341,7 @@ 200 ], "bodyType": { - "$ref": "269" + "$ref": "271" }, "headers": [], "isErrorResponse": false, @@ -7283,18 +7365,18 @@ }, "parameters": [ { - "$ref": "558" + "$ref": "565" }, { - "$ref": "564" + "$ref": "571" }, { - "$ref": "566" + "$ref": "573" } ], "response": { "type": { - "$ref": "269" + "$ref": "271" } }, "isOverride": true, @@ -7303,7 +7385,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.noContentType" }, { - "$id": "569", + "$id": "576", "kind": "basic", "name": "helloDemo2", "accessibility": "public", @@ -7313,14 +7395,14 @@ ], "doc": "Return hi in demo2", "operation": { - "$id": "570", + "$id": "577", "name": "helloDemo2", "resourceName": "SampleTypeSpec", "doc": "Return hi in demo2", "accessibility": "public", "parameters": [ { - "$id": "571", + "$id": "578", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -7336,7 +7418,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloDemo2.accept", "methodParameterSegments": [ { - "$id": "572", + "$id": "579", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -7361,7 +7443,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -7382,12 +7464,12 @@ }, "parameters": [ { - "$ref": "572" + "$ref": "579" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -7396,7 +7478,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloDemo2" }, { - "$id": "573", + "$id": "580", "kind": "basic", "name": "createLiteral", "accessibility": "public", @@ -7406,14 +7488,14 @@ ], "doc": "Create with literal value", "operation": { - "$id": "574", + "$id": "581", "name": "createLiteral", "resourceName": "SampleTypeSpec", "doc": "Create with literal value", "accessibility": "public", "parameters": [ { - "$id": "575", + "$id": "582", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -7430,7 +7512,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.createLiteral.contentType", "methodParameterSegments": [ { - "$id": "576", + "$id": "583", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -7450,7 +7532,7 @@ ] }, { - "$id": "577", + "$id": "584", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -7466,7 +7548,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.createLiteral.accept", "methodParameterSegments": [ { - "$id": "578", + "$id": "585", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -7485,12 +7567,12 @@ ] }, { - "$id": "579", + "$id": "586", "kind": "body", "name": "body", "serializedName": "body", "type": { - "$ref": "234" + "$ref": "236" }, "isApiVersion": false, "contentTypes": [ @@ -7504,12 +7586,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.createLiteral.body", "methodParameterSegments": [ { - "$id": "580", + "$id": "587", "kind": "method", "name": "body", "serializedName": "body", "type": { - "$ref": "234" + "$ref": "236" }, "location": "Body", "isApiVersion": false, @@ -7529,7 +7611,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -7553,18 +7635,18 @@ }, "parameters": [ { - "$ref": "580" + "$ref": "587" }, { - "$ref": "576" + "$ref": "583" }, { - "$ref": "578" + "$ref": "585" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -7573,7 +7655,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.createLiteral" }, { - "$id": "581", + "$id": "588", "kind": "basic", "name": "helloLiteral", "accessibility": "public", @@ -7583,14 +7665,14 @@ ], "doc": "Send literal parameters", "operation": { - "$id": "582", + "$id": "589", "name": "helloLiteral", "resourceName": "SampleTypeSpec", "doc": "Send literal parameters", "accessibility": "public", "parameters": [ { - "$id": "583", + "$id": "590", "kind": "header", "name": "p1", "serializedName": "p1", @@ -7606,7 +7688,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloLiteral.p1", "methodParameterSegments": [ { - "$id": "584", + "$id": "591", "kind": "method", "name": "p1", "serializedName": "p1", @@ -7625,7 +7707,7 @@ ] }, { - "$id": "585", + "$id": "592", "kind": "path", "name": "p2", "serializedName": "p2", @@ -7644,7 +7726,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloLiteral.p2", "methodParameterSegments": [ { - "$id": "586", + "$id": "593", "kind": "method", "name": "p2", "serializedName": "p2", @@ -7663,7 +7745,7 @@ ] }, { - "$id": "587", + "$id": "594", "kind": "query", "name": "p3", "serializedName": "p3", @@ -7679,7 +7761,7 @@ "readOnly": false, "methodParameterSegments": [ { - "$id": "588", + "$id": "595", "kind": "method", "name": "p3", "serializedName": "p3", @@ -7698,7 +7780,7 @@ ] }, { - "$id": "589", + "$id": "596", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -7714,7 +7796,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloLiteral.accept", "methodParameterSegments": [ { - "$id": "590", + "$id": "597", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -7739,7 +7821,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -7760,21 +7842,21 @@ }, "parameters": [ { - "$ref": "584" + "$ref": "591" }, { - "$ref": "586" + "$ref": "593" }, { - "$ref": "588" + "$ref": "595" }, { - "$ref": "590" + "$ref": "597" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -7783,7 +7865,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.helloLiteral" }, { - "$id": "591", + "$id": "598", "kind": "basic", "name": "topAction", "accessibility": "public", @@ -7793,24 +7875,24 @@ ], "doc": "top level method", "operation": { - "$id": "592", + "$id": "599", "name": "topAction", "resourceName": "SampleTypeSpec", "doc": "top level method", "accessibility": "public", "parameters": [ { - "$id": "593", + "$id": "600", "kind": "path", "name": "action", "serializedName": "action", "type": { - "$id": "594", + "$id": "601", "kind": "utcDateTime", "name": "utcDateTime", "encode": "rfc3339", "wireType": { - "$id": "595", + "$id": "602", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -7831,17 +7913,17 @@ "crossLanguageDefinitionId": "SampleTypeSpec.topAction.action", "methodParameterSegments": [ { - "$id": "596", + "$id": "603", "kind": "method", "name": "action", "serializedName": "action", "type": { - "$id": "597", + "$id": "604", "kind": "utcDateTime", "name": "utcDateTime", "encode": "rfc3339", "wireType": { - "$id": "598", + "$id": "605", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -7862,7 +7944,7 @@ ] }, { - "$id": "599", + "$id": "606", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -7878,7 +7960,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.topAction.accept", "methodParameterSegments": [ { - "$id": "600", + "$id": "607", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -7903,7 +7985,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -7924,15 +8006,15 @@ }, "parameters": [ { - "$ref": "596" + "$ref": "603" }, { - "$ref": "600" + "$ref": "607" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -7941,7 +8023,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.topAction" }, { - "$id": "601", + "$id": "608", "kind": "basic", "name": "topAction2", "accessibility": "public", @@ -7951,14 +8033,14 @@ ], "doc": "top level method2", "operation": { - "$id": "602", + "$id": "609", "name": "topAction2", "resourceName": "SampleTypeSpec", "doc": "top level method2", "accessibility": "public", "parameters": [ { - "$id": "603", + "$id": "610", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -7974,7 +8056,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.topAction2.accept", "methodParameterSegments": [ { - "$id": "604", + "$id": "611", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -7999,7 +8081,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -8020,12 +8102,12 @@ }, "parameters": [ { - "$ref": "604" + "$ref": "611" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -8034,7 +8116,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.topAction2" }, { - "$id": "605", + "$id": "612", "kind": "basic", "name": "patchAction", "accessibility": "public", @@ -8044,14 +8126,14 @@ ], "doc": "top level patch", "operation": { - "$id": "606", + "$id": "613", "name": "patchAction", "resourceName": "SampleTypeSpec", "doc": "top level patch", "accessibility": "public", "parameters": [ { - "$id": "607", + "$id": "614", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -8068,7 +8150,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.patchAction.contentType", "methodParameterSegments": [ { - "$id": "608", + "$id": "615", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -8088,7 +8170,7 @@ ] }, { - "$id": "609", + "$id": "616", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -8104,7 +8186,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.patchAction.accept", "methodParameterSegments": [ { - "$id": "610", + "$id": "617", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -8123,12 +8205,12 @@ ] }, { - "$id": "611", + "$id": "618", "kind": "body", "name": "body", "serializedName": "body", "type": { - "$ref": "234" + "$ref": "236" }, "isApiVersion": false, "contentTypes": [ @@ -8142,12 +8224,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.patchAction.body", "methodParameterSegments": [ { - "$id": "612", + "$id": "619", "kind": "method", "name": "body", "serializedName": "body", "type": { - "$ref": "234" + "$ref": "236" }, "location": "Body", "isApiVersion": false, @@ -8167,7 +8249,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -8191,18 +8273,18 @@ }, "parameters": [ { - "$ref": "612" + "$ref": "619" }, { - "$ref": "608" + "$ref": "615" }, { - "$ref": "610" + "$ref": "617" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -8211,7 +8293,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.patchAction" }, { - "$id": "613", + "$id": "620", "kind": "basic", "name": "anonymousBody", "accessibility": "public", @@ -8221,14 +8303,14 @@ ], "doc": "body parameter without body decorator", "operation": { - "$id": "614", + "$id": "621", "name": "anonymousBody", "resourceName": "SampleTypeSpec", "doc": "body parameter without body decorator", "accessibility": "public", "parameters": [ { - "$id": "615", + "$id": "622", "kind": "query", "name": "requiredQueryParam", "serializedName": "requiredQueryParam", @@ -8244,7 +8326,7 @@ "readOnly": false, "methodParameterSegments": [ { - "$id": "616", + "$id": "623", "kind": "method", "name": "requiredQueryParam", "serializedName": "requiredQueryParam", @@ -8263,7 +8345,7 @@ ] }, { - "$id": "617", + "$id": "624", "kind": "header", "name": "requiredHeader", "serializedName": "required-header", @@ -8279,7 +8361,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.anonymousBody.requiredHeader", "methodParameterSegments": [ { - "$id": "618", + "$id": "625", "kind": "method", "name": "requiredHeader", "serializedName": "required-header", @@ -8298,7 +8380,7 @@ ] }, { - "$id": "619", + "$id": "626", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -8315,7 +8397,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.anonymousBody.contentType", "methodParameterSegments": [ { - "$id": "620", + "$id": "627", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -8335,7 +8417,7 @@ ] }, { - "$id": "621", + "$id": "628", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -8351,7 +8433,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.anonymousBody.accept", "methodParameterSegments": [ { - "$id": "622", + "$id": "629", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -8370,12 +8452,12 @@ ] }, { - "$id": "623", + "$id": "630", "kind": "body", "name": "thing", "serializedName": "thing", "type": { - "$ref": "234" + "$ref": "236" }, "isApiVersion": false, "contentTypes": [ @@ -8389,13 +8471,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.anonymousBody.body", "methodParameterSegments": [ { - "$id": "624", + "$id": "631", "kind": "method", "name": "name", "serializedName": "name", "doc": "name of the Thing", "type": { - "$id": "625", + "$id": "632", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -8419,7 +8501,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -8443,16 +8525,16 @@ }, "parameters": [ { - "$ref": "624" + "$ref": "631" }, { - "$id": "626", + "$id": "633", "kind": "method", "name": "requiredUnion", "serializedName": "requiredUnion", "doc": "required Union", "type": { - "$ref": "238" + "$ref": "240" }, "location": "Body", "isApiVersion": false, @@ -8464,7 +8546,7 @@ "decorators": [] }, { - "$id": "627", + "$id": "634", "kind": "method", "name": "requiredLiteralString", "serializedName": "requiredLiteralString", @@ -8482,13 +8564,13 @@ "decorators": [] }, { - "$id": "628", + "$id": "635", "kind": "method", "name": "requiredNullableString", "serializedName": "requiredNullableString", "doc": "required nullable string", "type": { - "$ref": "245" + "$ref": "247" }, "location": "Body", "isApiVersion": false, @@ -8500,13 +8582,13 @@ "decorators": [] }, { - "$id": "629", + "$id": "636", "kind": "method", "name": "optionalNullableString", "serializedName": "optionalNullableString", "doc": "required optional string", "type": { - "$ref": "248" + "$ref": "250" }, "location": "Body", "isApiVersion": false, @@ -8518,7 +8600,7 @@ "decorators": [] }, { - "$id": "630", + "$id": "637", "kind": "method", "name": "requiredLiteralInt", "serializedName": "requiredLiteralInt", @@ -8536,7 +8618,7 @@ "decorators": [] }, { - "$id": "631", + "$id": "638", "kind": "method", "name": "requiredLiteralFloat", "serializedName": "requiredLiteralFloat", @@ -8554,7 +8636,7 @@ "decorators": [] }, { - "$id": "632", + "$id": "639", "kind": "method", "name": "requiredLiteralBool", "serializedName": "requiredLiteralBool", @@ -8572,18 +8654,18 @@ "decorators": [] }, { - "$id": "633", + "$id": "640", "kind": "method", "name": "optionalLiteralString", "serializedName": "optionalLiteralString", "doc": "optional literal string", "type": { - "$id": "634", + "$id": "641", "kind": "enum", "name": "ThingOptionalLiteralString", "crossLanguageDefinitionId": "", "valueType": { - "$id": "635", + "$id": "642", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -8591,12 +8673,12 @@ }, "values": [ { - "$id": "636", + "$id": "643", "kind": "enumvalue", "name": "reject", "value": "reject", "valueType": { - "$id": "637", + "$id": "644", "kind": "string", "decorators": [], "doc": "A sequence of textual characters.", @@ -8604,7 +8686,7 @@ "crossLanguageDefinitionId": "TypeSpec.string" }, "enumType": { - "$ref": "634" + "$ref": "641" }, "decorators": [] } @@ -8625,13 +8707,13 @@ "decorators": [] }, { - "$id": "638", + "$id": "645", "kind": "method", "name": "requiredNullableLiteralString", "serializedName": "requiredNullableLiteralString", "doc": "required nullable literal string", "type": { - "$ref": "255" + "$ref": "257" }, "location": "Body", "isApiVersion": false, @@ -8643,18 +8725,18 @@ "decorators": [] }, { - "$id": "639", + "$id": "646", "kind": "method", "name": "optionalLiteralInt", "serializedName": "optionalLiteralInt", "doc": "optional literal int", "type": { - "$id": "640", + "$id": "647", "kind": "enum", "name": "ThingOptionalLiteralInt", "crossLanguageDefinitionId": "", "valueType": { - "$id": "641", + "$id": "648", "kind": "int32", "name": "int32", "crossLanguageDefinitionId": "TypeSpec.int32", @@ -8662,12 +8744,12 @@ }, "values": [ { - "$id": "642", + "$id": "649", "kind": "enumvalue", "name": "456", "value": 456, "valueType": { - "$id": "643", + "$id": "650", "kind": "int32", "decorators": [], "doc": "A 32-bit integer. (`-2,147,483,648` to `2,147,483,647`)", @@ -8675,7 +8757,7 @@ "crossLanguageDefinitionId": "TypeSpec.int32" }, "enumType": { - "$ref": "640" + "$ref": "647" }, "decorators": [] } @@ -8696,18 +8778,18 @@ "decorators": [] }, { - "$id": "644", + "$id": "651", "kind": "method", "name": "optionalLiteralFloat", "serializedName": "optionalLiteralFloat", "doc": "optional literal float", "type": { - "$id": "645", + "$id": "652", "kind": "enum", "name": "ThingOptionalLiteralFloat", "crossLanguageDefinitionId": "", "valueType": { - "$id": "646", + "$id": "653", "kind": "float32", "name": "float32", "crossLanguageDefinitionId": "TypeSpec.float32", @@ -8715,12 +8797,12 @@ }, "values": [ { - "$id": "647", + "$id": "654", "kind": "enumvalue", "name": "4.56", "value": 4.56, "valueType": { - "$id": "648", + "$id": "655", "kind": "float32", "decorators": [], "doc": "A 32 bit floating point number. (`±1.5 x 10^−45` to `±3.4 x 10^38`)", @@ -8728,7 +8810,7 @@ "crossLanguageDefinitionId": "TypeSpec.float32" }, "enumType": { - "$ref": "645" + "$ref": "652" }, "decorators": [] } @@ -8749,7 +8831,7 @@ "decorators": [] }, { - "$id": "649", + "$id": "656", "kind": "method", "name": "optionalLiteralBool", "serializedName": "optionalLiteralBool", @@ -8767,13 +8849,13 @@ "decorators": [] }, { - "$id": "650", + "$id": "657", "kind": "method", "name": "requiredBadDescription", "serializedName": "requiredBadDescription", "doc": "description with xml <|endoftext|>", "type": { - "$id": "651", + "$id": "658", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -8789,13 +8871,13 @@ "decorators": [] }, { - "$id": "652", + "$id": "659", "kind": "method", "name": "optionalNullableList", "serializedName": "optionalNullableList", "doc": "optional nullable collection", "type": { - "$ref": "262" + "$ref": "264" }, "location": "Body", "isApiVersion": false, @@ -8807,13 +8889,13 @@ "decorators": [] }, { - "$id": "653", + "$id": "660", "kind": "method", "name": "requiredNullableList", "serializedName": "requiredNullableList", "doc": "required nullable collection", "type": { - "$ref": "266" + "$ref": "268" }, "location": "Body", "isApiVersion": false, @@ -8825,13 +8907,13 @@ "decorators": [] }, { - "$id": "654", + "$id": "661", "kind": "method", "name": "propertyWithSpecialDocs", "serializedName": "propertyWithSpecialDocs", "doc": "This tests:\n- Simple bullet point. This bullet point is going to be very long to test how text wrapping is handled in bullet points within documentation comments. It should properly indent the wrapped lines.\n- Another bullet point with **bold text**. This bullet point is also intentionally long to see how the formatting is preserved when the text wraps onto multiple lines in the generated documentation.\n- Third bullet point with *italic text*. Similar to the previous points, this one is extended to ensure that the wrapping and formatting are correctly applied in the output.\n- Complex bullet point with **bold** and *italic* combined. This bullet point combines both bold and italic formatting and is long enough to test the wrapping behavior in such cases.\n- **Bold bullet point**: A bullet point that is entirely bolded. This point is also made lengthy to observe how the bold formatting is maintained across wrapped lines.\n- *Italic bullet point*: A bullet point that is entirely italicized. This final point is extended to verify that italic formatting is correctly applied even when the text spans multiple lines.", "type": { - "$id": "655", + "$id": "662", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -8847,21 +8929,21 @@ "decorators": [] }, { - "$ref": "616" + "$ref": "623" }, { - "$ref": "618" + "$ref": "625" }, { - "$ref": "620" + "$ref": "627" }, { - "$ref": "622" + "$ref": "629" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -8870,7 +8952,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.anonymousBody" }, { - "$id": "656", + "$id": "663", "kind": "basic", "name": "friendlyModel", "accessibility": "public", @@ -8880,14 +8962,14 @@ ], "doc": "Model can have its friendly name", "operation": { - "$id": "657", + "$id": "664", "name": "friendlyModel", "resourceName": "SampleTypeSpec", "doc": "Model can have its friendly name", "accessibility": "public", "parameters": [ { - "$id": "658", + "$id": "665", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -8904,7 +8986,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.friendlyModel.contentType", "methodParameterSegments": [ { - "$id": "659", + "$id": "666", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -8924,7 +9006,7 @@ ] }, { - "$id": "660", + "$id": "667", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -8940,7 +9022,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.friendlyModel.accept", "methodParameterSegments": [ { - "$id": "661", + "$id": "668", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -8959,12 +9041,12 @@ ] }, { - "$id": "662", + "$id": "669", "kind": "body", "name": "friend", "serializedName": "friend", "type": { - "$ref": "323" + "$ref": "325" }, "isApiVersion": false, "contentTypes": [ @@ -8978,13 +9060,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.friendlyModel.body", "methodParameterSegments": [ { - "$id": "663", + "$id": "670", "kind": "method", "name": "name", "serializedName": "name", "doc": "name of the NotFriend", "type": { - "$id": "664", + "$id": "671", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9008,7 +9090,7 @@ 200 ], "bodyType": { - "$ref": "323" + "$ref": "325" }, "headers": [], "isErrorResponse": false, @@ -9032,18 +9114,18 @@ }, "parameters": [ { - "$ref": "663" + "$ref": "670" }, { - "$ref": "659" + "$ref": "666" }, { - "$ref": "661" + "$ref": "668" } ], "response": { "type": { - "$ref": "323" + "$ref": "325" } }, "isOverride": false, @@ -9052,7 +9134,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.friendlyModel" }, { - "$id": "665", + "$id": "672", "kind": "basic", "name": "addTimeHeader", "accessibility": "public", @@ -9061,23 +9143,23 @@ "2024-08-16-preview" ], "operation": { - "$id": "666", + "$id": "673", "name": "addTimeHeader", "resourceName": "SampleTypeSpec", "accessibility": "public", "parameters": [ { - "$id": "667", + "$id": "674", "kind": "header", "name": "repeatabilityFirstSent", "serializedName": "Repeatability-First-Sent", "type": { - "$id": "668", + "$id": "675", "kind": "utcDateTime", "name": "utcDateTime", "encode": "rfc7231", "wireType": { - "$id": "669", + "$id": "676", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9095,17 +9177,17 @@ "crossLanguageDefinitionId": "SampleTypeSpec.addTimeHeader.repeatabilityFirstSent", "methodParameterSegments": [ { - "$id": "670", + "$id": "677", "kind": "method", "name": "repeatabilityFirstSent", "serializedName": "Repeatability-First-Sent", "type": { - "$id": "671", + "$id": "678", "kind": "utcDateTime", "name": "utcDateTime", "encode": "rfc7231", "wireType": { - "$id": "672", + "$id": "679", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9147,7 +9229,7 @@ }, "parameters": [ { - "$ref": "670" + "$ref": "677" } ], "response": {}, @@ -9157,7 +9239,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.addTimeHeader" }, { - "$id": "673", + "$id": "680", "kind": "basic", "name": "projectedNameModel", "accessibility": "public", @@ -9167,14 +9249,14 @@ ], "doc": "Model can have its projected name", "operation": { - "$id": "674", + "$id": "681", "name": "projectedNameModel", "resourceName": "SampleTypeSpec", "doc": "Model can have its projected name", "accessibility": "public", "parameters": [ { - "$id": "675", + "$id": "682", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -9191,7 +9273,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.projectedNameModel.contentType", "methodParameterSegments": [ { - "$id": "676", + "$id": "683", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -9211,7 +9293,7 @@ ] }, { - "$id": "677", + "$id": "684", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -9227,7 +9309,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.projectedNameModel.accept", "methodParameterSegments": [ { - "$id": "678", + "$id": "685", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -9246,12 +9328,12 @@ ] }, { - "$id": "679", + "$id": "686", "kind": "body", "name": "renamedModel", "serializedName": "renamedModel", "type": { - "$ref": "326" + "$ref": "328" }, "isApiVersion": false, "contentTypes": [ @@ -9265,13 +9347,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.projectedNameModel.body", "methodParameterSegments": [ { - "$id": "680", + "$id": "687", "kind": "method", "name": "otherName", "serializedName": "otherName", "doc": "name of the ModelWithClientName", "type": { - "$id": "681", + "$id": "688", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9295,7 +9377,7 @@ 200 ], "bodyType": { - "$ref": "326" + "$ref": "328" }, "headers": [], "isErrorResponse": false, @@ -9319,18 +9401,18 @@ }, "parameters": [ { - "$ref": "680" + "$ref": "687" }, { - "$ref": "676" + "$ref": "683" }, { - "$ref": "678" + "$ref": "685" } ], "response": { "type": { - "$ref": "326" + "$ref": "328" } }, "isOverride": false, @@ -9339,7 +9421,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.projectedNameModel" }, { - "$id": "682", + "$id": "689", "kind": "basic", "name": "returnsAnonymousModel", "accessibility": "public", @@ -9349,14 +9431,14 @@ ], "doc": "return anonymous model", "operation": { - "$id": "683", + "$id": "690", "name": "returnsAnonymousModel", "resourceName": "SampleTypeSpec", "doc": "return anonymous model", "accessibility": "public", "parameters": [ { - "$id": "684", + "$id": "691", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -9372,7 +9454,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.returnsAnonymousModel.accept", "methodParameterSegments": [ { - "$id": "685", + "$id": "692", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -9397,7 +9479,7 @@ 200 ], "bodyType": { - "$ref": "329" + "$ref": "331" }, "headers": [], "isErrorResponse": false, @@ -9418,12 +9500,12 @@ }, "parameters": [ { - "$ref": "685" + "$ref": "692" } ], "response": { "type": { - "$ref": "329" + "$ref": "331" } }, "isOverride": false, @@ -9432,7 +9514,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.returnsAnonymousModel" }, { - "$id": "686", + "$id": "693", "kind": "basic", "name": "getUnknownValue", "accessibility": "public", @@ -9442,19 +9524,19 @@ ], "doc": "get extensible enum", "operation": { - "$id": "687", + "$id": "694", "name": "getUnknownValue", "resourceName": "SampleTypeSpec", "doc": "get extensible enum", "accessibility": "public", "parameters": [ { - "$id": "688", + "$id": "695", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$id": "689", + "$id": "696", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9469,12 +9551,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.getUnknownValue.accept", "methodParameterSegments": [ { - "$id": "690", + "$id": "697", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "689" + "$ref": "696" }, "location": "Header", "isApiVersion": false, @@ -9494,7 +9576,7 @@ 200 ], "bodyType": { - "$id": "691", + "$id": "698", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9526,12 +9608,12 @@ }, "parameters": [ { - "$ref": "690" + "$ref": "697" } ], "response": { "type": { - "$ref": "691" + "$ref": "698" } }, "isOverride": false, @@ -9540,7 +9622,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.getUnknownValue" }, { - "$id": "692", + "$id": "699", "kind": "basic", "name": "internalProtocol", "accessibility": "public", @@ -9550,14 +9632,14 @@ ], "doc": "When set protocol false and convenient true, then the protocol method should be internal", "operation": { - "$id": "693", + "$id": "700", "name": "internalProtocol", "resourceName": "SampleTypeSpec", "doc": "When set protocol false and convenient true, then the protocol method should be internal", "accessibility": "public", "parameters": [ { - "$id": "694", + "$id": "701", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -9574,7 +9656,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.internalProtocol.contentType", "methodParameterSegments": [ { - "$id": "695", + "$id": "702", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -9594,7 +9676,7 @@ ] }, { - "$id": "696", + "$id": "703", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -9610,7 +9692,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.internalProtocol.accept", "methodParameterSegments": [ { - "$id": "697", + "$id": "704", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -9629,12 +9711,12 @@ ] }, { - "$id": "698", + "$id": "705", "kind": "body", "name": "body", "serializedName": "body", "type": { - "$ref": "234" + "$ref": "236" }, "isApiVersion": false, "contentTypes": [ @@ -9648,12 +9730,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.internalProtocol.body", "methodParameterSegments": [ { - "$id": "699", + "$id": "706", "kind": "method", "name": "body", "serializedName": "body", "type": { - "$ref": "234" + "$ref": "236" }, "location": "Body", "isApiVersion": false, @@ -9673,7 +9755,7 @@ 200 ], "bodyType": { - "$ref": "234" + "$ref": "236" }, "headers": [], "isErrorResponse": false, @@ -9697,18 +9779,18 @@ }, "parameters": [ { - "$ref": "699" + "$ref": "706" }, { - "$ref": "695" + "$ref": "702" }, { - "$ref": "697" + "$ref": "704" } ], "response": { "type": { - "$ref": "234" + "$ref": "236" } }, "isOverride": false, @@ -9717,7 +9799,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.internalProtocol" }, { - "$id": "700", + "$id": "707", "kind": "basic", "name": "stillConvenient", "accessibility": "public", @@ -9727,7 +9809,7 @@ ], "doc": "When set protocol false and convenient true, the convenient method should be generated even it has the same signature as protocol one", "operation": { - "$id": "701", + "$id": "708", "name": "stillConvenient", "resourceName": "SampleTypeSpec", "doc": "When set protocol false and convenient true, the convenient method should be generated even it has the same signature as protocol one", @@ -9760,7 +9842,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.stillConvenient" }, { - "$id": "702", + "$id": "709", "kind": "basic", "name": "headAsBoolean", "accessibility": "public", @@ -9770,19 +9852,19 @@ ], "doc": "head as boolean.", "operation": { - "$id": "703", + "$id": "710", "name": "headAsBoolean", "resourceName": "SampleTypeSpec", "doc": "head as boolean.", "accessibility": "public", "parameters": [ { - "$id": "704", + "$id": "711", "kind": "path", "name": "id", "serializedName": "id", "type": { - "$id": "705", + "$id": "712", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9800,12 +9882,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.headAsBoolean.id", "methodParameterSegments": [ { - "$id": "706", + "$id": "713", "kind": "method", "name": "id", "serializedName": "id", "type": { - "$id": "707", + "$id": "714", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9844,7 +9926,7 @@ }, "parameters": [ { - "$ref": "706" + "$ref": "713" } ], "response": {}, @@ -9854,7 +9936,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.headAsBoolean" }, { - "$id": "708", + "$id": "715", "kind": "basic", "name": "WithApiVersion", "accessibility": "public", @@ -9864,19 +9946,19 @@ ], "doc": "Return hi again", "operation": { - "$id": "709", + "$id": "716", "name": "WithApiVersion", "resourceName": "SampleTypeSpec", "doc": "Return hi again", "accessibility": "public", "parameters": [ { - "$id": "710", + "$id": "717", "kind": "header", "name": "p1", "serializedName": "p1", "type": { - "$id": "711", + "$id": "718", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9891,12 +9973,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.WithApiVersion.p1", "methodParameterSegments": [ { - "$id": "712", + "$id": "719", "kind": "method", "name": "p1", "serializedName": "p1", "type": { - "$id": "713", + "$id": "720", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9914,12 +9996,12 @@ ] }, { - "$id": "714", + "$id": "721", "kind": "query", "name": "apiVersion", "serializedName": "apiVersion", "type": { - "$id": "715", + "$id": "722", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9929,7 +10011,7 @@ "explode": false, "defaultValue": { "type": { - "$id": "716", + "$id": "723", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string" @@ -9943,12 +10025,12 @@ "readOnly": false, "methodParameterSegments": [ { - "$id": "717", + "$id": "724", "kind": "method", "name": "apiVersion", "serializedName": "apiVersion", "type": { - "$id": "718", + "$id": "725", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -9958,7 +10040,7 @@ "isApiVersion": true, "defaultValue": { "type": { - "$id": "719", + "$id": "726", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string" @@ -9996,7 +10078,7 @@ }, "parameters": [ { - "$ref": "712" + "$ref": "719" } ], "response": {}, @@ -10006,7 +10088,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.WithApiVersion" }, { - "$id": "720", + "$id": "727", "kind": "paging", "name": "ListWithNextLink", "accessibility": "public", @@ -10016,14 +10098,14 @@ ], "doc": "List things with nextlink", "operation": { - "$id": "721", + "$id": "728", "name": "ListWithNextLink", "resourceName": "SampleTypeSpec", "doc": "List things with nextlink", "accessibility": "public", "parameters": [ { - "$id": "722", + "$id": "729", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -10039,7 +10121,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.ListWithNextLink.accept", "methodParameterSegments": [ { - "$id": "723", + "$id": "730", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -10064,7 +10146,7 @@ 200 ], "bodyType": { - "$ref": "330" + "$ref": "332" }, "headers": [], "isErrorResponse": false, @@ -10085,12 +10167,12 @@ }, "parameters": [ { - "$ref": "723" + "$ref": "730" } ], "response": { "type": { - "$ref": "332" + "$ref": "334" }, "resultSegments": [ "things" @@ -10114,7 +10196,7 @@ } }, { - "$id": "724", + "$id": "731", "kind": "paging", "name": "ListWithStringNextLink", "accessibility": "public", @@ -10124,14 +10206,14 @@ ], "doc": "List things with nextlink", "operation": { - "$id": "725", + "$id": "732", "name": "ListWithStringNextLink", "resourceName": "SampleTypeSpec", "doc": "List things with nextlink", "accessibility": "public", "parameters": [ { - "$id": "726", + "$id": "733", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -10147,7 +10229,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.ListWithStringNextLink.accept", "methodParameterSegments": [ { - "$id": "727", + "$id": "734", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -10172,7 +10254,7 @@ 200 ], "bodyType": { - "$ref": "335" + "$ref": "337" }, "headers": [], "isErrorResponse": false, @@ -10193,12 +10275,12 @@ }, "parameters": [ { - "$ref": "727" + "$ref": "734" } ], "response": { "type": { - "$ref": "332" + "$ref": "334" }, "resultSegments": [ "things" @@ -10222,7 +10304,7 @@ } }, { - "$id": "728", + "$id": "735", "kind": "paging", "name": "ListWithContinuationToken", "accessibility": "public", @@ -10232,19 +10314,19 @@ ], "doc": "List things with continuation token", "operation": { - "$id": "729", + "$id": "736", "name": "ListWithContinuationToken", "resourceName": "SampleTypeSpec", "doc": "List things with continuation token", "accessibility": "public", "parameters": [ { - "$id": "730", + "$id": "737", "kind": "query", "name": "token", "serializedName": "token", "type": { - "$id": "731", + "$id": "738", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10259,12 +10341,12 @@ "readOnly": false, "methodParameterSegments": [ { - "$id": "732", + "$id": "739", "kind": "method", "name": "token", "serializedName": "token", "type": { - "$id": "733", + "$id": "740", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10282,7 +10364,7 @@ ] }, { - "$id": "734", + "$id": "741", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -10298,7 +10380,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.ListWithContinuationToken.accept", "methodParameterSegments": [ { - "$id": "735", + "$id": "742", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -10323,7 +10405,7 @@ 200 ], "bodyType": { - "$ref": "339" + "$ref": "341" }, "headers": [], "isErrorResponse": false, @@ -10344,15 +10426,15 @@ }, "parameters": [ { - "$ref": "732" + "$ref": "739" }, { - "$ref": "735" + "$ref": "742" } ], "response": { "type": { - "$ref": "332" + "$ref": "334" }, "resultSegments": [ "things" @@ -10368,7 +10450,7 @@ ], "continuationToken": { "parameter": { - "$ref": "730" + "$ref": "737" }, "responseSegments": [ "nextToken" @@ -10379,7 +10461,7 @@ } }, { - "$id": "736", + "$id": "743", "kind": "paging", "name": "ListWithContinuationTokenHeaderResponse", "accessibility": "public", @@ -10389,19 +10471,19 @@ ], "doc": "List things with continuation token header response", "operation": { - "$id": "737", + "$id": "744", "name": "ListWithContinuationTokenHeaderResponse", "resourceName": "SampleTypeSpec", "doc": "List things with continuation token header response", "accessibility": "public", "parameters": [ { - "$id": "738", + "$id": "745", "kind": "query", "name": "token", "serializedName": "token", "type": { - "$id": "739", + "$id": "746", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10416,12 +10498,12 @@ "readOnly": false, "methodParameterSegments": [ { - "$id": "740", + "$id": "747", "kind": "method", "name": "token", "serializedName": "token", "type": { - "$id": "741", + "$id": "748", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10439,7 +10521,7 @@ ] }, { - "$id": "742", + "$id": "749", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -10455,7 +10537,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.ListWithContinuationTokenHeaderResponse.accept", "methodParameterSegments": [ { - "$id": "743", + "$id": "750", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -10480,14 +10562,14 @@ 200 ], "bodyType": { - "$ref": "343" + "$ref": "345" }, "headers": [ { "name": "nextToken", "nameInResponse": "next-token", "type": { - "$id": "744", + "$id": "751", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10513,15 +10595,15 @@ }, "parameters": [ { - "$ref": "740" + "$ref": "747" }, { - "$ref": "743" + "$ref": "750" } ], "response": { "type": { - "$ref": "332" + "$ref": "334" }, "resultSegments": [ "things" @@ -10537,7 +10619,7 @@ ], "continuationToken": { "parameter": { - "$ref": "738" + "$ref": "745" }, "responseSegments": [ "next-token" @@ -10548,7 +10630,7 @@ } }, { - "$id": "745", + "$id": "752", "kind": "paging", "name": "ListWithPaging", "accessibility": "public", @@ -10558,14 +10640,14 @@ ], "doc": "List things with paging", "operation": { - "$id": "746", + "$id": "753", "name": "ListWithPaging", "resourceName": "SampleTypeSpec", "doc": "List things with paging", "accessibility": "public", "parameters": [ { - "$id": "747", + "$id": "754", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -10581,7 +10663,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.ListWithPaging.accept", "methodParameterSegments": [ { - "$id": "748", + "$id": "755", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -10606,7 +10688,7 @@ 200 ], "bodyType": { - "$ref": "345" + "$ref": "347" }, "headers": [], "isErrorResponse": false, @@ -10627,12 +10709,12 @@ }, "parameters": [ { - "$ref": "748" + "$ref": "755" } ], "response": { "type": { - "$ref": "332" + "$ref": "334" }, "resultSegments": [ "items" @@ -10650,7 +10732,7 @@ } }, { - "$id": "749", + "$id": "756", "kind": "basic", "name": "EmbeddedParameters", "accessibility": "public", @@ -10660,20 +10742,20 @@ ], "doc": "An operation with embedded parameters within the body", "operation": { - "$id": "750", + "$id": "757", "name": "EmbeddedParameters", "resourceName": "SampleTypeSpec", "doc": "An operation with embedded parameters within the body", "accessibility": "public", "parameters": [ { - "$id": "751", + "$id": "758", "kind": "header", "name": "requiredHeader", "serializedName": "required-header", "doc": "required header parameter", "type": { - "$id": "752", + "$id": "759", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10688,12 +10770,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.ModelWithEmbeddedNonBodyParameters.requiredHeader", "methodParameterSegments": [ { - "$id": "753", + "$id": "760", "kind": "method", "name": "body", "serializedName": "body", "type": { - "$ref": "347" + "$ref": "349" }, "location": "Body", "isApiVersion": false, @@ -10705,13 +10787,13 @@ "decorators": [] }, { - "$id": "754", + "$id": "761", "kind": "method", "name": "requiredHeader", "serializedName": "requiredHeader", "doc": "required header parameter", "type": { - "$ref": "351" + "$ref": "353" }, "location": "", "isApiVersion": false, @@ -10725,13 +10807,13 @@ ] }, { - "$id": "755", + "$id": "762", "kind": "header", "name": "optionalHeader", "serializedName": "optional-header", "doc": "optional header parameter", "type": { - "$id": "756", + "$id": "763", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10746,16 +10828,16 @@ "crossLanguageDefinitionId": "SampleTypeSpec.ModelWithEmbeddedNonBodyParameters.optionalHeader", "methodParameterSegments": [ { - "$ref": "753" + "$ref": "760" }, { - "$id": "757", + "$id": "764", "kind": "method", "name": "optionalHeader", "serializedName": "optionalHeader", "doc": "optional header parameter", "type": { - "$ref": "353" + "$ref": "355" }, "location": "", "isApiVersion": false, @@ -10769,13 +10851,13 @@ ] }, { - "$id": "758", + "$id": "765", "kind": "query", "name": "requiredQuery", "serializedName": "requiredQuery", "doc": "required query parameter", "type": { - "$id": "759", + "$id": "766", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10790,16 +10872,16 @@ "readOnly": false, "methodParameterSegments": [ { - "$ref": "753" + "$ref": "760" }, { - "$id": "760", + "$id": "767", "kind": "method", "name": "requiredQuery", "serializedName": "requiredQuery", "doc": "required query parameter", "type": { - "$ref": "355" + "$ref": "357" }, "location": "", "isApiVersion": false, @@ -10813,13 +10895,13 @@ ] }, { - "$id": "761", + "$id": "768", "kind": "query", "name": "optionalQuery", "serializedName": "optionalQuery", "doc": "optional query parameter", "type": { - "$id": "762", + "$id": "769", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -10834,16 +10916,16 @@ "readOnly": false, "methodParameterSegments": [ { - "$ref": "753" + "$ref": "760" }, { - "$id": "763", + "$id": "770", "kind": "method", "name": "optionalQuery", "serializedName": "optionalQuery", "doc": "optional query parameter", "type": { - "$ref": "357" + "$ref": "359" }, "location": "", "isApiVersion": false, @@ -10857,7 +10939,7 @@ ] }, { - "$id": "764", + "$id": "771", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -10874,7 +10956,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.EmbeddedParameters.contentType", "methodParameterSegments": [ { - "$id": "765", + "$id": "772", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -10894,12 +10976,12 @@ ] }, { - "$id": "766", + "$id": "773", "kind": "body", "name": "body", "serializedName": "body", "type": { - "$ref": "347" + "$ref": "349" }, "isApiVersion": false, "contentTypes": [ @@ -10913,7 +10995,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.EmbeddedParameters.body", "methodParameterSegments": [ { - "$ref": "753" + "$ref": "760" } ] } @@ -10942,10 +11024,10 @@ }, "parameters": [ { - "$ref": "753" + "$ref": "760" }, { - "$ref": "765" + "$ref": "772" } ], "response": {}, @@ -10955,7 +11037,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.EmbeddedParameters" }, { - "$id": "767", + "$id": "774", "kind": "basic", "name": "DynamicModelOperation", "accessibility": "public", @@ -10965,14 +11047,14 @@ ], "doc": "An operation with a dynamic model", "operation": { - "$id": "768", + "$id": "775", "name": "DynamicModelOperation", "resourceName": "SampleTypeSpec", "doc": "An operation with a dynamic model", "accessibility": "public", "parameters": [ { - "$id": "769", + "$id": "776", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -10989,7 +11071,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.DynamicModelOperation.contentType", "methodParameterSegments": [ { - "$id": "770", + "$id": "777", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -11009,12 +11091,12 @@ ] }, { - "$id": "771", + "$id": "778", "kind": "body", "name": "body", "serializedName": "body", "type": { - "$ref": "358" + "$ref": "360" }, "isApiVersion": false, "contentTypes": [ @@ -11028,12 +11110,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.DynamicModelOperation.body", "methodParameterSegments": [ { - "$id": "772", + "$id": "779", "kind": "method", "name": "body", "serializedName": "body", "type": { - "$ref": "358" + "$ref": "360" }, "location": "Body", "isApiVersion": false, @@ -11071,10 +11153,10 @@ }, "parameters": [ { - "$ref": "772" + "$ref": "779" }, { - "$ref": "770" + "$ref": "777" } ], "response": {}, @@ -11084,7 +11166,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.DynamicModelOperation" }, { - "$id": "773", + "$id": "780", "kind": "basic", "name": "GetXmlAdvancedModel", "accessibility": "public", @@ -11094,14 +11176,14 @@ ], "doc": "Get an advanced XML model with various property types", "operation": { - "$id": "774", + "$id": "781", "name": "GetXmlAdvancedModel", "resourceName": "SampleTypeSpec", "doc": "Get an advanced XML model with various property types", "accessibility": "public", "parameters": [ { - "$id": "775", + "$id": "782", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -11117,7 +11199,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.GetXmlAdvancedModel.accept", "methodParameterSegments": [ { - "$id": "776", + "$id": "783", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -11142,7 +11224,7 @@ 200 ], "bodyType": { - "$ref": "396" + "$ref": "398" }, "headers": [ { @@ -11171,12 +11253,12 @@ }, "parameters": [ { - "$ref": "776" + "$ref": "783" } ], "response": { "type": { - "$ref": "396" + "$ref": "398" } }, "isOverride": false, @@ -11185,7 +11267,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.GetXmlAdvancedModel" }, { - "$id": "777", + "$id": "784", "kind": "basic", "name": "UpdateXmlAdvancedModel", "accessibility": "public", @@ -11195,14 +11277,14 @@ ], "doc": "Update an advanced XML model with various property types", "operation": { - "$id": "778", + "$id": "785", "name": "UpdateXmlAdvancedModel", "resourceName": "SampleTypeSpec", "doc": "Update an advanced XML model with various property types", "accessibility": "public", "parameters": [ { - "$id": "779", + "$id": "786", "kind": "header", "name": "contentType", "serializedName": "Content-Type", @@ -11218,7 +11300,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.UpdateXmlAdvancedModel.contentType", "methodParameterSegments": [ { - "$id": "780", + "$id": "787", "kind": "method", "name": "contentType", "serializedName": "Content-Type", @@ -11237,7 +11319,7 @@ ] }, { - "$id": "781", + "$id": "788", "kind": "header", "name": "accept", "serializedName": "Accept", @@ -11253,7 +11335,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.UpdateXmlAdvancedModel.accept", "methodParameterSegments": [ { - "$id": "782", + "$id": "789", "kind": "method", "name": "accept", "serializedName": "Accept", @@ -11272,12 +11354,12 @@ ] }, { - "$id": "783", + "$id": "790", "kind": "body", "name": "body", "serializedName": "body", "type": { - "$ref": "396" + "$ref": "398" }, "isApiVersion": false, "contentTypes": [ @@ -11291,12 +11373,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.UpdateXmlAdvancedModel.body", "methodParameterSegments": [ { - "$id": "784", + "$id": "791", "kind": "method", "name": "body", "serializedName": "body", "type": { - "$ref": "396" + "$ref": "398" }, "location": "Body", "isApiVersion": false, @@ -11316,7 +11398,7 @@ 200 ], "bodyType": { - "$ref": "396" + "$ref": "398" }, "headers": [ { @@ -11348,18 +11430,18 @@ }, "parameters": [ { - "$ref": "784" + "$ref": "791" }, { - "$ref": "780" + "$ref": "787" }, { - "$ref": "782" + "$ref": "789" } ], "response": { "type": { - "$ref": "396" + "$ref": "398" } }, "isOverride": false, @@ -11370,12 +11452,12 @@ ], "parameters": [ { - "$id": "785", + "$id": "792", "kind": "endpoint", "name": "sampleTypeSpecUrl", "serializedName": "sampleTypeSpecUrl", "type": { - "$id": "786", + "$id": "793", "kind": "url", "name": "endpoint", "crossLanguageDefinitionId": "TypeSpec.url" @@ -11390,7 +11472,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.sampleTypeSpecUrl" }, { - "$ref": "717" + "$ref": "724" } ], "initializedBy": 1, @@ -11402,13 +11484,197 @@ ], "children": [ { - "$id": "787", + "$id": "794", + "kind": "client", + "name": "Notebooks", + "namespace": "SampleTypeSpec", + "methods": [ + { + "$id": "795", + "kind": "basic", + "name": "getNotebook", + "accessibility": "public", + "apiVersions": [ + "2024-07-16-preview", + "2024-08-16-preview" + ], + "doc": "Get a notebook by name", + "operation": { + "$id": "796", + "name": "getNotebook", + "resourceName": "Notebooks", + "doc": "Get a notebook by name", + "accessibility": "public", + "parameters": [ + { + "$id": "797", + "kind": "path", + "name": "notebookName", + "serializedName": "notebookName", + "type": { + "$id": "798", + "kind": "string", + "name": "string", + "crossLanguageDefinitionId": "TypeSpec.string", + "decorators": [] + }, + "isApiVersion": false, + "explode": false, + "style": "simple", + "allowReserved": false, + "skipUrlEncoding": false, + "optional": false, + "scope": "Client", + "decorators": [], + "readOnly": false, + "crossLanguageDefinitionId": "SampleTypeSpec.Notebooks.getNotebook.notebookName", + "methodParameterSegments": [ + { + "$id": "799", + "kind": "method", + "name": "notebook", + "serializedName": "notebook", + "type": { + "$id": "800", + "kind": "string", + "name": "string", + "crossLanguageDefinitionId": "TypeSpec.string", + "decorators": [] + }, + "location": "", + "isApiVersion": false, + "optional": false, + "scope": "Method", + "crossLanguageDefinitionId": "SampleTypeSpec.NotebookClientParams.notebook", + "readOnly": false, + "access": "public", + "decorators": [], + "paramAlias": "notebookName" + } + ] + }, + { + "$id": "801", + "kind": "header", + "name": "accept", + "serializedName": "Accept", + "type": { + "$ref": "188" + }, + "isApiVersion": false, + "optional": false, + "isContentType": false, + "scope": "Constant", + "readOnly": false, + "decorators": [], + "crossLanguageDefinitionId": "SampleTypeSpec.Notebooks.getNotebook.accept", + "methodParameterSegments": [ + { + "$id": "802", + "kind": "method", + "name": "accept", + "serializedName": "Accept", + "type": { + "$ref": "188" + }, + "location": "Header", + "isApiVersion": false, + "optional": false, + "scope": "Constant", + "crossLanguageDefinitionId": "SampleTypeSpec.Notebooks.getNotebook.accept", + "readOnly": false, + "access": "public", + "decorators": [] + } + ] + } + ], + "responses": [ + { + "statusCodes": [ + 200 + ], + "bodyType": { + "$ref": "494" + }, + "headers": [], + "isErrorResponse": false, + "contentTypes": [ + "application/json" + ] + } + ], + "httpMethod": "GET", + "uri": "{sampleTypeSpecUrl}", + "path": "/notebooks/{notebookName}", + "bufferResponse": true, + "generateProtocolMethod": true, + "generateConvenienceMethod": true, + "crossLanguageDefinitionId": "SampleTypeSpec.Notebooks.getNotebook", + "decorators": [], + "namespace": "SampleTypeSpec" + }, + "parameters": [ + { + "$ref": "802" + } + ], + "response": { + "type": { + "$ref": "494" + } + }, + "isOverride": false, + "generateConvenient": true, + "generateProtocol": true, + "crossLanguageDefinitionId": "SampleTypeSpec.Notebooks.getNotebook" + } + ], + "parameters": [ + { + "$id": "803", + "kind": "endpoint", + "name": "sampleTypeSpecUrl", + "serializedName": "sampleTypeSpecUrl", + "type": { + "$id": "804", + "kind": "url", + "name": "endpoint", + "crossLanguageDefinitionId": "TypeSpec.url" + }, + "isApiVersion": false, + "optional": false, + "scope": "Client", + "isEndpoint": true, + "serverUrlTemplate": "{sampleTypeSpecUrl}", + "skipUrlEncoding": false, + "readOnly": false, + "crossLanguageDefinitionId": "SampleTypeSpec.Notebooks.sampleTypeSpecUrl" + }, + { + "$ref": "799" + } + ], + "initializedBy": 3, + "decorators": [], + "crossLanguageDefinitionId": "SampleTypeSpec.Notebooks", + "apiVersions": [ + "2024-07-16-preview", + "2024-08-16-preview" + ], + "parent": { + "$ref": "528" + }, + "isMultiServiceClient": false + }, + { + "$id": "805", "kind": "client", "name": "AnimalOperations", "namespace": "SampleTypeSpec", "methods": [ { - "$id": "788", + "$id": "806", "kind": "basic", "name": "updatePetAsAnimal", "accessibility": "public", @@ -11418,20 +11684,20 @@ ], "doc": "Update a pet as an animal", "operation": { - "$id": "789", + "$id": "807", "name": "updatePetAsAnimal", "resourceName": "AnimalOperations", "doc": "Update a pet as an animal", "accessibility": "public", "parameters": [ { - "$id": "790", + "$id": "808", "kind": "header", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "188" + "$ref": "190" }, "isApiVersion": false, "optional": false, @@ -11442,13 +11708,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.AnimalOperations.updatePetAsAnimal.contentType", "methodParameterSegments": [ { - "$id": "791", + "$id": "809", "kind": "method", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "188" + "$ref": "190" }, "location": "Header", "isApiVersion": false, @@ -11462,12 +11728,12 @@ ] }, { - "$id": "792", + "$id": "810", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "190" + "$ref": "192" }, "isApiVersion": false, "optional": false, @@ -11478,12 +11744,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.AnimalOperations.updatePetAsAnimal.accept", "methodParameterSegments": [ { - "$id": "793", + "$id": "811", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "190" + "$ref": "192" }, "location": "Header", "isApiVersion": false, @@ -11497,12 +11763,12 @@ ] }, { - "$id": "794", + "$id": "812", "kind": "body", "name": "animal", "serializedName": "animal", "type": { - "$ref": "492" + "$ref": "499" }, "isApiVersion": false, "contentTypes": [ @@ -11516,12 +11782,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.AnimalOperations.updatePetAsAnimal.animal", "methodParameterSegments": [ { - "$id": "795", + "$id": "813", "kind": "method", "name": "animal", "serializedName": "animal", "type": { - "$ref": "492" + "$ref": "499" }, "location": "Body", "isApiVersion": false, @@ -11541,7 +11807,7 @@ 200 ], "bodyType": { - "$ref": "492" + "$ref": "499" }, "headers": [], "isErrorResponse": false, @@ -11565,18 +11831,18 @@ }, "parameters": [ { - "$ref": "795" + "$ref": "813" }, { - "$ref": "791" + "$ref": "809" }, { - "$ref": "793" + "$ref": "811" } ], "response": { "type": { - "$ref": "492" + "$ref": "499" } }, "isOverride": false, @@ -11585,7 +11851,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.AnimalOperations.updatePetAsAnimal" }, { - "$id": "796", + "$id": "814", "kind": "basic", "name": "updateDogAsAnimal", "accessibility": "public", @@ -11595,20 +11861,20 @@ ], "doc": "Update a dog as an animal", "operation": { - "$id": "797", + "$id": "815", "name": "updateDogAsAnimal", "resourceName": "AnimalOperations", "doc": "Update a dog as an animal", "accessibility": "public", "parameters": [ { - "$id": "798", + "$id": "816", "kind": "header", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "192" + "$ref": "194" }, "isApiVersion": false, "optional": false, @@ -11619,13 +11885,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.AnimalOperations.updateDogAsAnimal.contentType", "methodParameterSegments": [ { - "$id": "799", + "$id": "817", "kind": "method", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "192" + "$ref": "194" }, "location": "Header", "isApiVersion": false, @@ -11639,12 +11905,12 @@ ] }, { - "$id": "800", + "$id": "818", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "194" + "$ref": "196" }, "isApiVersion": false, "optional": false, @@ -11655,12 +11921,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.AnimalOperations.updateDogAsAnimal.accept", "methodParameterSegments": [ { - "$id": "801", + "$id": "819", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "194" + "$ref": "196" }, "location": "Header", "isApiVersion": false, @@ -11674,12 +11940,12 @@ ] }, { - "$id": "802", + "$id": "820", "kind": "body", "name": "animal", "serializedName": "animal", "type": { - "$ref": "492" + "$ref": "499" }, "isApiVersion": false, "contentTypes": [ @@ -11693,12 +11959,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.AnimalOperations.updateDogAsAnimal.animal", "methodParameterSegments": [ { - "$id": "803", + "$id": "821", "kind": "method", "name": "animal", "serializedName": "animal", "type": { - "$ref": "492" + "$ref": "499" }, "location": "Body", "isApiVersion": false, @@ -11718,7 +11984,7 @@ 200 ], "bodyType": { - "$ref": "492" + "$ref": "499" }, "headers": [], "isErrorResponse": false, @@ -11742,18 +12008,18 @@ }, "parameters": [ { - "$ref": "803" + "$ref": "821" }, { - "$ref": "799" + "$ref": "817" }, { - "$ref": "801" + "$ref": "819" } ], "response": { "type": { - "$ref": "492" + "$ref": "499" } }, "isOverride": false, @@ -11764,12 +12030,12 @@ ], "parameters": [ { - "$id": "804", + "$id": "822", "kind": "endpoint", "name": "sampleTypeSpecUrl", "serializedName": "sampleTypeSpecUrl", "type": { - "$id": "805", + "$id": "823", "kind": "url", "name": "endpoint", "crossLanguageDefinitionId": "TypeSpec.url" @@ -11792,18 +12058,18 @@ "2024-08-16-preview" ], "parent": { - "$ref": "521" + "$ref": "528" }, "isMultiServiceClient": false }, { - "$id": "806", + "$id": "824", "kind": "client", "name": "PetOperations", "namespace": "SampleTypeSpec", "methods": [ { - "$id": "807", + "$id": "825", "kind": "basic", "name": "updatePetAsPet", "accessibility": "public", @@ -11813,20 +12079,20 @@ ], "doc": "Update a pet as a pet", "operation": { - "$id": "808", + "$id": "826", "name": "updatePetAsPet", "resourceName": "PetOperations", "doc": "Update a pet as a pet", "accessibility": "public", "parameters": [ { - "$id": "809", + "$id": "827", "kind": "header", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "196" + "$ref": "198" }, "isApiVersion": false, "optional": false, @@ -11837,13 +12103,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PetOperations.updatePetAsPet.contentType", "methodParameterSegments": [ { - "$id": "810", + "$id": "828", "kind": "method", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "196" + "$ref": "198" }, "location": "Header", "isApiVersion": false, @@ -11857,12 +12123,12 @@ ] }, { - "$id": "811", + "$id": "829", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "198" + "$ref": "200" }, "isApiVersion": false, "optional": false, @@ -11873,12 +12139,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PetOperations.updatePetAsPet.accept", "methodParameterSegments": [ { - "$id": "812", + "$id": "830", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "198" + "$ref": "200" }, "location": "Header", "isApiVersion": false, @@ -11892,12 +12158,12 @@ ] }, { - "$id": "813", + "$id": "831", "kind": "body", "name": "pet", "serializedName": "pet", "type": { - "$ref": "497" + "$ref": "504" }, "isApiVersion": false, "contentTypes": [ @@ -11911,12 +12177,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PetOperations.updatePetAsPet.pet", "methodParameterSegments": [ { - "$id": "814", + "$id": "832", "kind": "method", "name": "pet", "serializedName": "pet", "type": { - "$ref": "497" + "$ref": "504" }, "location": "Body", "isApiVersion": false, @@ -11936,7 +12202,7 @@ 200 ], "bodyType": { - "$ref": "497" + "$ref": "504" }, "headers": [], "isErrorResponse": false, @@ -11960,18 +12226,18 @@ }, "parameters": [ { - "$ref": "814" + "$ref": "832" }, { - "$ref": "810" + "$ref": "828" }, { - "$ref": "812" + "$ref": "830" } ], "response": { "type": { - "$ref": "497" + "$ref": "504" } }, "isOverride": false, @@ -11980,7 +12246,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PetOperations.updatePetAsPet" }, { - "$id": "815", + "$id": "833", "kind": "basic", "name": "updateDogAsPet", "accessibility": "public", @@ -11990,20 +12256,20 @@ ], "doc": "Update a dog as a pet", "operation": { - "$id": "816", + "$id": "834", "name": "updateDogAsPet", "resourceName": "PetOperations", "doc": "Update a dog as a pet", "accessibility": "public", "parameters": [ { - "$id": "817", + "$id": "835", "kind": "header", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "200" + "$ref": "202" }, "isApiVersion": false, "optional": false, @@ -12014,13 +12280,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PetOperations.updateDogAsPet.contentType", "methodParameterSegments": [ { - "$id": "818", + "$id": "836", "kind": "method", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "200" + "$ref": "202" }, "location": "Header", "isApiVersion": false, @@ -12034,12 +12300,12 @@ ] }, { - "$id": "819", + "$id": "837", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "202" + "$ref": "204" }, "isApiVersion": false, "optional": false, @@ -12050,12 +12316,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PetOperations.updateDogAsPet.accept", "methodParameterSegments": [ { - "$id": "820", + "$id": "838", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "202" + "$ref": "204" }, "location": "Header", "isApiVersion": false, @@ -12069,12 +12335,12 @@ ] }, { - "$id": "821", + "$id": "839", "kind": "body", "name": "pet", "serializedName": "pet", "type": { - "$ref": "497" + "$ref": "504" }, "isApiVersion": false, "contentTypes": [ @@ -12088,12 +12354,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PetOperations.updateDogAsPet.pet", "methodParameterSegments": [ { - "$id": "822", + "$id": "840", "kind": "method", "name": "pet", "serializedName": "pet", "type": { - "$ref": "497" + "$ref": "504" }, "location": "Body", "isApiVersion": false, @@ -12113,7 +12379,7 @@ 200 ], "bodyType": { - "$ref": "497" + "$ref": "504" }, "headers": [], "isErrorResponse": false, @@ -12137,18 +12403,18 @@ }, "parameters": [ { - "$ref": "822" + "$ref": "840" }, { - "$ref": "818" + "$ref": "836" }, { - "$ref": "820" + "$ref": "838" } ], "response": { "type": { - "$ref": "497" + "$ref": "504" } }, "isOverride": false, @@ -12159,12 +12425,12 @@ ], "parameters": [ { - "$id": "823", + "$id": "841", "kind": "endpoint", "name": "sampleTypeSpecUrl", "serializedName": "sampleTypeSpecUrl", "type": { - "$id": "824", + "$id": "842", "kind": "url", "name": "endpoint", "crossLanguageDefinitionId": "TypeSpec.url" @@ -12187,18 +12453,18 @@ "2024-08-16-preview" ], "parent": { - "$ref": "521" + "$ref": "528" }, "isMultiServiceClient": false }, { - "$id": "825", + "$id": "843", "kind": "client", "name": "DogOperations", "namespace": "SampleTypeSpec", "methods": [ { - "$id": "826", + "$id": "844", "kind": "basic", "name": "updateDogAsDog", "accessibility": "public", @@ -12208,20 +12474,20 @@ ], "doc": "Update a dog as a dog", "operation": { - "$id": "827", + "$id": "845", "name": "updateDogAsDog", "resourceName": "DogOperations", "doc": "Update a dog as a dog", "accessibility": "public", "parameters": [ { - "$id": "828", + "$id": "846", "kind": "header", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "204" + "$ref": "206" }, "isApiVersion": false, "optional": false, @@ -12232,13 +12498,13 @@ "crossLanguageDefinitionId": "SampleTypeSpec.DogOperations.updateDogAsDog.contentType", "methodParameterSegments": [ { - "$id": "829", + "$id": "847", "kind": "method", "name": "contentType", "serializedName": "Content-Type", "doc": "Body parameter's content type. Known values are application/json", "type": { - "$ref": "204" + "$ref": "206" }, "location": "Header", "isApiVersion": false, @@ -12252,12 +12518,12 @@ ] }, { - "$id": "830", + "$id": "848", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "206" + "$ref": "208" }, "isApiVersion": false, "optional": false, @@ -12268,12 +12534,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.DogOperations.updateDogAsDog.accept", "methodParameterSegments": [ { - "$id": "831", + "$id": "849", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "206" + "$ref": "208" }, "location": "Header", "isApiVersion": false, @@ -12287,12 +12553,12 @@ ] }, { - "$id": "832", + "$id": "850", "kind": "body", "name": "dog", "serializedName": "dog", "type": { - "$ref": "501" + "$ref": "508" }, "isApiVersion": false, "contentTypes": [ @@ -12306,12 +12572,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.DogOperations.updateDogAsDog.dog", "methodParameterSegments": [ { - "$id": "833", + "$id": "851", "kind": "method", "name": "dog", "serializedName": "dog", "type": { - "$ref": "501" + "$ref": "508" }, "location": "Body", "isApiVersion": false, @@ -12331,7 +12597,7 @@ 200 ], "bodyType": { - "$ref": "501" + "$ref": "508" }, "headers": [], "isErrorResponse": false, @@ -12355,18 +12621,18 @@ }, "parameters": [ { - "$ref": "833" + "$ref": "851" }, { - "$ref": "829" + "$ref": "847" }, { - "$ref": "831" + "$ref": "849" } ], "response": { "type": { - "$ref": "501" + "$ref": "508" } }, "isOverride": false, @@ -12377,12 +12643,12 @@ ], "parameters": [ { - "$id": "834", + "$id": "852", "kind": "endpoint", "name": "sampleTypeSpecUrl", "serializedName": "sampleTypeSpecUrl", "type": { - "$id": "835", + "$id": "853", "kind": "url", "name": "endpoint", "crossLanguageDefinitionId": "TypeSpec.url" @@ -12405,18 +12671,18 @@ "2024-08-16-preview" ], "parent": { - "$ref": "521" + "$ref": "528" }, "isMultiServiceClient": false }, { - "$id": "836", + "$id": "854", "kind": "client", "name": "PlantOperations", "namespace": "SampleTypeSpec", "methods": [ { - "$id": "837", + "$id": "855", "kind": "basic", "name": "getTree", "accessibility": "public", @@ -12426,19 +12692,19 @@ ], "doc": "Get a tree as a plant", "operation": { - "$id": "838", + "$id": "856", "name": "getTree", "resourceName": "PlantOperations", "doc": "Get a tree as a plant", "accessibility": "public", "parameters": [ { - "$id": "839", + "$id": "857", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "208" + "$ref": "210" }, "isApiVersion": false, "optional": false, @@ -12449,12 +12715,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.getTree.accept", "methodParameterSegments": [ { - "$id": "840", + "$id": "858", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "208" + "$ref": "210" }, "location": "Header", "isApiVersion": false, @@ -12474,14 +12740,14 @@ 200 ], "bodyType": { - "$ref": "505" + "$ref": "512" }, "headers": [ { "name": "contentType", "nameInResponse": "content-type", "type": { - "$ref": "210" + "$ref": "212" } } ], @@ -12503,12 +12769,12 @@ }, "parameters": [ { - "$ref": "840" + "$ref": "858" } ], "response": { "type": { - "$ref": "505" + "$ref": "512" } }, "isOverride": false, @@ -12517,7 +12783,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.getTree" }, { - "$id": "841", + "$id": "859", "kind": "basic", "name": "getTreeAsJson", "accessibility": "public", @@ -12527,19 +12793,19 @@ ], "doc": "Get a tree as a plant", "operation": { - "$id": "842", + "$id": "860", "name": "getTreeAsJson", "resourceName": "PlantOperations", "doc": "Get a tree as a plant", "accessibility": "public", "parameters": [ { - "$id": "843", + "$id": "861", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "212" + "$ref": "214" }, "isApiVersion": false, "optional": false, @@ -12550,12 +12816,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.getTreeAsJson.accept", "methodParameterSegments": [ { - "$id": "844", + "$id": "862", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "212" + "$ref": "214" }, "location": "Header", "isApiVersion": false, @@ -12575,14 +12841,14 @@ 200 ], "bodyType": { - "$ref": "505" + "$ref": "512" }, "headers": [ { "name": "contentType", "nameInResponse": "content-type", "type": { - "$ref": "214" + "$ref": "216" } } ], @@ -12604,12 +12870,12 @@ }, "parameters": [ { - "$ref": "844" + "$ref": "862" } ], "response": { "type": { - "$ref": "505" + "$ref": "512" } }, "isOverride": false, @@ -12618,7 +12884,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.getTreeAsJson" }, { - "$id": "845", + "$id": "863", "kind": "basic", "name": "updateTree", "accessibility": "public", @@ -12628,19 +12894,19 @@ ], "doc": "Update a tree as a plant", "operation": { - "$id": "846", + "$id": "864", "name": "updateTree", "resourceName": "PlantOperations", "doc": "Update a tree as a plant", "accessibility": "public", "parameters": [ { - "$id": "847", + "$id": "865", "kind": "header", "name": "contentType", "serializedName": "Content-Type", "type": { - "$ref": "216" + "$ref": "218" }, "isApiVersion": false, "optional": false, @@ -12651,12 +12917,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.updateTree.contentType", "methodParameterSegments": [ { - "$id": "848", + "$id": "866", "kind": "method", "name": "contentType", "serializedName": "Content-Type", "type": { - "$ref": "216" + "$ref": "218" }, "location": "Header", "isApiVersion": false, @@ -12670,12 +12936,12 @@ ] }, { - "$id": "849", + "$id": "867", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "220" + "$ref": "222" }, "isApiVersion": false, "optional": false, @@ -12686,12 +12952,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.updateTree.accept", "methodParameterSegments": [ { - "$id": "850", + "$id": "868", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "220" + "$ref": "222" }, "location": "Header", "isApiVersion": false, @@ -12705,12 +12971,12 @@ ] }, { - "$id": "851", + "$id": "869", "kind": "body", "name": "tree", "serializedName": "tree", "type": { - "$ref": "505" + "$ref": "512" }, "isApiVersion": false, "contentTypes": [ @@ -12724,12 +12990,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.updateTree.tree", "methodParameterSegments": [ { - "$id": "852", + "$id": "870", "kind": "method", "name": "tree", "serializedName": "tree", "type": { - "$ref": "505" + "$ref": "512" }, "location": "Body", "isApiVersion": false, @@ -12749,14 +13015,14 @@ 200 ], "bodyType": { - "$ref": "505" + "$ref": "512" }, "headers": [ { "name": "contentType", "nameInResponse": "content-type", "type": { - "$ref": "222" + "$ref": "224" } } ], @@ -12781,18 +13047,18 @@ }, "parameters": [ { - "$ref": "852" + "$ref": "870" }, { - "$ref": "848" + "$ref": "866" }, { - "$ref": "850" + "$ref": "868" } ], "response": { "type": { - "$ref": "505" + "$ref": "512" } }, "isOverride": false, @@ -12801,7 +13067,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.updateTree" }, { - "$id": "853", + "$id": "871", "kind": "basic", "name": "updateTreeAsJson", "accessibility": "public", @@ -12811,19 +13077,19 @@ ], "doc": "Update a tree as a plant", "operation": { - "$id": "854", + "$id": "872", "name": "updateTreeAsJson", "resourceName": "PlantOperations", "doc": "Update a tree as a plant", "accessibility": "public", "parameters": [ { - "$id": "855", + "$id": "873", "kind": "header", "name": "contentType", "serializedName": "Content-Type", "type": { - "$ref": "224" + "$ref": "226" }, "isApiVersion": false, "optional": false, @@ -12834,12 +13100,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.updateTreeAsJson.contentType", "methodParameterSegments": [ { - "$id": "856", + "$id": "874", "kind": "method", "name": "contentType", "serializedName": "Content-Type", "type": { - "$ref": "224" + "$ref": "226" }, "location": "Header", "isApiVersion": false, @@ -12853,12 +13119,12 @@ ] }, { - "$id": "857", + "$id": "875", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "228" + "$ref": "230" }, "isApiVersion": false, "optional": false, @@ -12869,12 +13135,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.updateTreeAsJson.accept", "methodParameterSegments": [ { - "$id": "858", + "$id": "876", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "228" + "$ref": "230" }, "location": "Header", "isApiVersion": false, @@ -12888,12 +13154,12 @@ ] }, { - "$id": "859", + "$id": "877", "kind": "body", "name": "tree", "serializedName": "tree", "type": { - "$ref": "505" + "$ref": "512" }, "isApiVersion": false, "contentTypes": [ @@ -12907,12 +13173,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.PlantOperations.updateTreeAsJson.tree", "methodParameterSegments": [ { - "$id": "860", + "$id": "878", "kind": "method", "name": "tree", "serializedName": "tree", "type": { - "$ref": "505" + "$ref": "512" }, "location": "Body", "isApiVersion": false, @@ -12932,14 +13198,14 @@ 200 ], "bodyType": { - "$ref": "505" + "$ref": "512" }, "headers": [ { "name": "contentType", "nameInResponse": "content-type", "type": { - "$ref": "230" + "$ref": "232" } } ], @@ -12964,18 +13230,18 @@ }, "parameters": [ { - "$ref": "860" + "$ref": "878" }, { - "$ref": "856" + "$ref": "874" }, { - "$ref": "858" + "$ref": "876" } ], "response": { "type": { - "$ref": "505" + "$ref": "512" } }, "isOverride": false, @@ -12986,12 +13252,12 @@ ], "parameters": [ { - "$id": "861", + "$id": "879", "kind": "endpoint", "name": "sampleTypeSpecUrl", "serializedName": "sampleTypeSpecUrl", "type": { - "$id": "862", + "$id": "880", "kind": "url", "name": "endpoint", "crossLanguageDefinitionId": "TypeSpec.url" @@ -13014,18 +13280,18 @@ "2024-08-16-preview" ], "parent": { - "$ref": "521" + "$ref": "528" }, "isMultiServiceClient": false }, { - "$id": "863", + "$id": "881", "kind": "client", "name": "Metrics", "namespace": "SampleTypeSpec", "methods": [ { - "$id": "864", + "$id": "882", "kind": "basic", "name": "getWidgetMetrics", "accessibility": "public", @@ -13035,19 +13301,19 @@ ], "doc": "Get Widget metrics for given day of week", "operation": { - "$id": "865", + "$id": "883", "name": "getWidgetMetrics", "resourceName": "Metrics", "doc": "Get Widget metrics for given day of week", "accessibility": "public", "parameters": [ { - "$id": "866", + "$id": "884", "kind": "path", "name": "metricsNamespace", "serializedName": "metricsNamespace", "type": { - "$id": "867", + "$id": "885", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -13065,12 +13331,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.Metrics.getWidgetMetrics.metricsNamespace", "methodParameterSegments": [ { - "$id": "868", + "$id": "886", "kind": "method", "name": "metricsNamespace", "serializedName": "metricsNamespace", "type": { - "$id": "869", + "$id": "887", "kind": "string", "name": "string", "crossLanguageDefinitionId": "TypeSpec.string", @@ -13088,7 +13354,7 @@ ] }, { - "$id": "870", + "$id": "888", "kind": "path", "name": "day", "serializedName": "day", @@ -13107,7 +13373,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.Metrics.getWidgetMetrics.day", "methodParameterSegments": [ { - "$id": "871", + "$id": "889", "kind": "method", "name": "day", "serializedName": "day", @@ -13126,12 +13392,12 @@ ] }, { - "$id": "872", + "$id": "890", "kind": "header", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "232" + "$ref": "234" }, "isApiVersion": false, "optional": false, @@ -13142,12 +13408,12 @@ "crossLanguageDefinitionId": "SampleTypeSpec.Metrics.getWidgetMetrics.accept", "methodParameterSegments": [ { - "$id": "873", + "$id": "891", "kind": "method", "name": "accept", "serializedName": "Accept", "type": { - "$ref": "232" + "$ref": "234" }, "location": "Header", "isApiVersion": false, @@ -13167,7 +13433,7 @@ 200 ], "bodyType": { - "$ref": "516" + "$ref": "523" }, "headers": [], "isErrorResponse": false, @@ -13188,15 +13454,15 @@ }, "parameters": [ { - "$ref": "871" + "$ref": "889" }, { - "$ref": "873" + "$ref": "891" } ], "response": { "type": { - "$ref": "516" + "$ref": "523" } }, "isOverride": false, @@ -13207,12 +13473,12 @@ ], "parameters": [ { - "$id": "874", + "$id": "892", "kind": "endpoint", "name": "sampleTypeSpecUrl", "serializedName": "sampleTypeSpecUrl", "type": { - "$id": "875", + "$id": "893", "kind": "url", "name": "endpoint", "crossLanguageDefinitionId": "TypeSpec.url" @@ -13227,7 +13493,7 @@ "crossLanguageDefinitionId": "SampleTypeSpec.Metrics.sampleTypeSpecUrl" }, { - "$ref": "868" + "$ref": "886" } ], "initializedBy": 3, @@ -13238,7 +13504,7 @@ "2024-08-16-preview" ], "parent": { - "$ref": "521" + "$ref": "528" }, "isMultiServiceClient": false }