@aws/nx-plugin 1.0.0-rc.9 → 1.0.0-rc.90

package/src/open-api/utils/codegen-data.js

@@ -1,770 +1,590 @@
-"use strict";
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOpenApiCodeGenData = void 0;
-const tslib_1 = require("tslib");
-const gen = tslib_1.__importStar(require("@hey-api/openapi-ts"));
-const lodash_camelcase_1 = tslib_1.__importDefault(require("lodash.camelcase"));
-const lodash_orderby_1 = tslib_1.__importDefault(require("lodash.orderby"));
-const lodash_trim_1 = tslib_1.__importDefault(require("lodash.trim"));
-const lodash_uniqby_1 = tslib_1.__importDefault(require("lodash.uniqby"));
-const names_1 = require("../../utils/names");
-const languages_1 = require("./codegen-data/languages");
-const types_1 = require("./codegen-data/types");
-const normalise_1 = require("./normalise");
-const refs_1 = require("./refs");
+ */ import orderBy from "lodash.orderby";
+import trim from "lodash.trim";
+import uniqBy from "lodash.uniqby";
+import { camelCase, pascalCase, snakeCase, toClassName, upperFirst } from "../../utils/names.js";
+import { toPythonName, toPythonType, toTypeScriptModelName, toTypeScriptName, toTypeScriptType } from "./codegen-data/languages.js";
+import { COLLECTION_TYPES, COMPOSED_SCHEMA_TYPES, createModel, DEFAULT_SERVICE_NAME, indexModelsByName, PRIMITIVE_TYPES, STREAMING_CONTENT_TYPES, VENDOR_EXTENSIONS } from "./codegen-data/types.js";
+import { normaliseOpenApiSpecForCodeGen } from "./normalise.js";
+import { buildClientData, buildInlineModel, compositeMemberSchemas, getSpecOperation, getSpecParametersByKey, getSpecPathParameters, linkModel, specParameterKey } from "./parser.js";
+import { isRef, resolveIfRef, splitRef } from "./refs.js";
 /**
- * Builds a data structure from an OpenAPI spec which can be used to generate code
- */
-const buildOpenApiCodeGenData = async (inSpec) => {
-    // Ensure spec is ready for codegen
-    const spec = (0, normalise_1.normaliseOpenApiSpecForCodeGen)(inSpec);
-    // Build the initial data, which we will augment with additional information
-    const data = await buildInitialCodeGenData(spec);
-    // Ensure the models have their links set when they are arrays/dictionaries
-    ensureModelLinks(spec, data);
-    // Mutate the models with enough data to render composite models in the templates
-    ensureCompositeModels(data);
-    const modelsByName = Object.fromEntries(data.models.map((m) => [m.name, m]));
-    // Augment operations with additional data
-    for (const service of data.services) {
-        // Keep track of the request and response models we need the service (ie api client) to import
-        const requestModelImports = [];
-        const responseModelImports = [];
-        for (const op of service.operations) {
-            // Extract the operation back from the openapi spec
-            const specOp = spec?.paths?.[op.path]?.[op.method.toLowerCase()];
-            op.name = op.id ?? op.name;
-            op.uniqueName = op.name;
-            if (specOp['x-aws-nx-deduplicated-op-id']) {
-                op.uniqueName = specOp['x-aws-nx-deduplicated-op-id'];
-            }
-            if (specOp['x-aws-nx-deduplicated-dot-op-id']) {
-                op.dotNotationName = specOp['x-aws-nx-deduplicated-dot-op-id'];
-            }
-            // Add vendor extensions
-            op.vendorExtensions = op.vendorExtensions ?? {};
-            copyVendorExtensions(specOp ?? {}, op.vendorExtensions);
-            if (specOp) {
-                // Add all response models to the response model imports
-                responseModelImports.push(...op.responses
-                    .filter((r) => r.export === 'reference')
-                    .map((r) => r.type));
-                for (const response of op.responses) {
-                    // Validate that the response is not a composite schema of primitives since we cannot determine what
-                    // the type of the response is (it all comes back as text!)
-                    if (response.export === 'reference' &&
-                        types_1.COMPOSED_SCHEMA_TYPES.has(modelsByName[response.type]?.export)) {
-                        const composedPrimitives = modelsByName[response.type].composedPrimitives.filter((p) => !['array', 'dictionary'].includes(p.export));
-                        if (composedPrimitives.length > 0) {
-                            throw new Error(`Operation "${op.method} ${op.path}" returns a composite schema of primitives with ${(0, lodash_camelcase_1.default)(modelsByName[response.type].export)}, which cannot be distinguished at runtime`);
-                        }
-                    }
-                    const matchingSpecResponse = specOp.responses[`${response.code}`];
-                    // @hey-api/openapi-ts does not distinguish between returning an "any" or returning "void"
-                    // We distinguish this by looking back at each response in the spec, and checking whether it
-                    // has content
-                    if (matchingSpecResponse) {
-                        // Resolve the ref if necessary
-                        const specResponse = (0, refs_1.resolveIfRef)(spec, matchingSpecResponse);
-                        // When there's no content, we set the type to 'void'
-                        if (!specResponse.content) {
-                            response.type = 'void';
-                        }
-                        else {
-                            // Add the response media types
-                            const mediaTypes = Object.keys(specResponse.content);
-                            response.mediaTypes = mediaTypes;
-                            for (const mediaType of mediaTypes) {
-                                const responseContent = specResponse.content?.[mediaType] ??
-                                    Object.values(specResponse.content)[0];
-                                const responseSchema = (0, refs_1.resolveIfRef)(spec, responseContent.schema);
-                                if (responseSchema) {
-                                    await mutateWithOpenapiSchemaProperties(spec, response, responseSchema, modelsByName);
-                                }
-                                if (types_1.STREAMING_CONTENT_TYPES.has(mediaType) &&
-                                    'itemSchema' in responseContent) {
-                                    response.isJsonlStreaming = true;
-                                    response.itemSchemaModel =
-                                        await buildOrReferenceModel(spec, modelsByName, responseContent.itemSchema);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            const specParametersByName = Object.fromEntries((specOp?.parameters ?? []).map((p) => {
-                const param = (0, refs_1.resolveIfRef)(spec, p);
-                return [param.name, param];
-            }));
-            // Loop through the parameters
-            for (const parameter of op.parameters) {
-                // Add the request model import
-                if (parameter.export === 'reference') {
-                    requestModelImports.push(parameter.type);
-                }
-                const specParameter = specParametersByName[parameter.prop];
-                const specParameterSchema = (0, refs_1.resolveIfRef)(spec, specParameter?.schema);
-                if (specParameterSchema) {
-                    await mutateWithOpenapiSchemaProperties(spec, parameter, specParameterSchema, modelsByName);
-                }
-                if (parameter.in === 'body' || parameter.in === 'formData') {
-                    // Parameter name for the body is 'body'.  `formData` bodies arrive
-                    // under a synthetic `formData` param (hey-api convention) that's
-                    // logically the body — normalise both shapes to `in === 'body'`
-                    // so every downstream consumer (including ts-client's request-
-                    // type composition) sees a single body kind.
-                    parameter.name = 'body';
-                    parameter.prop = 'body';
-                    parameter.in = 'body';
-                    // The request body is not in the "parameters" section of the openapi spec so we won't have added the schema
-                    // properties above. Find it here.
-                    const specBody = (0, refs_1.resolveIfRef)(spec, specOp?.requestBody);
-                    if (specBody) {
-                        if (parameter.mediaType) {
-                            const bodySchema = (0, refs_1.resolveIfRef)(spec, specBody.content?.[parameter.mediaType]?.schema);
-                            if (bodySchema) {
-                                await mutateWithOpenapiSchemaProperties(spec, parameter, bodySchema, modelsByName);
-                            }
-                        }
-                        // Track all the media types that can be accepted in the request body
-                        parameter.mediaTypes = Object.keys(specBody.content);
-                    }
-                }
-                else if (['query', 'header'].includes(parameter.in) &&
-                    specParameter) {
-                    // Translate style/explode to OpenAPI v2 style collectionFormat
-                    // https://spec.openapis.org/oas/v3.0.3.html#style-values
-                    const style = specParameter.style ??
-                        (parameter.in === 'query' ? 'form' : 'simple');
-                    const explode = specParameter.explode ?? style === 'form';
-                    if (parameter.in === 'query') {
-                        parameter.collectionFormat = explode
-                            ? 'multi'
-                            : ({
-                                spaceDelimited: 'ssv',
-                                pipeDelimited: 'tsv',
-                                simple: 'csv',
-                                form: 'csv',
-                            }[style] ?? 'multi');
-                    }
-                    else {
-                        // parameter.in === "header"
-                        parameter.collectionFormat = explode ? 'multi' : 'csv';
-                    }
-                }
-                mutateModelWithAdditionalTypes(parameter);
-            }
-            // Add language types to response models
-            (op.responses ?? []).forEach(mutateModelWithAdditionalTypes);
-            // Sort responses by code
-            op.responses = (0, lodash_orderby_1.default)(op.responses, (r) => r.code);
-            // Result is the lowest successful response, otherwise is the 2XX or default response
-            const result = op.responses.find((r) => typeof r.code === 'number' && r.code >= 200 && r.code < 300);
-            op.result =
-                result ??
-                    op.responses.find((r) => r.code === '2XX' || r.code === 'default');
-            // Add variants of operation name
-            op.operationIdPascalCase = (0, names_1.pascalCase)(op.uniqueName);
-            op.operationIdKebabCase = (0, names_1.kebabCase)(op.uniqueName);
-            op.operationIdSnakeCase = (0, languages_1.toPythonName)('operation', op.uniqueName);
-            // Add request type name (after operationIdPascalCase is set)
-            if (op.parameters && op.parameters.length > 0) {
-                const baseRequestTypeName = `${op.operationIdPascalCase}Request`;
-                const hasConflict = !!spec.components?.schemas?.[baseRequestTypeName];
-                if (hasConflict) {
-                    // Use OperationRequest suffix when there's a conflict
-                    op.requestTypeName =
-                        `${op.operationIdPascalCase}OperationRequest`;
-                }
-                else {
-                    // Use standard Request suffix when no conflict
-                    op.requestTypeName = baseRequestTypeName;
-                }
-            }
-            mutateOperationWithAdditionalData(op);
-        }
-        // Lexicographical ordering of operations
-        service.operations = (0, lodash_orderby_1.default)(service.operations, (op) => op.uniqueName);
-        // Add the models to import
-        service.modelImports = (0, lodash_orderby_1.default)((0, lodash_uniqby_1.default)([...service.imports, ...requestModelImports, ...responseModelImports], (x) => x));
-        // Add the service class name
-        service.className = `${service.name}Api`;
-        service.classNameSnakeCase = (0, names_1.snakeCase)(service.className);
-        service.nameSnakeCase = (0, names_1.snakeCase)(service.name);
-    }
-    // All operations across all services
-    const allOperations = (0, lodash_uniqby_1.default)(data.services.flatMap((s) => s.operations), (o) => o.uniqueName);
-    // Add additional models for operation parameters
+ * Build the data structure used to generate code from an OpenAPI spec.
+ */ export const buildOpenApiCodeGenData = (inSpec)=>{
+    const spec = normaliseOpenApiSpecForCodeGen(inSpec);
+    const data = buildClientData(spec);
+    const modelsByName = indexModelsByName(data.models);
+    for (const service of data.services){
+        augmentService(spec, service, modelsByName);
+    }
+    const allOperations = uniqBy(data.services.flatMap((s)=>s.operations), (o)=>o.uniqueName);
+    // A model per operation request parameter position (query/path/body/...).
     data.models = [
         ...data.models,
-        ...allOperations.flatMap((op) => {
-            if (op.parameters && op.parameters.length > 0) {
-                // Build a collection of request parameter models to create based on their position (ie 'in' in the openapi spec, eg body, query, path, header, etc)
-                const parametersByPosition = {};
-                op.parameters
-                    .filter(
-                // We filter out (return false for) request bodies which we "inline" - ie we don't create a property which points to the body, the request will only be the body itself
-                (p) => {
-                    // Always create models for non-body parameters
-                    if (p.in !== 'body') {
-                        return true;
-                    }
-                    // If the body is the only parameter, we can inline it no matter the type
-                    if (op.parameters.length === 1) {
-                        return false;
-                    }
-                    // We inline object bodies, so long as they aren't dictionaries (as dictionary keys could clash with other parameters),
-                    // and so long as they don't have a property name that clashes with another parameter
-                    const hasClashingPropertyName = (modelsByName?.[p.type]?.properties ?? []).some((prop) => op.parameters.some((param) => param.name === prop.name));
-                    if (p.export === 'reference' &&
-                        modelsByName?.[p.type]?.export !== 'dictionary' &&
-                        !hasClashingPropertyName) {
-                        return false;
-                    }
-                    // Don't inline anything else
-                    return true;
-                })
-                    .forEach((parameter) => {
-                    parametersByPosition[parameter.in] = [
-                        ...(parametersByPosition[parameter.in] ?? []),
-                        parameter,
-                    ];
-                });
-                // Ensure that if we have an explicit body parameter, it's called "body"
-                const requestBodyParameter = parametersByPosition['body']?.[0];
-                if (requestBodyParameter) {
-                    requestBodyParameter.name = 'body';
-                    requestBodyParameter.prop = 'body';
-                }
-                op.explicitRequestBodyParameter = requestBodyParameter;
-                return Object.entries(parametersByPosition).map(([position, parameters]) => {
-                    const name = `${op.operationIdPascalCase}Request${(0, names_1.upperFirst)(position)}Parameters`;
-                    return {
-                        $refs: [],
-                        base: name,
-                        description: op.description,
-                        enum: null,
-                        enums: null,
-                        export: 'interface',
-                        imports: [],
-                        in: '',
-                        link: undefined,
-                        name,
-                        properties: parameters,
-                        template: '',
-                        type: name,
-                        isDefinition: false,
-                        isNullable: false,
-                        isReadOnly: false,
-                        isRequired: true,
-                    };
-                });
-            }
-            return [];
-        }),
+        ...allOperations.flatMap((op)=>buildRequestParameterModels(op, modelsByName))
     ];
-    // Augment models with additional data
-    for (const model of data.models) {
-        // Add a snake_case name
-        model.nameSnakeCase = (0, languages_1.toPythonName)('model', model.name);
-        const matchingSpecModel = spec?.components?.schemas?.[model.name];
-        if (matchingSpecModel) {
-            const specModel = (0, refs_1.resolveIfRef)(spec, matchingSpecModel);
-            await mutateWithOpenapiSchemaProperties(spec, model, specModel, modelsByName);
-            // Add unique imports
-            model.uniqueImports = (0, lodash_orderby_1.default)((0, lodash_uniqby_1.default)([
-                ...model.imports,
-                // Include property imports, if any
-                ...model.properties
-                    .filter((p) => p.export === 'reference')
-                    .map((p) => p.type),
-            ], (x) => x)).filter((modelImport) => modelImport !== model.name); // Filter out self for recursive model references
-            // Add deprecated flag if present
-            model.deprecated = specModel.deprecated || false;
-            // Augment properties with additional data
-            for (const property of model.properties) {
-                const matchingSpecProperty = specModel.properties?.[property.name];
-                if (matchingSpecProperty) {
-                    const specProperty = (0, refs_1.resolveIfRef)(spec, matchingSpecProperty);
-                    await mutateWithOpenapiSchemaProperties(spec, property, specProperty, modelsByName);
-                }
-            }
-        }
-        // Augment properties with additional data
-        model.properties.forEach((property) => {
-            // Add language-specific names/types
-            mutateModelWithAdditionalTypes(property);
-        });
+    for (const model of data.models){
+        augmentModel(spec, model, modelsByName);
     }
-    for (const model of data.models) {
-        // Set the model's typescript name and type
-        model.typescriptName = (0, languages_1.toTypeScriptModelName)(model.name);
+    for (const model of data.models){
+        model.typescriptName = toTypeScriptModelName(model.name);
         model.typescriptType = model.typescriptName;
     }
-    // Order models lexicographically by name
-    data.models = (0, lodash_orderby_1.default)(data.models, (d) => d.name);
-    // Order services so default appears first, then otherwise by name
-    data.services = (0, lodash_orderby_1.default)(data.services, (s) => s.name === 'Default' ? '' : s.name);
-    // All operations by tags
-    const operationsByTag = {};
-    const untaggedOperations = [];
-    allOperations.forEach((op) => {
-        const tags = op.tags;
-        if (tags && tags.length > 0) {
-            tags.map(lodash_camelcase_1.default).forEach((tag) => {
-                operationsByTag[tag] = [...(operationsByTag[tag] ?? []), op];
-            });
-        }
-        else {
-            untaggedOperations.push(op);
-        }
-    });
-    // Add top level vendor extensions
-    const vendorExtensions = {};
-    copyVendorExtensions(spec ?? {}, vendorExtensions);
+    for (const model of data.models){
+        assertNoClashingPropertyNames(model);
+        assertNoConflictingUnionMemberMarshalling(model);
+    }
+    for (const op of allOperations){
+        assertEncodableUrlEncodedBody(op);
+    }
+    data.models = orderBy(data.models, (d)=>d.name);
+    // Default service first, then by name.
+    data.services = orderBy(data.services, (s)=>s.name === DEFAULT_SERVICE_NAME ? '' : s.name);
+    const { operationsByTag, untaggedOperations } = groupOperationsByTag(allOperations);
     return {
         ...data,
         operationsByTag,
         untaggedOperations,
         info: spec.info,
         allOperations,
-        vendorExtensions,
-        className: (0, names_1.toClassName)(spec.info.title),
+        vendorExtensions: vendorExtensionsOf(spec),
+        className: toClassName(spec.info.title)
     };
 };
-exports.buildOpenApiCodeGenData = buildOpenApiCodeGenData;
-const buildInitialCodeGenData = async (spec) => {
-    let data;
-    // We create a plugin which will capture the client data
-    const plugin = () => ({
-        name: 'plugin',
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        _handler: () => { },
-        _handlerLegacy: ({ client }) => {
-            data = client;
-        },
-    });
-    // Use @hey-api/openapi-ts to build the initial data structure that we'll generate clients from
-    await gen.createClient({
-        experimentalParser: false,
-        input: {
-            path: spec,
-        },
-        output: 'unused',
-        plugins: [plugin()],
-        dryRun: true,
-        logs: { level: 'silent' },
-    });
-    if (!data) {
-        // If this happens it indicates an update to @hey-api/openapi-ts which has removed the legacy parser
-        throw new Error('Failed to build code generation data');
+/**
+ * Augment a service and each of its operations with the data needed for code
+ * generation (names, imports, result/request types, behavioural flags), and
+ * compute the set of models the service (ie API client) needs to import.
+ */ const augmentService = (spec, service, modelsByName)=>{
+    const modelImports = service.operations.flatMap((op)=>augmentOperation(spec, op, modelsByName));
+    service.operations = orderBy(service.operations, (op)=>op.uniqueName);
+    service.modelImports = orderBy(uniqBy([
+        ...service.imports,
+        ...modelImports
+    ], (x)=>x));
+    service.className = `${service.name}Api`;
+    service.nameSnakeCase = snakeCase(service.name);
+};
+/**
+ * Augment a single operation with all the data the templates need, returning
+ * the names of the models it references (for the service's import list).
+ */ const augmentOperation = (spec, op, modelsByName)=>{
+    const specOp = getSpecOperation(spec, op);
+    assignOperationNames(op, specOp);
+    op.vendorExtensions = vendorExtensionsOf(specOp);
+    const modelImports = [
+        ...specOp ? augmentResponses(spec, op, specOp, modelsByName) : [],
+        ...augmentParameters(spec, op, specOp, modelsByName)
+    ];
+    op.responses.forEach(addLanguageTypes);
+    op.responses = orderBy(op.responses, (r)=>r.code);
+    // Result is the lowest successful response, otherwise the 2XX or default.
+    op.result = op.responses.find((r)=>typeof r.code === 'number' && r.code >= 200 && r.code < 300) ?? op.responses.find((r)=>r.code === '2XX' || r.code === 'default');
+    op.operationIdPascalCase = pascalCase(op.uniqueName);
+    op.operationIdSnakeCase = toPythonName('operation', op.uniqueName);
+    if (op.parameters.length > 0) {
+        const baseRequestTypeName = `${op.operationIdPascalCase}Request`;
+        // Use the OperationRequest suffix when the standard Request name clashes
+        // with an existing schema.
+        op.requestTypeName = spec.components?.schemas?.[baseRequestTypeName] ? `${op.operationIdPascalCase}OperationRequest` : baseRequestTypeName;
     }
-    return data;
+    augmentOperationBehaviour(op);
+    return modelImports;
 };
 /**
- * Build a model for a particular primitive schema.
- * Only primitives are supported since we only return one model.
- * For non-primitives, it assumes all referenced subschemas are already models
- */
-const buildModelForPrimitive = async (originalSpec, schema) => {
-    const targetSchemaName = '___aws_nx_plugin_openapi_tmp_schema___';
-    const spec = {
-        openapi: '3.1.0',
-        info: { title: 'tmp', version: '1.0.0' },
-        paths: {},
-        components: {
-            schemas: {
-                ...originalSpec.components?.schemas,
-                [targetSchemaName]: schema,
-            },
-        },
-    };
-    const data = await buildInitialCodeGenData(spec);
-    const model = data.models.find((m) => m.name === targetSchemaName);
-    if (!model) {
-        throw new Error(`Failed to construct model for schema ${JSON.stringify(schema)}`);
+ * Set an operation's name and its deduplicated variants from the vendor
+ * extensions the normaliser added.
+ */ const assignOperationNames = (op, specOp)=>{
+    const deduplicatedOpId = specOp?.['x-aws-nx-deduplicated-op-id'];
+    const dotNotationOpId = specOp?.['x-aws-nx-deduplicated-dot-op-id'];
+    op.name = op.id ?? op.name;
+    op.uniqueName = deduplicatedOpId ?? op.name;
+    if (dotNotationOpId) {
+        op.dotNotationName = dotNotationOpId;
     }
-    ensureModelLinks(spec, data);
-    await mutateWithOpenapiSchemaProperties(spec, model, schema, Object.fromEntries(data.models.map((m) => [m.name, m])));
-    return model;
 };
-const buildOrReferenceModel = async (spec, modelsByName, schema) => {
-    if ((0, refs_1.isRef)(schema)) {
-        const name = (0, refs_1.splitRef)(schema.$ref)[2];
-        return modelsByName[name];
+/**
+ * Augment an operation's response models with schema-derived data, resolving
+ * void responses and streaming item schemas. Returns the response model names
+ * to import.
+ */ const augmentResponses = (spec, op, specOp, modelsByName)=>{
+    const modelImports = op.responses.filter((r)=>r.export === 'reference').map((r)=>r.type);
+    for (const response of op.responses){
+        // We cannot distinguish a composite of primitives at runtime (it all comes
+        // back as text), so validate this away.
+        if (response.export === 'reference' && COMPOSED_SCHEMA_TYPES.has(modelsByName[response.type]?.export)) {
+            const composedPrimitives = (modelsByName[response.type].composedPrimitives ?? []).filter((p)=>!COLLECTION_TYPES.has(p.export));
+            if (composedPrimitives.length > 0) {
+                throw new Error(`Operation "${op.method} ${op.path}" returns a composite schema of primitives with ${camelCase(modelsByName[response.type].export)}, which cannot be distinguished at runtime`);
+            }
+        }
+        const matchingSpecResponse = specOp.responses[`${response.code}`];
+        if (!matchingSpecResponse) continue;
+        const specResponse = resolveIfRef(spec, matchingSpecResponse);
+        // When there's no content, the response type is 'void'
+        if (!specResponse.content) {
+            response.type = 'void';
+            continue;
+        }
+        const mediaTypes = Object.keys(specResponse.content);
+        response.mediaTypes = mediaTypes;
+        for (const mediaType of mediaTypes){
+            const responseContent = specResponse.content[mediaType];
+            const responseSchema = resolveIfRef(spec, responseContent.schema);
+            if (responseSchema) {
+                augmentModelFromSchema(spec, response, responseSchema, modelsByName);
+            }
+            if (STREAMING_CONTENT_TYPES.has(mediaType) && 'itemSchema' in responseContent) {
+                response.isJsonlStreaming = true;
+                response.itemSchemaModel = buildOrReferenceModel(spec, modelsByName, responseContent.itemSchema);
+            }
+        }
     }
-    // Non referenced schemas won't have a model created as they are primitives and aren't covered by @heyapi
-    // So we build the model here
-    return await buildModelForPrimitive(spec, schema);
+    return modelImports;
 };
 /**
- * Copy vendor extensions from the first parameter to the second
- */
-const copyVendorExtensions = (object, vendorExtensions) => {
-    Object.entries(object ?? {}).forEach(([key, value]) => {
-        if (key.startsWith('x-')) {
-            vendorExtensions[key] = value;
+ * Augment an operation's parameter models with schema-derived data, resolving
+ * request bodies and query/header collection formats. Returns the parameter
+ * model names to import.
+ */ const augmentParameters = (spec, op, specOp, modelsByName)=>{
+    const specParametersByKey = getSpecParametersByKey(spec, specOp, getSpecPathParameters(spec, op));
+    const modelImports = [];
+    for (const parameter of op.parameters){
+        if (parameter.export === 'reference') {
+            modelImports.push(parameter.type);
         }
+        const specParameter = specParametersByKey[specParameterKey({
+            in: parameter.in,
+            name: parameter.prop
+        })];
+        const specParameterSchema = resolveIfRef(spec, specParameter?.schema);
+        if (specParameterSchema) {
+            augmentModelFromSchema(spec, parameter, specParameterSchema, modelsByName);
+        }
+        if (parameter.in === 'body') {
+            augmentBodyParameter(spec, parameter, specOp, modelsByName);
+        } else if ((parameter.in === 'query' || parameter.in === 'header') && specParameter) {
+            parameter.collectionFormat = getCollectionFormat(parameter.in, specParameter);
+            if (parameter.in === 'query' && specParameter.allowReserved) {
+                parameter.allowReserved = true;
+            }
+        } else if (parameter.in === 'path' && specParameter) {
+            const style = specParameter.style;
+            if (style === 'matrix' || style === 'label') {
+                parameter.pathStyle = style;
+                parameter.pathExplode = !!specParameter.explode;
+            }
+        }
+        addLanguageTypes(parameter);
+    }
+    return modelImports;
+};
+/**
+ * Augment a request body parameter with its schema (the body is not in the
+ * spec's `parameters`, so it is resolved from `requestBody` here) and record
+ * its acceptable media types.
+ */ const augmentBodyParameter = (spec, parameter, specOp, modelsByName)=>{
+    // The request body parameter is named 'body' downstream.
+    parameter.name = 'body';
+    parameter.prop = 'body';
+    const specBody = resolveIfRef(spec, specOp?.requestBody);
+    if (!specBody) return;
+    if (parameter.mediaType) {
+        const bodySchema = resolveIfRef(spec, specBody.content?.[parameter.mediaType]?.schema);
+        if (bodySchema) {
+            augmentModelFromSchema(spec, parameter, bodySchema, modelsByName);
+        }
+    }
+    // Track all the media types that can be accepted in the request body
+    parameter.mediaTypes = Object.keys(specBody.content);
+};
+/**
+ * Translate an OpenAPI v3 parameter's style/explode into a v2-style
+ * collectionFormat used when serialising array parameters.
+ * @see https://spec.openapis.org/oas/v3.0.3.html#style-values
+ */ const getCollectionFormat = (position, specParameter)=>{
+    const style = specParameter.style ?? (position === 'query' ? 'form' : 'simple');
+    const explode = specParameter.explode ?? style === 'form';
+    if (position === 'header') {
+        return explode ? 'multi' : 'csv';
+    }
+    // `deepObject` serialises an object as `key[prop]=value` pairs regardless of
+    // explode; the object shape (not array collection) drives its serialisation.
+    if (style === 'deepObject') {
+        return 'deepObject';
+    }
+    return explode ? 'multi' : ({
+        spaceDelimited: 'ssv',
+        pipeDelimited: 'pipes',
+        simple: 'csv',
+        form: 'csv'
+    })[style] ?? 'multi';
+};
+/**
+ * Build the request parameter models for an operation — one model per parameter
+ * position (query/path/header/cookie/body), named e.g.
+ * `FooRequestQueryParameters`. Request bodies that can be represented directly
+ * (the sole parameter, or a non-clashing object reference) are inlined rather
+ * than given a wrapper model, and recorded on `op.explicitRequestBodyParameter`.
+ */ const buildRequestParameterModels = (op, modelsByName)=>{
+    if (!op.parameters || op.parameters.length === 0) {
+        return [];
+    }
+    // Whether the request body can be represented directly, without a wrapper
+    // model (ie the request will be the body itself).
+    const canInlineBody = (body)=>{
+        // If the body is the only parameter, we can inline it no matter the type
+        if (op.parameters.length === 1) {
+            return true;
+        }
+        // We inline object bodies, so long as they aren't dictionaries (as
+        // dictionary keys could clash with other parameters), and so long as they
+        // don't have a property name that clashes with another parameter
+        const hasClashingPropertyName = (modelsByName?.[body.type]?.properties ?? []).some((prop)=>op.parameters.some((param)=>param.name === prop.name));
+        return body.export === 'reference' && modelsByName?.[body.type]?.export !== 'dictionary' && !hasClashingPropertyName;
+    };
+    // Group parameters by their position (`in`: query/path/header/cookie/body),
+    // dropping any body that can be inlined.
+    const parametersByPosition = op.parameters.filter((p)=>!(p.in === 'body' && canInlineBody(p))).reduce((acc, p)=>({
+            ...acc,
+            [p.in]: [
+                ...acc[p.in] ?? [],
+                p
+            ]
+        }), {});
+    // The body parameter was already renamed to "body" by augmentBodyParameter.
+    op.explicitRequestBodyParameter = parametersByPosition['body']?.[0];
+    return Object.entries(parametersByPosition).map(([position, parameters])=>{
+        const name = `${op.operationIdPascalCase}Request${upperFirst(position)}Parameters`;
+        return createModel({
+            description: op.description,
+            export: 'interface',
+            name,
+            properties: parameters,
+            type: name,
+            isRequired: true
+        });
     });
 };
-const mutateWithOpenapiSchemaProperties = async (spec, model, schema, modelsByName, visited = new Set()) => {
+/**
+ * Augment a single model with schema-derived data (from its matching spec
+ * schema, if any) and language-specific names and types.
+ */ const augmentModel = (spec, model, modelsByName)=>{
+    model.nameSnakeCase = toPythonName('model', model.name);
+    const matchingSpecModel = spec?.components?.schemas?.[model.name];
+    if (matchingSpecModel) {
+        const specModel = resolveIfRef(spec, matchingSpecModel);
+        augmentModelFromSchema(spec, model, specModel, modelsByName);
+        for (const property of model.properties){
+            const matchingSpecProperty = specModel.properties?.[property.name];
+            if (matchingSpecProperty) {
+                const specProperty = resolveIfRef(spec, matchingSpecProperty);
+                augmentModelFromSchema(spec, property, specProperty, modelsByName);
+            }
+        }
+    }
+    model.properties.forEach(addLanguageTypes);
+    // Resolve the discriminator's TypeScript property name for marshalling.
+    if (model.discriminator) {
+        model.discriminator.typescriptPropertyName = toTypeScriptName(model.discriminator.propertyName);
+    }
+};
+/**
+ * Ensure no two properties/parameters of an object model collapse onto the same
+ * TypeScript identifier (e.g. `foo-bar` and `foo_bar` both camelCase to
+ * `fooBar`, or a query and header parameter sharing a name within one request
+ * position). Such a clash would emit a type with duplicate members that does
+ * not compile, so fail fast with an actionable error instead.
+ */ const assertNoClashingPropertyNames = (model)=>{
+    const seen = new Map();
+    for (const property of model.properties){
+        // Composite members are unnamed (their names are empty); skip them.
+        if (!property.name) continue;
+        const existing = seen.get(property.typescriptName);
+        if (existing !== undefined && existing !== property.name) {
+            throw new Error(`Property name conflict in "${model.name}": "${existing}" and "${property.name}" both map to the TypeScript name "${property.typescriptName}". Please rename one of these in your OpenAPI specification.`);
+        }
+        seen.set(property.typescriptName, property.name);
+    }
+};
+/**
+ * The marshalling semantics of a property — two properties with the same key
+ * convert identically on the wire (so either branch's conversion is safe).
+ */ const marshallingKey = (m)=>{
+    if ([
+        'date',
+        'date-time'
+    ].includes(m.format ?? '')) return 'date';
+    if (m.type === 'binary') return 'binary';
+    // Enums serialise as their bare primitive (no conversion).
+    if (m.isEnum || m.export === 'enum') return 'plain';
+    if (COLLECTION_TYPES.has(m.export)) {
+        return `${m.export}<${m.link ? marshallingKey(m.link) : 'plain'}>`;
+    }
+    if (m.export === 'tuple') {
+        return `tuple<${m.properties.map(marshallingKey).join(',')}>`;
+    }
+    if (m.export === 'reference' && !PRIMITIVE_TYPES.has(m.type)) {
+        return `ref:${m.type}`;
+    }
+    return 'plain';
+};
+/**
+ * A non-discriminated `oneOf`/`anyOf` of object members marshals by composing
+ * every member, taking only the properties present on the value. That is sound
+ * exactly when no wire property is claimed by two members with different
+ * marshalling (e.g. a `date-time` in one and a plain string in another) —
+ * otherwise the branch cannot be determined without guessing, so fail fast and
+ * ask for a discriminator rather than corrupt data at runtime.
+ */ const assertNoConflictingUnionMemberMarshalling = (model)=>{
+    if (model.export !== 'one-of' && model.export !== 'any-of' || model.discriminator) {
+        return;
+    }
+    const seen = new Map();
+    for (const member of model.composedModels ?? []){
+        for (const property of member.properties){
+            if (!property.name) continue;
+            const key = marshallingKey(property);
+            const existing = seen.get(property.name);
+            if (existing && existing.key !== key) {
+                throw new Error(`Schema "${model.name}" is a non-discriminated ${camelCase(model.export)} of "${existing.memberName}" and "${member.name}", which both declare a property "${property.name}" with different types, so the correct conversion cannot be determined. Add a discriminator to the union in your OpenAPI specification (e.g. with Pydantic, Field(discriminator=...)).`);
+            }
+            if (!existing) {
+                seen.set(property.name, {
+                    memberName: member.name,
+                    key
+                });
+            }
+        }
+    }
+};
+/**
+ * An `application/x-www-form-urlencoded` body is form-encoded as `key=value`
+ * pairs, so the wire form is only defined for a schema with named properties
+ * (an object) or a primitive sent verbatim. A top-level array or tuple has no
+ * property names to key on — encoding it would emit index keys (`0=a&1=b`) that
+ * no form parser can decode — so fail fast rather than generate a client that
+ * is silently wrong on the wire.
+ */ const assertEncodableUrlEncodedBody = (op)=>{
+    const body = op.parametersBody;
+    if (!body?.mediaTypes) return;
+    const mediaTypes = Array.isArray(body.mediaTypes) ? body.mediaTypes : [
+        body.mediaTypes
+    ];
+    // Match the wire media type the client actually sends: JSON is preferred, so
+    // an array body offering both JSON and urlencoded is sent as JSON and is fine.
+    const chosenMediaType = mediaTypes.find((mt)=>mt === 'application/json' || mt.endsWith('+json')) ?? mediaTypes[0];
+    if (chosenMediaType !== 'application/x-www-form-urlencoded') return;
+    if (body.isPrimitive) return;
+    if (body.export === 'array' || body.export === 'tuple') {
+        throw new Error(`Operation ${op.method} ${op.path} has an application/x-www-form-urlencoded request body whose schema is a ${body.export}, which has no defined form encoding. Use an object schema (its properties become the form fields) or a primitive schema (sent verbatim) in your OpenAPI specification.`);
+    }
+};
+/**
+ * Group operations by their (camelCased) tags, collecting any untagged
+ * operations separately.
+ */ const groupOperationsByTag = (allOperations)=>{
+    const isTagged = (op)=>!!op.tags && op.tags.length > 0;
+    const operationsByTag = allOperations.filter(isTagged).flatMap((op)=>op.tags.map((tag)=>[
+                camelCase(tag),
+                op
+            ])).reduce((acc, [tag, op])=>({
+            ...acc,
+            [tag]: [
+                ...acc[tag] ?? [],
+                op
+            ]
+        }), {});
+    return {
+        operationsByTag,
+        untaggedOperations: allOperations.filter((op)=>!isTagged(op))
+    };
+};
+/**
+ * Resolve a schema to its model: an existing named model for a `$ref`, or a
+ * freshly built-and-augmented model for an inline (nested value) schema.
+ */ const buildOrReferenceModel = (spec, modelsByName, schema)=>{
+    if (isRef(schema)) {
+        const name = splitRef(schema.$ref)[2];
+        return modelsByName[name];
+    }
+    const model = buildInlineModel(spec, schema);
+    linkModel(spec, modelsByName, model, schema);
+    augmentModelFromSchema(spec, model, schema, modelsByName);
+    return model;
+};
+/**
+ * The `x-*` vendor extensions declared on an object.
+ */ const vendorExtensionsOf = (object)=>Object.fromEntries(Object.entries(object ?? {}).filter(([key])=>key.startsWith('x-')));
+const augmentModelFromSchema = (spec, model, schema, modelsByName, visited = new Set())=>{
     model.format = schema.format;
-    model.isInteger = schema.type === 'integer';
-    model.isShort = schema.format === 'int32';
-    model.isLong = schema.format === 'int64';
     model.deprecated = !!schema.deprecated;
     model.openapiType = schema.type;
-    model.isNotSchema = !!schema.not;
     model.isEnum = !!schema.enum && schema.enum.length > 0;
-    // Copy any schema vendor extensions
-    model.vendorExtensions = {};
-    copyVendorExtensions(schema, model.vendorExtensions);
-    // Use our added vendor extension
-    model.isHoisted = !!model.vendorExtensions?.['x-aws-nx-hoisted'];
-    // Ensure models with additional properties are handled correctly
+    model.vendorExtensions = vendorExtensionsOf(schema);
+    // A "dictionary" has only additional properties; an "interface" may mix
+    // explicit and additional properties.
     if (schema.additionalProperties) {
-        const additionalPropertiesModel = await buildOrReferenceModel(spec, modelsByName, schema.additionalProperties === true ? {} : schema.additionalProperties);
-        // The original models treat _some_ objects with additional properties as a "dictionary", and others as an "interface"
-        // For the purposes of our code generation, we define a "dictionary" to be a model with no explicit properties, only
-        // additional properties. Interfaces can have a mixture of explicit properties and additional properties.
+        const additionalPropertiesModel = buildOrReferenceModel(spec, modelsByName, schema.additionalProperties === true ? {} : schema.additionalProperties);
         if (model.export === 'dictionary') {
-            // Dictionaries contain a special property which is the model itself. Other properties are explicit properties.
-            const explicitProperties = model.properties.filter((p) => !(p.export === 'dictionary' && p.name === model.name));
+            // A dictionary carries a self-referential property; the rest are explicit
+            const explicitProperties = model.properties.filter((p)=>!(p.export === 'dictionary' && p.name === model.name));
+            // Explicit properties make this an interface rather than a dictionary
             if (explicitProperties.length > 0 || schema.patternProperties) {
-                // Treat this model as an interface instead of a dictionary, since this has
-                // explicit properties
                 model.export = 'interface';
                 model.hasAdditionalProperties = true;
                 model.additionalPropertiesModel = additionalPropertiesModel;
                 model.properties = explicitProperties;
             }
-        }
-        else {
+        } else {
             model.hasAdditionalProperties = true;
             model.additionalPropertiesModel = additionalPropertiesModel;
-            // There's a special property named [key: string] which is the definition of the additional properties
-            // We remove this so we don't render it as a regular property.
-            model.properties = (model.properties ?? []).filter((p) => p.name !== '[key: string]');
         }
     }
-    // Ensure models with pattern properties are handled correctly
+    // Pattern properties can have different value types per pattern, so the model
+    // is an interface rather than a dictionary.
     if (schema.patternProperties) {
-        const patternProperties = (0, refs_1.resolveIfRef)(spec, schema.patternProperties);
-        const patternPropertiesModels = [];
-        // When there are pattern properties, we don't want to treat models as dictionaries since there can be more than one type of "value"
-        // depending on what pattern the key matches
+        const patternProperties = resolveIfRef(spec, schema.patternProperties);
         if (model.export === 'dictionary') {
             model.export = 'interface';
         }
-        for (const [pattern, patternProperty] of Object.entries(patternProperties)) {
-            const patternPropertyModel = await buildOrReferenceModel(spec, modelsByName, patternProperty);
-            if (patternPropertyModel) {
-                patternPropertiesModels.push({
-                    pattern,
-                    model: patternPropertyModel,
-                });
-            }
-        }
         model.hasPatternProperties = true;
-        model.patternPropertiesModels = patternPropertiesModels;
+        model.patternPropertiesModels = Object.entries(patternProperties).map(([pattern, patternProperty])=>({
+                pattern,
+                model: buildOrReferenceModel(spec, modelsByName, patternProperty)
+            })).filter((entry)=>!!entry.model);
     }
-    mutateModelWithAdditionalTypes(model);
+    addLanguageTypes(model);
     visited.add(model);
-    const modelLink = (0, types_1.flattenModelLink)(model.link);
-    // Also apply to array items recursively
-    if (model.export === 'array' &&
-        modelLink &&
-        'items' in schema &&
-        schema.items &&
-        !visited.has(modelLink)) {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.items);
-        await mutateWithOpenapiSchemaProperties(spec, modelLink, subSchema, modelsByName, visited);
-    }
-    // Also apply to object properties recursively
-    if (model.export === 'dictionary' &&
-        model.link &&
-        'additionalProperties' in schema &&
-        schema.additionalProperties &&
-        !visited.has(modelLink)) {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.additionalProperties);
-        // Additional properties can be "true" rather than a type
-        if (subSchema !== true) {
-            await mutateWithOpenapiSchemaProperties(spec, modelLink, subSchema, modelsByName, visited);
-        }
-    }
-    for (const property of model.properties.filter((p) => !visited.has(p) && schema.properties?.[(0, lodash_trim_1.default)(p.name, `"'`)])) {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.properties[(0, lodash_trim_1.default)(property.name, `"'`)]);
-        await mutateWithOpenapiSchemaProperties(spec, property, subSchema, modelsByName, visited);
+    const recurse = (target, subSchema)=>augmentModelFromSchema(spec, target, subSchema, modelsByName, visited);
+    // Array element type.
+    if (model.export === 'array' && model.link && 'items' in schema && schema.items && !visited.has(model.link)) {
+        recurse(model.link, resolveIfRef(spec, schema.items));
     }
-    if (types_1.COMPOSED_SCHEMA_TYPES.has(model.export)) {
-        for (let i = 0; i < model.properties.length; i++) {
-            const subSchema = (0, refs_1.resolveIfRef)(spec, schema[(0, lodash_camelcase_1.default)(model.export)]?.[i]);
-            if (subSchema) {
-                await mutateWithOpenapiSchemaProperties(spec, model.properties[i], subSchema, modelsByName, visited);
-            }
+    // Dictionary value type (additionalProperties may be `true` rather than a
+    // schema).
+    if (model.export === 'dictionary' && model.link && 'additionalProperties' in schema && schema.additionalProperties && !visited.has(model.link)) {
+        const subSchema = resolveIfRef(spec, schema.additionalProperties);
+        if (subSchema !== true) {
+            recurse(model.link, subSchema);
         }
     }
-};
-/**
- * Ensure that the "link" property of all dictionary/array models and properties are set recursively
- */
-const ensureModelLinks = (spec, data) => {
-    const modelsByName = Object.fromEntries(data.models.map((m) => [m.name, m]));
-    const visited = new Set();
-    // Ensure set for all models
-    data.models.forEach((model) => {
-        const schema = (0, refs_1.resolveIfRef)(spec, spec?.components?.schemas?.[model.name]);
-        if (schema) {
-            // Object schemas should be typed as the model we will create
-            if (schema.type === 'object' &&
-                (schema.properties || schema.patternProperties)) {
-                model.type = model.name;
+    // Tuple element types (3.1 `prefixItems`), positionally.
+    if (model.export === 'tuple' && 'prefixItems' in schema) {
+        const memberSchemas = schema.prefixItems ?? [];
+        model.properties.forEach((member, i)=>{
+            const subSchema = resolveIfRef(spec, memberSchemas[i]);
+            if (subSchema && !visited.has(member)) {
+                recurse(member, subSchema);
             }
-            _ensureModelLinks(spec, modelsByName, model, schema, visited);
-        }
-    });
-    // Ensure set for all parameters and responses
-    data.services.forEach((service) => {
-        service.operations.forEach((op) => {
-            const specOp = spec?.paths?.[op.path]?.[op.method.toLowerCase()];
-            const specParametersByName = Object.fromEntries((specOp?.parameters ?? []).map((p) => {
-                const param = (0, refs_1.resolveIfRef)(spec, p);
-                return [param.name, param];
-            }));
-            op.parameters.forEach((parameter) => {
-                const specParameter = specParametersByName[parameter.prop];
-                const specParameterSchema = (0, refs_1.resolveIfRef)(spec, specParameter?.schema);
-                if (specParameterSchema) {
-                    _ensureModelLinks(spec, modelsByName, parameter, specParameterSchema, visited);
-                }
-                else if (parameter.in === 'body') {
-                    // Body is not in the "parameters" section of the OpenAPI spec so we handle it in an explicit case here
-                    const specBody = (0, refs_1.resolveIfRef)(spec, specOp?.requestBody);
-                    const specBodySchema = (0, refs_1.resolveIfRef)(spec, specBody?.content?.[parameter.mediaType]?.schema);
-                    if (specBodySchema) {
-                        _ensureModelLinks(spec, modelsByName, parameter, specBodySchema, visited);
-                    }
-                }
-            });
-            op.responses.forEach((response) => {
-                const specResponse = (0, refs_1.resolveIfRef)(spec, specOp?.responses?.[response.code]);
-                const mediaTypes = Object.keys(specResponse?.content ?? {});
-                mediaTypes.forEach((mediaType) => {
-                    const responseSchema = (0, refs_1.resolveIfRef)(spec, specResponse?.content?.[mediaType]?.schema);
-                    if (responseSchema) {
-                        _ensureModelLinks(spec, modelsByName, response, responseSchema, visited);
-                    }
-                });
-            });
         });
-    });
-};
-const _ensureModelLinks = (spec, modelsByName, model, schema, visited) => {
-    if (visited.has(model)) {
-        return;
-    }
-    visited.add(model);
-    if (model.export === 'dictionary' &&
-        'additionalProperties' in schema &&
-        schema.additionalProperties) {
-        if ((0, refs_1.isRef)(schema.additionalProperties)) {
-            const name = (0, refs_1.splitRef)(schema.additionalProperties.$ref)[2];
-            if (modelsByName[name] && !model.link) {
-                model.link = modelsByName[name];
-            }
-        }
-        else if (model.link && typeof schema.additionalProperties !== 'boolean') {
-            _ensureModelLinks(spec, modelsByName, (0, types_1.flattenModelLink)(model.link), schema.additionalProperties, visited);
-        }
-    }
-    else if (model.export === 'array' && 'items' in schema && schema.items) {
-        if ((0, refs_1.isRef)(schema.items)) {
-            const name = (0, refs_1.splitRef)(schema.items.$ref)[2];
-            if (modelsByName[name] && !model.link) {
-                model.link = modelsByName[name];
-            }
-        }
-        else if (model.link) {
-            _ensureModelLinks(spec, modelsByName, (0, types_1.flattenModelLink)(model.link), schema.items, visited);
-        }
     }
-    model.properties
-        .filter((p) => !visited.has(p) && schema.properties?.[(0, lodash_trim_1.default)(p.name, `"'`)])
-        .forEach((property) => {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.properties[(0, lodash_trim_1.default)(property.name, `"'`)]);
-        _ensureModelLinks(spec, modelsByName, property, subSchema, visited);
-    });
-    if (types_1.COMPOSED_SCHEMA_TYPES.has(model.export)) {
-        model.properties.forEach((property, i) => {
-            const subSchema = (0, refs_1.resolveIfRef)(spec, schema[(0, lodash_camelcase_1.default)(model.export)]?.[i]);
+    model.properties.filter((p)=>!visited.has(p) && schema.properties?.[trim(p.name, `"'`)]).forEach((property)=>recurse(property, resolveIfRef(spec, schema.properties[trim(property.name, `"'`)])));
+    if (COMPOSED_SCHEMA_TYPES.has(model.export)) {
+        const memberSchemas = compositeMemberSchemas(schema, model.export);
+        model.properties.forEach((property, i)=>{
+            const subSchema = resolveIfRef(spec, memberSchemas[i]);
             if (subSchema) {
-                _ensureModelLinks(spec, modelsByName, property, subSchema, visited);
+                recurse(property, subSchema);
             }
         });
     }
 };
-/**
- * Mutates the given data to ensure composite models (ie allOf, oneOf, anyOf) have the necessary
- * properties for representing them in generated code. Adds `composedModels` and `composedPrimitives`
- * which contain the models and primitive types that each model is composed of.
- */
-const ensureCompositeModels = (data) => {
-    const visited = new Set();
-    data.models.forEach((model) => mutateModelWithCompositeProperties(data, model, visited));
-};
-const mutateModelWithCompositeProperties = (data, model, visited) => {
-    if (types_1.COMPOSED_SCHEMA_TYPES.has(model.export) && !visited.has(model)) {
-        visited.add(model);
-        // Find the models/primitives which this is composed from
-        const composedModelReferences = model.properties.filter((p) => !p.name && p.export === 'reference');
-        const composedPrimitives = model.properties.filter((p) => !p.name && p.export !== 'reference');
-        const modelsByName = Object.fromEntries(data.models.map((m) => [m.name, m]));
-        let composedModels = composedModelReferences.flatMap((r) => modelsByName[r.type] ? [modelsByName[r.type]] : []);
-        // Recursively resolve composed properties of properties, to ensure mixins for all-of include all recursive all-of properties
-        composedModels.forEach((m) => mutateModelWithCompositeProperties(data, m, visited));
-        // Enums are models, however they are serialised as primitives and so should be moved to the primitives list
-        composedPrimitives.push(...composedModels.filter((m) => m.export === 'enum'));
-        composedModels = composedModels.filter((m) => m.export !== 'enum');
-        // When multiple arrays of non-primitives are composed using allOf/oneOf/anyOf, it's not possible to distinguish at runtime which
-        // type it is, and so we validate this away.
-        // TODO: consider honouring more advanced OpenAPI spec features like "discriminators" which can help for this case, but in practice
-        // users are unlikely to model their API this way
-        const isPrimitiveArray = (m) => {
-            if (m.link && ['array', 'dictionary'].includes(m.export)) {
-                return isPrimitiveArray((0, types_1.flattenModelLink)(m.link));
-            }
-            return (types_1.PRIMITIVE_TYPES.has(m.type) && !['date', 'date-time'].includes(m.format));
-        };
-        const arrayComposedModels = composedPrimitives.filter((m) => m.export === 'array' && !isPrimitiveArray(m));
-        if (arrayComposedModels.length > 1) {
-            throw new Error(`Schema "${model.name}" defines ${(0, lodash_camelcase_1.default)(model.export)} with multiple array types which cannot be distinguished at runtime.`);
-        }
-        // For all-of models, we include all composed model properties.
-        if (model.export === 'all-of') {
-            if (composedPrimitives.length > 0) {
-                throw new Error(`Schema "${model.name}" defines allOf with non-object types. allOf may only compose object types in the OpenAPI specification.`);
-            }
-        }
-        model.composedModels = composedModels;
-        model.composedPrimitives = composedPrimitives;
-    }
-};
-/**
- * Mutates the given model to add language specific types and names
- */
-const mutateModelWithAdditionalTypes = (model) => {
-    // Trim any surrounding quotes from name
-    model.name = (0, lodash_trim_1.default)(model.name, `"'`);
-    model.typescriptName = (0, languages_1.toTypeScriptName)(model.name);
-    model.typescriptType = (0, languages_1.toTypeScriptType)(model);
-    model.pythonName = (0, languages_1.toPythonName)('property', model.name);
-    model.pythonType = (0, languages_1.toPythonType)(model);
-    model.isPrimitive =
-        types_1.PRIMITIVE_TYPES.has(model.type) &&
-            !types_1.COMPOSED_SCHEMA_TYPES.has(model.export) &&
-            !types_1.COLLECTION_TYPES.has(model.export);
+const addLanguageTypes = (model)=>{
+    model.name = trim(model.name, `"'`);
+    model.typescriptName = toTypeScriptName(model.name);
+    model.typescriptType = toTypeScriptType(model);
+    model.pythonName = toPythonName('property', model.name);
+    model.pythonType = toPythonType(model);
+    model.isPrimitive = PRIMITIVE_TYPES.has(model.type) && !COMPOSED_SCHEMA_TYPES.has(model.export) && !COLLECTION_TYPES.has(model.export);
 };
-/**
- * Determine whether or not an operation is a mutation
- */
-const isOperationMutation = (op) => {
-    // Let the user override whether an operation is a query or mutation using x-mutation/x-query
+const isOperationMutation = (op)=>{
+    // x-mutation/x-query override the HTTP-method default.
     const { vendorExtensions } = op;
-    if (vendorExtensions?.[types_1.VENDOR_EXTENSIONS.MUTATION]) {
+    if (vendorExtensions?.[VENDOR_EXTENSIONS.MUTATION]) {
         return true;
-    }
-    else if (vendorExtensions?.[types_1.VENDOR_EXTENSIONS.QUERY]) {
+    } else if (vendorExtensions?.[VENDOR_EXTENSIONS.QUERY]) {
         return false;
     }
-    // Assume a restful API and treat mutative HTTP methods as mutations
-    return ['PATCH', 'POST', 'PUT', 'DELETE'].includes(op.method);
+    return [
+        'PATCH',
+        'POST',
+        'PUT',
+        'DELETE'
+    ].includes(op.method);
 };
-/**
- * Add infinite query details to the operation
- */
-const mutateOperationWithInfiniteQueryDetails = (op) => {
+const augmentInfiniteQuery = (op)=>{
     const { paginationDisabled, cursorPropertyName } = getCursorOptions(op);
-    // Allow users to customise the "cursor" property used for paginated requests
-    const cursorProperty = op.parameters.find((p) => p.name === cursorPropertyName);
-    // The operation is an infinite query if:
-    // - x-cursor is not set to 'false' (this allows users to disable infinite queries for operations that accept a 'cursor')
-    // - the operation accepts a parameter named 'cursor', or a parameter named as the user specified with x-cursor
+    const cursorProperty = op.parameters.find((p)=>p.name === cursorPropertyName);
+    // An infinite query is a paginated operation that accepts the cursor parameter
     op.isInfiniteQuery = !paginationDisabled && !!cursorProperty;
     if (op.isInfiniteQuery) {
         op.infiniteQueryCursorProperty = cursorProperty;
     }
 };
 /**
- * Extracts the cursor options for this operation based on the vendor extensions
- *
- * Valid usage of x-cursor:
+ * Resolve the pagination cursor options from an operation's `x-cursor` vendor
+ * extension. Accepted forms (object variants exist because Smithy vendor
+ * extensions must be objects):
  *
- * x-cursor: 'property' - customises the input property used for pagination
- * x-cursor: false - disables pagination for the operation (ie the operation would have pagination by default as an input 'cursor' property exists)
- *
- * We also support object equivalents of the above, since Smithy vendor extensions can only be objects
- *
- * x-cursor: { inputToken: 'property' }
- * x-cursor: { enabled: false }
- */
-const getCursorOptions = (op) => {
-    const { vendorExtensions } = op;
-    const cursorExtension = vendorExtensions?.[types_1.VENDOR_EXTENSIONS.CURSOR];
-    // By default pagination isn't explicitly disabled and the cursor property to look for is 'cursor'
-    let paginationDisabled = false;
-    let cursorPropertyName = 'cursor';
-    if (typeof cursorExtension === 'boolean' && cursorExtension === false) {
-        paginationDisabled = true;
-    }
-    else if (typeof cursorExtension === 'string') {
-        cursorPropertyName = cursorExtension;
-    }
-    else if (typeof cursorExtension === 'object') {
-        if (cursorExtension?.enabled === false) {
-            paginationDisabled = true;
-        }
-        if (cursorExtension?.inputToken &&
-            typeof cursorExtension.inputToken === 'string') {
-            cursorPropertyName = cursorExtension.inputToken;
-        }
+ * - `'property'` / `{ inputToken: 'property' }` — the input property to page on
+ * - `false` / `{ enabled: false }` — disable pagination
+ */ const getCursorOptions = (op)=>{
+    const cursor = op.vendorExtensions?.[VENDOR_EXTENSIONS.CURSOR];
+    // Defaults: pagination enabled, paging on a property named 'cursor'.
+    if (cursor === false) {
+        return {
+            paginationDisabled: true,
+            cursorPropertyName: 'cursor'
+        };
+    }
+    if (typeof cursor === 'string') {
+        return {
+            paginationDisabled: false,
+            cursorPropertyName: cursor
+        };
     }
-    // x-cursor can be: a string (indicating pagination is enabled and the property name to use)
+    const options = cursor ?? {};
     return {
-        paginationDisabled,
-        cursorPropertyName,
+        paginationDisabled: options.enabled === false,
+        cursorPropertyName: typeof options.inputToken === 'string' ? options.inputToken : 'cursor'
     };
 };
 /**
- * Add additional data to an operation for code generation decisions
- */
-const mutateOperationWithAdditionalData = (op) => {
-    // Add mutation/query details
+ * Add query/mutation, streaming and infinite-query flags to an operation.
+ */ const augmentOperationBehaviour = (op)=>{
     const isMutation = isOperationMutation(op);
     op.isMutation = isMutation;
     op.isQuery = !isMutation;
-    // Streaming responses
-    op.isStreaming =
-        !!op.vendorExtensions?.[types_1.VENDOR_EXTENSIONS.STREAMING] ||
-            op.responses.some((res) => res.isJsonlStreaming);
-    // Set the result type for the client method to the item schema so that
-    // it will resolve to AsyncIterableIterator<{itemSchemaModel.name}>
-    const jsonlResponse = op.responses.find((res) => res.isJsonlStreaming);
+    op.isStreaming = !!op.vendorExtensions?.[VENDOR_EXTENSIONS.STREAMING] || op.responses.some((res)=>res.isJsonlStreaming);
+    // For JSON-lines streaming, the result is each streamed item, so the client
+    // method returns AsyncIterableIterator<itemSchemaModel>. Named (hoisted)
+    // item schemas become references; inline primitives keep their own type.
+    const jsonlResponse = op.responses.find((res)=>res.isJsonlStreaming);
     if (jsonlResponse) {
         const itemSchemaModel = jsonlResponse.itemSchemaModel;
         const result = op.result;
         if (result && itemSchemaModel) {
-            result.type = itemSchemaModel.name;
-            result.typescriptType = itemSchemaModel.name;
-            result.export = 'reference';
+            if (itemSchemaModel.name) {
+                result.type = itemSchemaModel.name;
+                result.typescriptType = itemSchemaModel.name;
+                result.export = 'reference';
+            } else {
+                result.type = itemSchemaModel.type;
+                result.typescriptType = itemSchemaModel.typescriptType;
+                result.export = itemSchemaModel.export;
+                result.format = itemSchemaModel.format;
+                result.link = itemSchemaModel.link;
+                result.isPrimitive = itemSchemaModel.isPrimitive;
+            }
         }
     }
     // Add infinite query details if applicable
     if (!isMutation) {
-        mutateOperationWithInfiniteQueryDetails(op);
+        augmentInfiniteQuery(op);
     }
 };
+
 //# sourceMappingURL=codegen-data.js.map