genoc 0.2.0 → 0.4.0

package/dist/generator/contracts-generator.js

@@ -1,213 +1,5 @@
-import { analyzePaths } from '../analyzer/path-analyzer.js';
-import { SchemaMapper } from '../analyzer/schema-mapper.js';
-import { RefResolver } from '../parser/ref-resolver.js';
-import { RESERVED_TYPE_NAMES, buildSchemaRenameMap, DEFAULT_RUNTIME_IMPORT_PATH, buildTypeJsDoc, sanitizeJsDocText, sanitizeTypeName, toPascalCase, getOperationTypePrefix, makeHeader, } from '../utils/generator-helpers.js';
-function isBinaryContentType(ct) {
-    if (ct === 'application/octet-stream')
-        return true;
-    if (ct.startsWith('image/'))
-        return true;
-    if (ct.startsWith('video/'))
-        return true;
-    if (ct.startsWith('audio/'))
-        return true;
-    return false;
-}
-/**
- * If the schema is a $ref to a discriminated base type (or an array whose items
- * are), replace the type name with the {Base}Variant union type.
- */
-function substituteDiscriminatedType(tsType, schema, discriminatorInfo, renameMap) {
-    const refSchema = schema;
-    if (!refSchema || typeof refSchema !== 'object')
-        return tsType;
-    if (typeof refSchema.$ref === 'string') {
-        const schemaName = sanitizeTypeName(refSchema.$ref.split('/').pop());
-        if (schemaName && discriminatorInfo.has(schemaName)) {
-            const renamed = renameMap.get(schemaName) ?? schemaName;
-            return tsType.replace(new RegExp(`\\b${renamed}\\b`, 'g'), `${renamed}Variant`);
-        }
-    }
-    if (refSchema.items && typeof refSchema.items === 'object') {
-        const items = refSchema.items;
-        if (typeof items.$ref === 'string') {
-            const schemaName = sanitizeTypeName(items.$ref.split('/').pop());
-            if (schemaName && discriminatorInfo.has(schemaName)) {
-                const renamed = renameMap.get(schemaName) ?? schemaName;
-                return tsType.replace(new RegExp(`\\b${renamed}\\b`, 'g'), `${renamed}Variant`);
-            }
-        }
-    }
-    return tsType;
-}
-/**
- * Indent unit matching `INDENT_UNIT` in schema-mapper.ts (2 spaces, pinned by
- * the mapper's golden tests). Kept local to avoid modifying the mapper module.
- */
-const INDENT_UNIT = '  ';
-/**
- * Build a description-only type-level JSDoc comment for operation-derived
- * types (body / response). Returns '' when the description is absent or
- * whitespace-only so callers can skip emission entirely.
- */
-function buildDescriptionJsDoc(description) {
-    if (description === undefined)
-        return '';
-    const sanitized = sanitizeJsDocText(description);
-    return sanitized === '' ? '' : `/** ${sanitized} */`;
-}
-/**
- * Prefix a type definition with its JSDoc block (single- or multi-line),
- * keeping the comment directly above the `export type` line.
- */
-function attachTypeJsDoc(jsDoc, definition) {
-    return jsDoc === '' ? definition : `${jsDoc}\n${definition}`;
-}
-/**
- * Indent every line of a JSDoc block by one indent unit so property comments
- * line up exactly with their property line (mapper indentation contract).
- */
-function indentJsDocBlock(jsDoc) {
-    return jsDoc.split('\n').map((line) => `${INDENT_UNIT}${line}`);
-}
-/**
- * Build the JSDoc block for a query/header parameter property using the
- * pinned parameter merge rule: parameter-level description / deprecated /
- * example win over the schema's; default, title and examples come from the
- * schema only (carried by the spread).
- */
-function buildParamPropertyJsDoc(param, schema) {
-    return buildTypeJsDoc({
-        ...schema,
-        description: param.description ?? schema.description,
-        deprecated: param.deprecated === true || schema.deprecated === true,
-        example: param.example ?? schema.example,
-    });
-}
-/**
- * Render a `${prefix}Query` / `${prefix}Headers` object body in the mapper's
- * multi-line format with per-property JSDoc from the parameter merge rule.
- */
-function buildParamTypeBody(params, mapper) {
-    const lines = [];
-    for (const param of params) {
-        const paramSchema = param.schema ?? { type: 'string' };
-        const result = mapper.mapSchema(paramSchema);
-        const optional = param.required ? '' : '?';
-        const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(param.name) ? param.name : `"${param.name}"`;
-        const jsDoc = buildParamPropertyJsDoc(param, paramSchema);
-        if (jsDoc !== '') {
-            lines.push(...indentJsDocBlock(jsDoc));
-        }
-        lines.push(`${INDENT_UNIT}${key}${optional}: ${result.tsType};`);
-    }
-    return `{\n${lines.join('\n')}\n}`;
-}
-function securitySchemeToTsType(scheme) {
-    const parts = [`type: "${scheme.type}"`];
-    if (scheme.description) {
-        parts.push(`description: "${scheme.description}"`);
-    }
-    if (scheme.type === 'apiKey') {
-        if (scheme.name)
-            parts.push(`name: "${scheme.name}"`);
-        if (scheme.in)
-            parts.push(`in: "${scheme.in}"`);
-    }
-    if (scheme.type === 'http') {
-        if (scheme.scheme)
-            parts.push(`scheme: "${scheme.scheme}"`);
-        if (scheme.bearerFormat)
-            parts.push(`bearerFormat: "${scheme.bearerFormat}"`);
-    }
-    if (scheme.type === 'oauth2' && scheme.flows) {
-        const flowParts = [];
-        const flows = scheme.flows;
-        if (flows.implicit) {
-            flowParts.push(`implicit: ${oAuth2FlowToTs(flows.implicit, true)}`);
-        }
-        if (flows.password) {
-            flowParts.push(`password: ${oAuth2FlowToTs(flows.password, false)}`);
-        }
-        if (flows.clientCredentials) {
-            flowParts.push(`clientCredentials: ${oAuth2FlowToTs(flows.clientCredentials, false)}`);
-        }
-        if (flows.authorizationCode) {
-            flowParts.push(`authorizationCode: ${oAuth2FlowToTs(flows.authorizationCode, true)}`);
-        }
-        parts.push(`flows: { ${flowParts.join('; ')} }`);
-    }
-    if (scheme.type === 'openIdConnect' && scheme.openIdConnectUrl) {
-        parts.push(`openIdConnectUrl: "${scheme.openIdConnectUrl}"`);
-    }
-    return `{ ${parts.join('; ')} }`;
-}
-function oAuth2FlowToTs(flow, hasAuthUrl) {
-    const entries = [];
-    if (hasAuthUrl && flow.authorizationUrl) {
-        entries.push(`authorizationUrl: "${flow.authorizationUrl}"`);
-    }
-    if (flow.tokenUrl) {
-        entries.push(`tokenUrl: "${flow.tokenUrl}"`);
-    }
-    if (flow.refreshUrl) {
-        entries.push(`refreshUrl: "${flow.refreshUrl}"`);
-    }
-    const scopeEntries = Object.entries(flow.scopes)
-        .map(([k, v]) => `"${k}": "${v}"`)
-        .join('; ');
-    entries.push(`scopes: { ${scopeEntries} }`);
-    return `{ ${entries.join('; ')} }`;
-}
-/**
- * Sort ContractEntry list so that referenced types appear before referrers.
- * Uses DFS-based topological sort; cycles are broken by skipping.
- */
-function topologicalSort(entries, allNames) {
-    if (entries.length <= 1)
-        return entries;
-    const nameToIndex = new Map();
-    entries.forEach((e, i) => nameToIndex.set(e.name, i));
-    const graph = new Map();
-    for (let i = 0; i < entries.length; i++) {
-        const deps = new Set();
-        const def = entries[i].definition;
-        for (const name of allNames) {
-            if (name === entries[i].name)
-                continue;
-            if (new RegExp(`\\b${name}\\b`).test(def)) {
-                const depIdx = nameToIndex.get(name);
-                if (depIdx !== undefined) {
-                    deps.add(depIdx);
-                }
-            }
-        }
-        graph.set(i, deps);
-    }
-    const sorted = [];
-    const visited = new Set();
-    const inStack = new Set();
-    function visit(idx) {
-        if (visited.has(idx))
-            return;
-        if (inStack.has(idx))
-            return;
-        inStack.add(idx);
-        const deps = graph.get(idx);
-        if (deps) {
-            for (const dep of deps) {
-                visit(dep);
-            }
-        }
-        inStack.delete(idx);
-        visited.add(idx);
-        sorted.push(entries[idx]);
-    }
-    for (let i = 0; i < entries.length; i++) {
-        visit(i);
-    }
-    return sorted;
-}
+import { DEFAULT_RUNTIME_IMPORT_PATH, makeHeader } from '../utils/generator-helpers.js';
+import { RUNTIME_CLASS_NAMES } from '../utils/operation-naming.js';
 /**
  * Build the import + re-export block for the shared runtime classes.
  * Generated code re-uses the genoc runtime as the single source of truth
@@ -218,315 +10,86 @@ function buildRuntimeReexport(runtimeImportPath) {
         '',
         `import { ApiError, StreamResponse } from '${runtimeImportPath}';`,
         'export {',
-        '  ApiError,',
-        '  UnspecifiedApiError,',
-        '  DefaultApiError,',
-        '  RequesterFailError,',
-        '  StreamResponse,',
-        '  ErrorResponse,',
+        ...RUNTIME_CLASS_NAMES.map((name) => `  ${name},`),
         `} from '${runtimeImportPath}';`,
     ];
 }
 /**
- * Generate the complete `*.contracts.ts` file content as a string.
+ * Render the complete `*.contracts.ts` file content from the analyzed model.
+ * Pure string assembly — reads ONLY the AnalyzedSpec, never the raw spec or
+ * a resolver.
  *
  * Sections produced:
  * 1. Header comment
- * 2. Schema types from `components/schemas`
- * 3. Query parameter types per operation
- * 4. Header parameter types per operation
- * 5. Request body types per operation
- * 6. Response / error types per operation
+ * 2. Schema types from `components/schemas` (finished model entries)
+ * 3. Security scheme types (finished model entries; `SecuritySchemes` union
+ *    when more than one)
+ * 4. Server variable types (finished model entries)
+ * 5. `FileInput` when any operation uploads files
+ * 6. Operation-derived types (finished emission lines from the model)
  * 7. Runtime re-export block (shared classes from the genoc runtime package)
  */
-export function generateContracts(doc, resolver, runtimeImportPath = DEFAULT_RUNTIME_IMPORT_PATH) {
-    const schemaNameList = doc.components?.schemas ? Object.keys(doc.components.schemas) : [];
-    const renameMap = buildSchemaRenameMap(schemaNameList, RESERVED_TYPE_NAMES);
-    for (const [original, renamed] of renameMap) {
-        // TODO: Replace with structured logging solution
-        // oxlint-disable-next-line no-console
-        console.warn(`Warning: Schema "${original}" collides with a built-in type and was renamed to "${renamed}".`);
-    }
-    const renamingTypeGenerator = (refString) => {
-        const segments = refString.split('/');
-        const rawSegment = segments[segments.length - 1] || 'unknown';
-        const lastSegment = sanitizeTypeName(rawSegment);
-        return renameMap.get(lastSegment) ?? lastSegment;
-    };
-    const discriminatorInfo = new Map();
-    if (doc.components?.schemas) {
-        for (const [name, schema] of Object.entries(doc.components.schemas)) {
-            const resolved = resolver.resolve(schema);
-            if (resolved.discriminator) {
-                const mapping = new Map();
-                if (resolved.discriminator.mapping) {
-                    for (const [key, ref] of Object.entries(resolved.discriminator.mapping)) {
-                        const targetName = sanitizeTypeName(ref.split('/').pop() || key);
-                        const renamedTarget = renameMap.get(targetName) ?? targetName;
-                        mapping.set(key, renamedTarget);
-                    }
-                }
-                discriminatorInfo.set(sanitizeTypeName(name), {
-                    propertyName: resolved.discriminator.propertyName,
-                    mapping,
-                });
-            }
-        }
-    }
-    const discriminatorTargets = new Map();
-    for (const [, info] of discriminatorInfo) {
-        for (const [mappingKey, schemaName] of info.mapping) {
-            discriminatorTargets.set(schemaName, {
-                propertyName: info.propertyName,
-                literalValue: mappingKey,
-            });
-        }
-    }
-    const allSchemaNames = new Set();
-    if (doc.components?.schemas) {
-        for (const name of Object.keys(doc.components.schemas)) {
-            allSchemaNames.add(sanitizeTypeName(name));
-        }
-    }
-    const mapper = new SchemaMapper(resolver, renamingTypeGenerator, discriminatorTargets, allSchemaNames);
+export function renderContracts(analyzed, runtimeImportPath = DEFAULT_RUNTIME_IMPORT_PATH) {
     const lines = [];
-    lines.push(makeHeader(doc.openapi));
+    lines.push(makeHeader(analyzed.specVersion));
     const runtimeReexport = buildRuntimeReexport(runtimeImportPath);
     lines.push(...runtimeReexport);
-    // Section 1: Schema types
-    const schemaEntries = [];
-    if (doc.components?.schemas) {
-        for (const [name, schema] of Object.entries(doc.components.schemas)) {
-            const sanitizedName = sanitizeTypeName(name);
-            const renamedName = renameMap.get(sanitizedName) ?? sanitizedName;
-            const result = mapper.mapSchema(schema, sanitizedName);
-            const resolved = resolver.resolve(schema);
-            const definition = `export type ${renamedName} = ${result.tsType};`;
-            schemaEntries.push({
-                name: renamedName,
-                kind: 'type',
-                definition,
-                jsDoc: buildTypeJsDoc(resolved) || undefined,
-            });
-        }
-    }
-    const sortedSchemas = topologicalSort(schemaEntries, allSchemaNames);
-    for (const entry of sortedSchemas) {
+    // Section 1: Schema types (finished entries; emission order — topologically
+    // sorted schemas, then discriminator variant unions — was fixed by analyze()).
+    for (const entry of analyzed.schemaTypes) {
         lines.push('');
         if (entry.jsDoc) {
             lines.push(entry.jsDoc);
         }
         lines.push(entry.definition);
     }
-    for (const [baseName, info] of discriminatorInfo) {
-        const subtypeNames = Array.from(info.mapping.values());
-        if (subtypeNames.length === 0)
-            continue;
-        const unionType = subtypeNames.join(' | ');
-        const renamedBase = renameMap.get(sanitizeTypeName(baseName)) ?? sanitizeTypeName(baseName);
-        lines.push('');
-        lines.push(`export type ${renamedBase}Variant = ${unionType};`);
-        allSchemaNames.add(`${renamedBase}Variant`);
-    }
-    // Section 1b: Security scheme types
-    const securitySchemes = doc.components?.securitySchemes;
-    if (securitySchemes && Object.keys(securitySchemes).length > 0) {
-        const securityTypeNames = [];
-        for (const [schemeName, scheme] of Object.entries(securitySchemes)) {
-            const typeName = `${toPascalCase(schemeName)}Auth`;
-            const tsType = securitySchemeToTsType(scheme);
-            const schemeJsDoc = buildDescriptionJsDoc(scheme.description);
-            if (schemeJsDoc !== '') {
+    // Section 1b: Security scheme types (finished entries in spec key order)
+    if (analyzed.securitySchemeTypes.length > 0) {
+        for (const entry of analyzed.securitySchemeTypes) {
+            if (entry.jsDoc !== '') {
                 lines.push('');
-                lines.push(schemeJsDoc);
+                lines.push(entry.jsDoc);
             }
             lines.push('');
-            lines.push(`export type ${typeName} = ${tsType};`);
-            securityTypeNames.push(typeName);
+            lines.push(`export type ${entry.name} = ${entry.tsType};`);
         }
-        if (securityTypeNames.length > 1) {
+        if (analyzed.securitySchemeTypes.length > 1) {
+            const unionMembers = analyzed.securitySchemeTypes.map((entry) => entry.name).join(' | ');
             lines.push('');
-            lines.push(`export type SecuritySchemes = ${securityTypeNames.join(' | ')};`);
+            lines.push(`export type SecuritySchemes = ${unionMembers};`);
         }
     }
-    // Section 1c: Server variable types
-    if (doc.servers) {
-        for (let serverIdx = 0; serverIdx < doc.servers.length; serverIdx++) {
-            const server = doc.servers[serverIdx];
-            if (!server.variables || Object.keys(server.variables).length === 0) {
-                continue;
-            }
-            const typeName = doc.servers.length === 1 ? 'ServerParams' : `Server${serverIdx + 1}Params`;
-            const props = [];
-            for (const [varName, variable] of Object.entries(server.variables)) {
-                const sv = variable;
-                const jsDocParts = [];
-                if (sv.description) {
-                    const description = sanitizeJsDocText(sv.description);
-                    if (description !== '') {
-                        jsDocParts.push(description);
-                    }
-                }
-                if (sv.default !== undefined) {
-                    jsDocParts.push(`@default ${sanitizeJsDocText(String(sv.default))}`);
-                }
-                let tsType;
-                if (sv.enum && sv.enum.length > 0) {
-                    tsType = sv.enum.map((v) => `"${v}"`).join(' | ');
-                }
-                else {
-                    tsType = 'string';
-                }
-                const jsDoc = jsDocParts.length > 0 ? `  /** ${jsDocParts.join(' ')} */` : null;
-                if (jsDoc) {
-                    props.push(jsDoc);
-                }
-                props.push(`  ${varName}: ${tsType};`);
-            }
-            lines.push('');
-            if (server.url) {
-                lines.push(`/** Server: ${server.url} */`);
-            }
-            lines.push(`export interface ${typeName} {`);
-            for (const prop of props) {
-                lines.push(prop);
-            }
-            lines.push('}');
+    // Section 1c: Server variable types (finished entries in spec order)
+    for (const entry of analyzed.serverTypes) {
+        lines.push('');
+        if (entry.url) {
+            lines.push(`/** Server: ${entry.url} */`);
+        }
+        lines.push(`export interface ${entry.name} {`);
+        for (const prop of entry.propertyLines) {
+            lines.push(prop);
         }
+        lines.push('}');
     }
-    const operations = analyzePaths(doc, resolver);
-    const hasFileUpload = operations.some((op) => op.requestBody?.isMultipart);
-    if (hasFileUpload) {
+    if (analyzed.hasFileUpload) {
         lines.push('');
         lines.push('export interface FileInput {');
         lines.push('  data: Blob;');
         lines.push('  filename: string;');
         lines.push('}');
     }
-    // Sections 2-4: Operation-derived types
-    for (const op of operations) {
-        const prefix = getOperationTypePrefix(op);
-        const opLines = [];
-        // Section 2: Query parameter types
-        if (op.queryParams.length > 0) {
-            opLines.push(`export type ${prefix}Query = ${buildParamTypeBody(op.queryParams, mapper)};`);
-        }
-        // Section 2b: Header parameter types
-        if (op.headerParams.length > 0) {
-            opLines.push(`export type ${prefix}Headers = ${buildParamTypeBody(op.headerParams, mapper)};`);
-        }
-        // Section 3: Request body types
-        const bodyJsDoc = op.requestBody ? buildDescriptionJsDoc(op.requestBody.description) : '';
-        if (op.requestBody?.isMultipart && op.requestBody.schema) {
-            const schema = resolver.resolveSchema(op.requestBody.schema);
-            const requiredSet = new Set(schema.required ?? []);
-            const propLines = [];
-            for (const [name, propSchema] of Object.entries(schema.properties ?? {})) {
-                const resolved = resolver.resolveSchema(propSchema);
-                const optional = requiredSet.has(name) ? '' : '?';
-                let tsType;
-                if (resolved.format === 'binary') {
-                    tsType = 'FileInput';
-                }
-                else if (resolved.type === 'array' && resolved.items?.format === 'binary') {
-                    tsType = 'FileInput[]';
-                }
-                else {
-                    tsType = 'string';
-                }
-                const jsDoc = buildTypeJsDoc(resolved);
-                if (jsDoc !== '') {
-                    propLines.push(...indentJsDocBlock(jsDoc));
-                }
-                propLines.push(`${INDENT_UNIT}${name}${optional}: ${tsType};`);
-            }
-            if (propLines.length > 0) {
-                opLines.push(attachTypeJsDoc(bodyJsDoc, `export type ${prefix}Body = {\n${propLines.join('\n')}\n};`));
-            }
-            else {
-                opLines.push(attachTypeJsDoc(bodyJsDoc, `export type ${prefix}Body = Record<string, never>;`));
-            }
-        }
-        else if (op.requestBody?.schema) {
-            const hasBinaryContentType = op.requestBody.contentTypes.some(isBinaryContentType);
-            if (hasBinaryContentType) {
-                opLines.push(attachTypeJsDoc(bodyJsDoc, `export type ${prefix}Body = Blob;`));
-            }
-            else {
-                const result = mapper.mapSchema(op.requestBody.schema, undefined, 'request');
-                opLines.push(attachTypeJsDoc(bodyJsDoc, `export type ${prefix}Body = ${result.tsType};`));
-            }
-        }
-        // Section 4: Response types
-        const successResponses = op.responses.filter((r) => r.isSuccess);
-        const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');
-        const defaultResponse = op.responses.find((r) => !r.isSuccess && r.statusCode === 'default');
-        // Success type
-        if (successResponses.length > 0) {
-            const types = successResponses.map((r) => {
-                if (r.isBinary)
-                    return 'StreamResponse';
-                if (r.schema) {
-                    const result = mapper.mapSchema(r.schema, undefined, 'response').tsType;
-                    return substituteDiscriminatedType(result, r.schema, discriminatorInfo, renameMap);
-                }
-                return r.tsType;
-            });
-            const successType = types.length === 1 ? types[0] : types.join(' | ');
-            // Type-level JSDoc from the lowest-numbered 2xx response (the analyzer
-            // returns success responses in ascending status order).
-            const responseJsDoc = buildDescriptionJsDoc(successResponses[0].description);
-            opLines.push(attachTypeJsDoc(responseJsDoc, `export type ${prefix}Response = ${successType};`));
-        }
-        // Error types per status
-        const errorTypes = [];
-        for (const err of errorResponses) {
-            const errorTypeName = `${prefix}Error${err.statusCode}`;
-            let errorTsType;
-            if (err.isBinary) {
-                errorTsType = 'StreamResponse';
-            }
-            else if (err.schema) {
-                errorTsType = mapper.mapSchema(err.schema, undefined, 'response').tsType;
-            }
-            else {
-                errorTsType = err.tsType;
-            }
-            opLines.push(`export type ${errorTypeName} = ${errorTsType};`);
-            errorTypes.push({ status: err.statusCode, typeName: errorTypeName });
-        }
-        // Default response error type
-        if (defaultResponse) {
-            const defaultTypeName = `${prefix}DefaultError`;
-            let defaultTsType;
-            if (defaultResponse.isBinary) {
-                defaultTsType = 'StreamResponse';
-            }
-            else if (defaultResponse.schema) {
-                defaultTsType = mapper.mapSchema(defaultResponse.schema, undefined, 'response').tsType;
-            }
-            else {
-                defaultTsType = 'unknown';
-            }
-            opLines.push(`export type ${defaultTypeName} = ${defaultTsType};`);
-        }
-        // Error union
-        if (errorTypes.length > 0) {
-            const unionParts = errorTypes.map((e) => `ApiError<${e.status}, ${e.typeName}>`);
-            opLines.push(`export type ${prefix}Errors = ${unionParts.join(' | ')};`);
-        }
-        if (opLines.length > 0) {
-            for (const line of opLines) {
-                lines.push('');
-                lines.push(line);
-            }
+    // Sections 2-4: Operation-derived types (finished emission lines assembled
+    // by analyze(); spilled unchanged with a blank line before each).
+    for (const op of analyzed.operations) {
+        for (const line of op.contractsLines) {
+            lines.push('');
+            lines.push(line);
         }
     }
     // Emit branded type definitions after header, before everything else
-    const brandedTypes = mapper.getBrandedTypes();
-    if (brandedTypes.size > 0) {
+    if (analyzed.brandedTypes.length > 0) {
         const brandLines = [];
-        for (const brand of brandedTypes.values()) {
+        for (const brand of analyzed.brandedTypes) {
             brandLines.push(`export type ${brand.name} = ${brand.baseType} & { readonly __format?: '${brand.format}' };`);
         }
         lines.splice(1 + runtimeReexport.length, 0, '', ...brandLines);

package/dist/generator/method-generator.d.ts

@@ -4,6 +4,6 @@ import type { GeneratedMethod } from '../types/client.js';
  * Generate a client method from an analyzed OpenAPI operation.
  *
  * @param op - The analyzed operation
- * @returns Generated method with name, JSDoc, signature, and implementation
+ * @returns Generated method with name, JSDoc, and signature
  */
 export declare function generateMethod(op: AnalyzedOperation): GeneratedMethod;