{"version":3,"file":"generateClientMethod-B8zYb-98.cjs","names":[],"sources":["../src/helpers/mimeTypes.ts","../src/helpers/getFormatter.ts","../src/helpers/callQsFunction.ts","../src/helpers/createUrlExpression.ts","../src/helpers/callOazapftsFunction.ts","../src/helpers/getBodyFormatter.ts","../src/helpers/wrapResult.ts","../src/helpers/findAvailableRef.ts","../src/helpers/isNamedEnumSchema.ts","../src/helpers/getEnumStyle.ts","../src/helpers/getUniqueAlias.ts","../src/helpers/getEnumUniqueAlias.ts","../src/helpers/getCustomNames.ts","../src/helpers/checkSchemaOnlyMode.ts","../src/helpers/isNullable.ts","../src/helpers/isHttpMethod.ts","../src/helpers/emptySchemaType.ts","../src/generate/getTypeFromSchema/getTrueEnum.ts","../src/generate/getTypeFromSchema/getAsConstEnum.ts","../src/generate/getTypeFromSchema/getTypeFromEnum.ts","../src/generate/getTypeFromSchema/getDiscriminatorType.ts","../src/generate/getTypeFromSchema/getUnionType.ts","../src/generate/getTypeFromSchema/getTypeFromProperties.ts","../src/generate/getTypeFromSchema/getTypeFromSchema.ts","../src/generate/getRefAlias.ts","../src/generate/preprocessComponents.ts","../src/generate/generateApi.ts","../src/generate/createDefaultsStatement.ts","../src/generate/generateImports.ts","../src/generate/getSchemaFromContent.ts","../src/generate/getTypeFromParameter.ts","../src/generate/getResponseType.ts","../src/generate/getTypeFromResponses.ts","../src/generate/getOperationName.ts","../src/generate/generateClientMethod.ts"],"sourcesContent":["export type ContentType = \"json\" | \"form\" | \"multipart\";\n\nexport const contentTypes: Record<string, ContentType> = {\n  \"*/*\": \"json\",\n  \"application/json\": \"json\",\n  \"application/x-www-form-urlencoded\": \"form\",\n  \"multipart/form-data\": \"multipart\",\n};\n\nexport function isMimeType(s: unknown) {\n  return typeof s === \"string\" && /^[^/]+\\/[^/]+$/.test(s);\n}\n\nexport function isJsonMimeType(mime: string) {\n  return contentTypes[mime] === \"json\" || /\\bjson\\b/i.test(mime);\n}\n","import { ParameterObject } from \"./openApi3-x\";\nimport { isJsonMimeType } from \"./mimeTypes\";\n\n/**\n * Get the name of a formatter function for a given parameter.\n */\nexport function getFormatter({\n  style = \"form\",\n  explode = true,\n  content,\n}: ParameterObject) {\n  if (content) {\n    const medias = Object.keys(content);\n    if (medias.length !== 1) {\n      throw new Error(\n        \"Parameters with content property must specify one media type\",\n      );\n    }\n    if (!isJsonMimeType(medias[0])) {\n      throw new Error(\n        \"Parameters with content property must specify a JSON compatible media type\",\n      );\n    }\n    return \"json\";\n  }\n  if (explode && style === \"deepObject\") return \"deep\";\n  if (explode) return \"explode\";\n  if (style === \"spaceDelimited\") return \"space\";\n  if (style === \"pipeDelimited\") return \"pipe\";\n  return \"form\";\n}\n","import ts from \"typescript\";\nimport { createCall } from \"../generate/tscodegen\";\n\n/**\n * Create a call expression for one of the QS runtime functions.\n */\nexport function callQsFunction(name: string, args: ts.Expression[]) {\n  return createCall(\n    ts.factory.createPropertyAccessExpression(\n      ts.factory.createIdentifier(\"QS\"),\n      name,\n    ),\n    { args },\n  );\n}\n","import ts from \"typescript\";\nimport { toIdentifier } from \"./toIdentifier\";\nimport { createCall, createTemplateString } from \"../generate/tscodegen\";\n\n/**\n * Create a template string literal from the given OpenAPI urlTemplate.\n * Curly braces in the path are turned into identifier expressions,\n * which are read from the local scope during runtime.\n */\nexport function createUrlExpression(path: string, qs?: ts.Expression) {\n  const spans: Array<{ expression: ts.Expression; literal: string }> = [];\n  // Use a replacer function to collect spans as a side effect:\n  const head = path.replace(\n    /(.*?)\\{(.+?)\\}(.*?)(?=\\{|$)/g,\n    (_substr, head, name, literal) => {\n      const expression = toIdentifier(name);\n      spans.push({\n        expression: createCall(\n          ts.factory.createIdentifier(\"encodeURIComponent\"),\n          {\n            args: [ts.factory.createIdentifier(expression)],\n          },\n        ),\n        literal,\n      });\n      return head;\n    },\n  );\n\n  if (qs) {\n    // add the query string as last span\n    spans.push({ expression: qs, literal: \"\" });\n  }\n  return createTemplateString(head, spans);\n}\n","import ts from \"typescript\";\nimport { createCall } from \"../generate/tscodegen\";\n\n/**\n * Create a call expression for one of the oazapfts runtime functions.\n */\nexport function callOazapftsFunction(\n  name: string,\n  args: ts.Expression[],\n  typeArgs?: ts.TypeNode[],\n) {\n  return createCall(\n    ts.factory.createPropertyAccessExpression(\n      ts.factory.createIdentifier(\"oazapfts\"),\n      name,\n    ),\n    { args, typeArgs },\n  );\n}\n","import { RequestBodyObject } from \"./openApi3-x\";\nimport { contentTypes, isJsonMimeType } from \"./mimeTypes\";\n\nexport function getBodyFormatter(body?: RequestBodyObject) {\n  if (body?.content) {\n    for (const contentType of Object.keys(body.content)) {\n      const formatter = contentTypes[contentType];\n      if (formatter) return formatter;\n      if (isJsonMimeType(contentType)) return \"json\";\n    }\n  }\n}\n","import ts from \"typescript\";\nimport { OazapftsContext } from \"../context\";\nimport { callOazapftsFunction } from \"./callOazapftsFunction\";\n\nexport function wrapResult(ex: ts.Expression, ctx: OazapftsContext) {\n  return ctx.opts?.optimistic ? callOazapftsFunction(\"ok\", [ex]) : ex;\n}\n","import { OazapftsContext } from \"../context\";\nimport { resolve } from \"@oazapfts/resolve\";\n\nexport function findAvailableRef(ref: string, ctx: OazapftsContext) {\n  const available = (ref: string) => {\n    try {\n      resolve({ $ref: ref }, ctx);\n      return false;\n    } catch (error) {\n      return true;\n    }\n  };\n\n  if (available(ref)) return ref;\n\n  let i = 2;\n  while (true) {\n    const key = ref + String(i);\n    if (available(key)) return key;\n    i += 1;\n  }\n}\n","import { SchemaObject } from \"./openApi3-x\";\n\n/**\n * Check if a schema is suitable for generating a named enum declaration\n * (has enum values, has a name, and is not a boolean type).\n */\nexport function isNamedEnumSchema(\n  schema: SchemaObject,\n  name?: string,\n): name is string {\n  return Boolean(\n    typeof schema !== \"boolean\" &&\n    schema.enum &&\n    name &&\n    schema.type !== \"boolean\",\n  );\n}\n","export const enumStyleOptions = [\"union\", \"enum\", \"as-const\"] as const;\nexport type EnumStyle = (typeof enumStyleOptions)[number];\n\n/**\n * Resolve the effective enum style from options.\n * `enumStyle` takes precedence over the deprecated `useEnumType`.\n */\nexport function getEnumStyle(opts: {\n  enumStyle?: EnumStyle;\n  useEnumType?: boolean;\n}): EnumStyle {\n  if (opts.enumStyle !== undefined) return opts.enumStyle;\n  if (opts.useEnumType) return \"enum\";\n  return \"union\";\n}\n","import { OazapftsContext } from \"../context\";\n\nexport function getUniqueAlias(name: string, ctx: OazapftsContext) {\n  let used = ctx.typeAliases[name] || 0;\n  if (used) {\n    ctx.typeAliases[name] = ++used;\n    name += used;\n  }\n\n  ctx.typeAliases[name] = 1;\n  return name;\n}\n","import { OazapftsContext } from \"../context\";\nimport { getUniqueAlias } from \"./getUniqueAlias\";\n\n/**\n * Return a unique alias for an enum declaration.\n * Reuses the existing name when the same enum values have already been registered.\n */\nexport function getEnumUniqueAlias(\n  name: string,\n  values: string,\n  ctx: OazapftsContext,\n) {\n  if (ctx.enumRefs[name] && ctx.enumRefs[name].values === values) {\n    return name;\n  }\n\n  return getUniqueAlias(name, ctx);\n}\n","import { SchemaObject } from \"./openApi3-x\";\n\n/**\n * Extract custom member names from `x-enumNames` or `x-enum-varnames` extensions.\n * Returns `undefined` when neither extension is present.\n */\nexport function getCustomNames(\n  schema: Exclude<SchemaObject, boolean>,\n  values: unknown[],\n) {\n  const names =\n    \"x-enumNames\" in schema\n      ? schema[\"x-enumNames\"]\n      : \"x-enum-varnames\" in schema\n        ? schema[\"x-enum-varnames\"]\n        : undefined;\n\n  if (names) {\n    if (!Array.isArray(names)) {\n      throw new Error(\"enum names must be an array\");\n    }\n    if (names.length !== values.length) {\n      throw new Error(\"enum names must have the same length as enum values\");\n    }\n    if (names.some((name) => typeof name !== \"string\")) {\n      throw new Error(\"enum names must be an array of strings\");\n    }\n    return names as string[];\n  }\n\n  return undefined;\n}\n","import { isReference, resolve } from \"@oazapfts/resolve\";\nimport { OazapftsContext, OnlyModes } from \"../context\";\nimport { ReferenceObject, SchemaObject } from \"./openApi3-x\";\n\n/**\n * Checks if readOnly/writeOnly properties are present in the given schema.\n * Returns a tuple of booleans; the first one is about readOnly, the second\n * one is about writeOnly.\n */\nexport function checkSchemaOnlyMode(\n  schema: SchemaObject | ReferenceObject,\n  ctx: OazapftsContext,\n  resolveRefs = true,\n): OnlyModes {\n  if (ctx.opts.mergeReadWriteOnly) {\n    return { readOnly: false, writeOnly: false };\n  }\n\n  const check = (\n    schema: SchemaObject | ReferenceObject,\n    history: Set<string>,\n  ): OnlyModes => {\n    if (isReference(schema)) {\n      if (!resolveRefs) return { readOnly: false, writeOnly: false };\n\n      // history is used to prevent infinite recursion\n      if (history.has(schema.$ref))\n        return { readOnly: false, writeOnly: false };\n\n      // check if the result is cached in `this.refsOnlyMode`\n      const cached = ctx.refsOnlyMode.get(schema.$ref);\n      if (cached) return cached;\n\n      history.add(schema.$ref);\n      const ret = check(resolve(schema, ctx), history);\n      history.delete(schema.$ref);\n\n      // cache the result\n      ctx.refsOnlyMode.set(schema.$ref, ret);\n\n      return ret;\n    }\n\n    if (typeof schema === \"boolean\") {\n      return { readOnly: false, writeOnly: false };\n    }\n\n    let readOnly = schema.readOnly ?? false;\n    let writeOnly = schema.writeOnly ?? false;\n\n    const subSchemas: (ReferenceObject | SchemaObject)[] = [];\n    if (\"items\" in schema && schema.items) {\n      subSchemas.push(schema.items);\n    } else {\n      subSchemas.push(...Object.values(schema.properties ?? {}));\n      subSchemas.push(...(schema.allOf ?? []));\n      subSchemas.push(...(schema.anyOf ?? []));\n      subSchemas.push(...(schema.oneOf ?? []));\n    }\n\n    for (const schema of subSchemas) {\n      // `readOnly` and `writeOnly` do not change once they become true,\n      // so you can exit early if both are true.\n      if (readOnly && writeOnly) break;\n\n      const result = check(schema, history);\n      readOnly = readOnly || result.readOnly;\n      writeOnly = writeOnly || result.writeOnly;\n    }\n\n    return { readOnly, writeOnly };\n  };\n\n  return check(schema, new Set<string>());\n}\n","import { isReference } from \"@oazapfts/resolve\";\nimport { ReferenceObject, SchemaObject } from \"./openApi3-x\";\n\nexport function isNullable(schema?: SchemaObject | ReferenceObject) {\n  if (typeof schema === \"boolean\") return schema;\n\n  if (schema && \"nullable\" in schema)\n    return !isReference(schema) && schema.nullable;\n\n  return false;\n}\n","const HttpMethods = [\n  \"GET\",\n  \"PUT\",\n  \"POST\",\n  \"DELETE\",\n  \"OPTIONS\",\n  \"HEAD\",\n  \"PATCH\",\n  \"TRACE\",\n] as const;\nexport type HttpMethod = (typeof HttpMethods)[number];\n\nexport function isHttpMethod(method: string): method is HttpMethod {\n  return HttpMethods.includes(method as HttpMethod);\n}\n","import { OazapftsContext } from \"../context\";\nimport * as cg from \"../generate/tscodegen\";\n\nexport function getEmptySchemaType(ctx: OazapftsContext) {\n  return ctx.opts.useUnknown ? cg.keywordType.unknown : cg.keywordType.any;\n}\n","import ts from \"typescript\";\nimport _ from \"lodash\";\nimport { OazapftsContext } from \"../../context\";\nimport { SchemaObject } from \"../../helpers/openApi3-x\";\nimport * as cg from \"../tscodegen\";\nimport * as h from \"../../helpers\";\nimport { getEnumUniqueAlias } from \"../../helpers/getEnumUniqueAlias\";\nimport { getCustomNames } from \"../../helpers/getCustomNames\";\n\n/**\n * Creates a enum \"ref\" if not used, reuse existing if values and name matches or creates a new one\n * with a new name adding a number\n */\nexport function getTrueEnum(\n  schema: SchemaObject,\n  propName: string,\n  ctx: OazapftsContext,\n) {\n  if (typeof schema === \"boolean\") {\n    // this should never be thrown, since `getTrueEnum` calls are\n    // behind an `isNamedEnumSchema` check, which returns false for boolean schemas.\n    throw new Error(\n      \"cannot get enum from boolean schema. schema must be an object\",\n    );\n  }\n  const baseName = schema.title || _.upperFirst(propName);\n  // TODO: use _.camelCase in future major version\n  // (currently we allow _ and $ for backwards compatibility)\n  const proposedName = baseName\n    .split(/[^A-Za-z0-9$_]/g)\n    .map((n) => _.upperFirst(n))\n    .join(\"\");\n  const stringEnumValue = (schema.enum ?? []).join(\"_\");\n\n  const name = getEnumUniqueAlias(proposedName, stringEnumValue, ctx);\n\n  if (ctx.enumRefs[proposedName] && proposedName === name) {\n    return ctx.enumRefs[proposedName].type;\n  }\n\n  const values = schema.enum ? schema.enum : [];\n\n  const names = getCustomNames(schema, values);\n\n  const members = values.map((s, index) => {\n    if (\n      schema.type === \"number\" ||\n      schema.type === \"integer\" ||\n      schema.type === \"string\"\n    ) {\n      const name = names ? names[index] : String(s);\n      return ts.factory.createEnumMember(\n        ts.factory.createIdentifier(h.toIdentifier(name, true)),\n        cg.createLiteral(s),\n      );\n    }\n    return ts.factory.createEnumMember(\n      ts.factory.createIdentifier(h.toIdentifier(String(s), true)),\n      cg.createLiteral(s),\n    );\n  });\n  ctx.enumAliases.push(\n    ts.factory.createEnumDeclaration([cg.modifier.export], name, members),\n  );\n\n  const type = ts.factory.createTypeReferenceNode(name, undefined);\n\n  ctx.enumRefs[proposedName] = {\n    values: stringEnumValue,\n    type: ts.factory.createTypeReferenceNode(name, undefined),\n  };\n\n  return type;\n}\n","import ts from \"typescript\";\nimport _ from \"lodash\";\nimport { OazapftsContext } from \"../../context\";\nimport { SchemaObject } from \"../../helpers/openApi3-x\";\nimport * as cg from \"../tscodegen\";\nimport * as h from \"../../helpers\";\nimport { getEnumUniqueAlias } from \"../../helpers/getEnumUniqueAlias\";\nimport { getCustomNames } from \"../../helpers/getCustomNames\";\n\n/**\n * Creates an `as const` object declaration with a companion type alias.\n *\n * Generates:\n * ```\n * export const Name = { A: 'a', B: 'b' } as const;\n * export type Name = (typeof Name)[keyof typeof Name];\n * ```\n */\nexport function getAsConstEnum(\n  schema: SchemaObject,\n  propName: string,\n  ctx: OazapftsContext,\n) {\n  if (typeof schema === \"boolean\") {\n    throw new Error(\n      \"cannot get enum from boolean schema. schema must be an object\",\n    );\n  }\n\n  const baseName = schema.title || _.upperFirst(propName);\n  const proposedName = baseName\n    .split(/[^A-Za-z0-9$_]/g)\n    .map((n) => _.upperFirst(n))\n    .join(\"\");\n  const stringEnumValue = (schema.enum ?? []).join(\"_\");\n\n  const name = getEnumUniqueAlias(proposedName, stringEnumValue, ctx);\n\n  if (ctx.enumRefs[proposedName] && proposedName === name) {\n    return ctx.enumRefs[proposedName].type;\n  }\n\n  const values = schema.enum ? schema.enum : [];\n  const names = getCustomNames(schema, values);\n\n  const properties = values.map((s, index) => {\n    if (\n      schema.type === \"number\" ||\n      schema.type === \"integer\" ||\n      schema.type === \"string\"\n    ) {\n      const memberName = names ? names[index] : String(s);\n      return ts.factory.createPropertyAssignment(\n        ts.factory.createIdentifier(h.toIdentifier(memberName, true)),\n        cg.createLiteral(s),\n      );\n    }\n    return ts.factory.createPropertyAssignment(\n      ts.factory.createIdentifier(h.toIdentifier(String(s), true)),\n      cg.createLiteral(s),\n    );\n  });\n\n  // export const Name = { ... } as const;\n  const constStatement = ts.factory.createVariableStatement(\n    [cg.modifier.export],\n    ts.factory.createVariableDeclarationList(\n      [\n        ts.factory.createVariableDeclaration(\n          name,\n          undefined,\n          undefined,\n          ts.factory.createAsExpression(\n            ts.factory.createObjectLiteralExpression(properties, true),\n            ts.factory.createTypeReferenceNode(\"const\"),\n          ),\n        ),\n      ],\n      ts.NodeFlags.Const,\n    ),\n  );\n\n  // export type Name = (typeof Name)[keyof typeof Name];\n  const typeStatement = cg.createTypeAliasDeclaration({\n    modifiers: [cg.modifier.export],\n    name,\n    type: ts.factory.createIndexedAccessTypeNode(\n      ts.factory.createParenthesizedType(\n        ts.factory.createTypeQueryNode(ts.factory.createIdentifier(name)),\n      ),\n      ts.factory.createTypeOperatorNode(\n        ts.SyntaxKind.KeyOfKeyword,\n        ts.factory.createTypeQueryNode(ts.factory.createIdentifier(name)),\n      ),\n    ),\n  });\n\n  ctx.enumAliases.push(constStatement, typeStatement);\n\n  const type = ts.factory.createTypeReferenceNode(name, undefined);\n\n  ctx.enumRefs[proposedName] = {\n    values: stringEnumValue,\n    type,\n  };\n\n  return type;\n}\n","import ts from \"typescript\";\nimport { keywordType } from \"../tscodegen\";\n\n/**\n * Creates literal type (or union) from an array of values\n */\nexport function getTypeFromEnum(values: unknown[]) {\n  const types = values.map((s) => {\n    if (s === null) return keywordType.null;\n    if (typeof s === \"boolean\")\n      return s\n        ? ts.factory.createLiteralTypeNode(\n            ts.factory.createToken(ts.SyntaxKind.TrueKeyword),\n          )\n        : ts.factory.createLiteralTypeNode(\n            ts.factory.createToken(ts.SyntaxKind.FalseKeyword),\n          );\n    if (typeof s === \"number\")\n      return ts.factory.createLiteralTypeNode(\n        ts.factory.createNumericLiteral(s),\n      );\n    if (typeof s === \"string\")\n      return ts.factory.createLiteralTypeNode(\n        ts.factory.createStringLiteral(s),\n      );\n    throw new Error(`Unexpected ${String(s)} of type ${typeof s} in enum`);\n  });\n  return types.length > 1 ? ts.factory.createUnionTypeNode(types) : types[0];\n}\n","import ts, { factory } from \"typescript\";\nimport { resolve } from \"@oazapfts/resolve\";\nimport { OazapftsContext } from \"../../context\";\nimport { getEnumStyle, isNamedEnumSchema, toIdentifier } from \"../../helpers\";\nimport * as OpenApi from \"../../helpers/openApi3-x\";\nimport { getTrueEnum } from \"./getTrueEnum\";\nimport { getAsConstEnum } from \"./getAsConstEnum\";\nimport { getTypeFromEnum } from \"./getTypeFromEnum\";\n\n/**\n * Get enum member reference type for discriminator values when enumStyle is \"enum\" or \"as-const\"\n */\nexport function getDiscriminatorType(\n  ctx: OazapftsContext,\n  discriminatingSchemaRef:\n    | Exclude<OpenApi.SchemaObject, boolean>\n    | OpenApi.ReferenceObject,\n  propertyName: string,\n  matches: string[],\n) {\n  const enumStyle = getEnumStyle(ctx.opts);\n  if (enumStyle === \"union\") {\n    return getTypeFromEnum(matches);\n  }\n\n  const discriminatingSchema = resolve(discriminatingSchemaRef, ctx);\n  // Get the discriminator property schema to check if it should use enum types\n  // Check the schema's own properties first, then search in allOf parents\n  let discriminatorPropertySchema = resolve(\n    discriminatingSchema.properties?.[propertyName],\n    ctx,\n  );\n\n  if (!discriminatorPropertySchema && discriminatingSchema.allOf) {\n    for (const allOfSchema of discriminatingSchema.allOf) {\n      const resolvedAllOf = resolve(allOfSchema, ctx);\n      if (resolvedAllOf.properties?.[propertyName]) {\n        discriminatorPropertySchema = resolve(\n          resolvedAllOf.properties[propertyName],\n          ctx,\n        );\n        break;\n      }\n    }\n  }\n\n  if (\n    !discriminatorPropertySchema ||\n    !isNamedEnumSchema(discriminatorPropertySchema, propertyName)\n  ) {\n    return getTypeFromEnum(matches);\n  }\n\n  const enumTypeRef =\n    enumStyle === \"as-const\"\n      ? getAsConstEnum(discriminatorPropertySchema, propertyName, ctx)\n      : getTrueEnum(discriminatorPropertySchema, propertyName, ctx);\n\n  const memberTypes = matches.map((value) => {\n    const entity = factory.createQualifiedName(\n      enumTypeRef.typeName,\n      factory.createIdentifier(toIdentifier(value, true)),\n    );\n\n    if (enumStyle === \"as-const\") {\n      return factory.createTypeQueryNode(entity);\n    }\n\n    return factory.createTypeReferenceNode(entity);\n  });\n\n  return memberTypes.length === 1\n    ? memberTypes[0]\n    : factory.createUnionTypeNode(memberTypes);\n}\n","import ts from \"typescript\";\nimport _ from \"lodash\";\nimport { isReference, resolve, getRefBasename } from \"@oazapfts/resolve\";\nimport { OazapftsContext } from \"../../context\";\nimport * as OpenApi from \"../../helpers/openApi3-x\";\nimport { createPropertySignature } from \"../tscodegen\";\nimport { getTypeFromSchema } from \"./getTypeFromSchema\";\nimport { getDiscriminatorType } from \"./getDiscriminatorType\";\n\nexport function getUnionType(\n  variants: (OpenApi.ReferenceObject | OpenApi.SchemaObject)[],\n  ctx: OazapftsContext,\n  discriminator?: OpenApi.DiscriminatorObject,\n) {\n  if (discriminator) {\n    // oneOf + discriminator -> tagged union (polymorphism)\n    if (discriminator.propertyName === undefined) {\n      throw new Error(\"Discriminators require a propertyName\");\n    }\n\n    // By default, the last component of the ref name (i.e., after the last trailing slash) is\n    // used as the discriminator value for each variant. This can be overridden using the\n    // discriminator.mapping property.\n    const mappedValues = new Set(\n      Object.values(discriminator.mapping || {}).map(getRefBasename),\n    );\n\n    return ts.factory.createUnionTypeNode(\n      (\n        [\n          ...Object.entries(discriminator.mapping || {}).map(\n            ([discriminatorValue, variantRef]) => [\n              discriminatorValue,\n              { $ref: variantRef },\n            ],\n          ),\n          ...variants\n            .filter((variant) => {\n              if (!isReference(variant)) {\n                // From the Swagger spec: \"When using the discriminator, inline schemas will not be\n                // considered.\"\n                throw new Error(\n                  \"Discriminators require references, not inline schemas\",\n                );\n              }\n              return !mappedValues.has(getRefBasename(variant.$ref));\n            })\n            .map((schema) => {\n              const schemaBaseName = getRefBasename(\n                (schema as OpenApi.ReferenceObject).$ref,\n              );\n              // TODO: handle boolean\n              const resolvedSchema = resolve(schema, ctx) as Exclude<\n                OpenApi.SchemaObject,\n                boolean\n              >;\n              const discriminatorProperty =\n                resolvedSchema.properties?.[discriminator.propertyName];\n              const variantName =\n                discriminatorProperty && \"enum\" in discriminatorProperty\n                  ? discriminatorProperty?.enum?.[0]\n                  : \"\";\n              return [variantName || schemaBaseName, schema];\n            }),\n        ] as [string, OpenApi.ReferenceObject][]\n      ).map(([discriminatorValue, variant]) =>\n        // Yields: { [discriminator.propertyName]: discriminatorValue } & variant\n        ts.factory.createIntersectionTypeNode([\n          ts.factory.createTypeLiteralNode([\n            createPropertySignature({\n              name: discriminator.propertyName,\n              type: getDiscriminatorType(\n                ctx,\n                variant,\n                discriminator.propertyName,\n                [discriminatorValue],\n              ),\n            }),\n          ]),\n          getTypeFromSchema(ctx, variant),\n        ]),\n      ),\n    );\n  } else {\n    // oneOf -> untagged union\n    return ts.factory.createUnionTypeNode(\n      _.uniq(variants.map((schema) => getTypeFromSchema(ctx, schema))),\n    );\n  }\n}\n","import ts from \"typescript\";\nimport { OazapftsContext } from \"../../context\";\nimport { ReferenceObject, SchemaObject } from \"../../helpers/openApi3-x\";\nimport * as cg from \"../tscodegen\";\nimport { checkSchemaOnlyMode } from \"../../helpers\";\nimport { getTypeFromSchema } from \"./getTypeFromSchema\";\nimport { getEmptySchemaType } from \"../../helpers/emptySchemaType\";\n\n/**\n * Recursively creates a type literal with the given props.\n */\nexport function getTypeFromProperties(\n  props: {\n    [prop: string]: SchemaObject | ReferenceObject;\n  },\n  ctx: OazapftsContext,\n  required?: string[],\n  additionalProperties?: boolean | SchemaObject | ReferenceObject,\n): ts.TypeLiteralNode {\n  const currentMode = ctx.mode;\n\n  // Check if any of the props are readOnly or writeOnly schemas\n  const propertyNames = Object.keys(props);\n  const filteredPropertyNames = propertyNames.filter((name) => {\n    const schema = props[name];\n    const { readOnly, writeOnly } = checkSchemaOnlyMode(schema, ctx, false);\n\n    switch (currentMode) {\n      case \"readOnly\":\n        return readOnly || !writeOnly;\n      case \"writeOnly\":\n        return writeOnly || !readOnly;\n      default:\n        return !readOnly && !writeOnly;\n    }\n  });\n\n  const members: ts.TypeElement[] = filteredPropertyNames.map((name) => {\n    const schema = props[name];\n    const isRequired = required && required.includes(name);\n    let type = getTypeFromSchema(ctx, schema, name);\n    if (!isRequired && ctx.opts.unionUndefined) {\n      type = ts.factory.createUnionTypeNode([type, cg.keywordType.undefined]);\n    }\n\n    const signature = cg.createPropertySignature({\n      questionToken: !isRequired,\n      name,\n      type,\n    });\n\n    if (\n      typeof schema !== \"boolean\" &&\n      \"description\" in schema &&\n      schema.description\n    ) {\n      // Escape any JSDoc comment closing tags in description\n      const description = schema.description.replace(\"*/\", \"*\\\\/\");\n\n      ts.addSyntheticLeadingComment(\n        signature,\n        ts.SyntaxKind.MultiLineCommentTrivia,\n        // Ensures it is formatted like a JSDoc comment: /** description here */\n        `* ${description} `,\n        true,\n      );\n    }\n\n    return signature;\n  });\n  if (additionalProperties) {\n    const type =\n      additionalProperties === true\n        ? getEmptySchemaType(ctx)\n        : getTypeFromSchema(ctx, additionalProperties);\n\n    members.push(cg.createIndexSignature(type));\n  }\n  return ts.factory.createTypeLiteralNode(members);\n}\n","import ts, { factory } from \"typescript\";\nimport _ from \"lodash\";\nimport { isReference, resolve } from \"@oazapfts/resolve\";\nimport { OazapftsContext } from \"../../context\";\nimport * as OpenApi from \"../../helpers/openApi3-x\";\nimport * as cg from \"../tscodegen\";\nimport * as h from \"../../helpers\";\nimport { getEmptySchemaType } from \"../../helpers/emptySchemaType\";\nimport { getRefAlias } from \"../getRefAlias\";\nimport { getUnionType } from \"./getUnionType\";\nimport { getTypeFromProperties } from \"./getTypeFromProperties\";\nimport { getTrueEnum } from \"./getTrueEnum\";\nimport { getAsConstEnum } from \"./getAsConstEnum\";\nimport { getTypeFromEnum } from \"./getTypeFromEnum\";\nimport { getDiscriminatorType } from \"./getDiscriminatorType\";\n\n/**\n * Creates a type node from a given schema.\n * Delegates to getBaseTypeFromSchema internally and\n * optionally adds a union with null.\n */\nexport function getTypeFromSchema(\n  ctx: OazapftsContext,\n  schema?: OpenApi.SchemaObject | OpenApi.ReferenceObject,\n  name?: string,\n) {\n  const type = getBaseTypeFromSchema(ctx, schema, name);\n  return h.isNullable(schema)\n    ? ts.factory.createUnionTypeNode([type, cg.keywordType.null])\n    : type;\n}\n\n/**\n * This is the very core of the OpenAPI to TS conversion - it takes a\n * schema and returns the appropriate type.\n */\nfunction getBaseTypeFromSchema(\n  ctx: OazapftsContext,\n  schema?: OpenApi.SchemaObject | OpenApi.ReferenceObject,\n  name?: string,\n): ts.TypeNode {\n  if (schema === undefined) return getEmptySchemaType(ctx);\n  if (isReference(schema)) {\n    return getRefAlias(schema, ctx) as ts.TypeReferenceNode;\n  }\n\n  if (schema === true) {\n    return getEmptySchemaType(ctx);\n  }\n\n  if (schema === false) {\n    return cg.keywordType.never;\n  }\n\n  if (schema.oneOf) {\n    const clone = { ...schema };\n    delete clone.oneOf;\n    // oneOf -> union\n    return getUnionType(\n      schema.oneOf.map((variant) =>\n        // ensure that base properties from the schema are included in the oneOf variants\n        _.mergeWith({}, clone, variant, (objValue, srcValue) => {\n          if (_.isArray(objValue)) {\n            return objValue.concat(srcValue);\n          }\n        }),\n      ),\n      ctx,\n      schema.discriminator,\n    );\n  }\n  if (schema.anyOf) {\n    // anyOf -> union\n    return getUnionType(schema.anyOf, ctx);\n  }\n  if (schema.discriminator?.mapping) {\n    // discriminating schema -> union\n    const mapping = schema.discriminator.mapping;\n    return getUnionType(\n      Object.values(mapping).map((ref) => ({ $ref: ref })),\n      ctx,\n      undefined,\n    );\n  }\n  if (schema.allOf) {\n    // allOf -> intersection\n    const types: ts.TypeNode[] = [];\n    for (const childSchema of schema.allOf) {\n      if (\n        isReference(childSchema) &&\n        ctx.discriminatingSchemas.has(\n          resolve(childSchema, ctx) as OpenApi.SchemaObject,\n        )\n      ) {\n        const discriminatingSchema =\n          resolve<OpenApi.UNSTABLE_DiscriminatingSchemaObject>(\n            childSchema,\n            ctx,\n          );\n        const discriminator = discriminatingSchema.discriminator;\n\n        const matches = Object.entries(discriminator.mapping ?? {})\n          .filter(([, ref]) => resolve({ $ref: ref }, ctx) === schema)\n          .map(([discriminatorValue]) => discriminatorValue);\n        if (matches.length > 0) {\n          types.push(\n            ts.factory.createTypeLiteralNode([\n              cg.createPropertySignature({\n                name: discriminator.propertyName,\n                type: getDiscriminatorType(\n                  ctx,\n                  childSchema,\n                  discriminator.propertyName,\n                  matches,\n                ),\n              }),\n            ]),\n          );\n        }\n        types.push(\n          getRefAlias(childSchema, ctx, /* ignoreDiscriminator */ true),\n        );\n      } else {\n        types.push(\n          getTypeFromSchema(ctx, {\n            required: schema.required,\n            ...childSchema,\n          }),\n        );\n      }\n    }\n\n    if (schema.properties || schema.additionalProperties) {\n      // properties -> literal type\n      types.push(\n        getTypeFromProperties(\n          schema.properties || {},\n          ctx,\n          schema.required,\n          schema.additionalProperties,\n        ),\n      );\n    }\n    return ts.factory.createIntersectionTypeNode(types);\n  }\n  // Union types defined by an array in schema.type\n  if (Array.isArray(schema.type)) {\n    return factory.createUnionTypeNode(\n      schema.type.map((type) => {\n        const subSchema = { ...schema, type } as Exclude<\n          OpenApi.SchemaObject,\n          boolean\n        >;\n        // Remove items if the type isn't array since it's not relevant\n        if (\"items\" in subSchema && type !== \"array\") {\n          delete subSchema.items;\n        }\n        if (\"properties\" in subSchema && type !== \"object\") {\n          delete subSchema.properties;\n        }\n\n        return getBaseTypeFromSchema(ctx, subSchema, name);\n      }),\n    );\n  }\n  if (\"items\" in schema) {\n    const schemaItems = schema.items;\n\n    // items -> array of enums or unions\n    if (schemaItems && !isReference(schemaItems) && schemaItems.enum) {\n      const enumStyle = h.getEnumStyle(ctx.opts);\n      let enumType;\n      if (enumStyle !== \"union\" && h.isNamedEnumSchema(schemaItems, name)) {\n        enumType =\n          enumStyle === \"as-const\"\n            ? getAsConstEnum(schemaItems, name, ctx)\n            : getTrueEnum(schemaItems, name, ctx);\n      } else {\n        enumType = cg.createEnumTypeNode(schemaItems.enum);\n      }\n\n      return factory.createArrayTypeNode(enumType);\n    }\n\n    // items -> array\n    return ts.factory.createArrayTypeNode(getTypeFromSchema(ctx, schema.items));\n  }\n  if (\"prefixItems\" in schema && Array.isArray(schema.prefixItems)) {\n    // prefixItems -> typed tuple\n    return ts.factory.createTupleTypeNode(\n      schema.prefixItems.map((schema) => getTypeFromSchema(ctx, schema)),\n    );\n  }\n  if (schema.properties || schema.additionalProperties) {\n    // properties -> literal type\n    return getTypeFromProperties(\n      schema.properties || {},\n      ctx,\n      schema.required,\n      schema.additionalProperties,\n    );\n  }\n\n  if (schema.enum) {\n    const enumStyle = h.getEnumStyle(ctx.opts);\n    if (enumStyle !== \"union\" && h.isNamedEnumSchema(schema, name)) {\n      return enumStyle === \"as-const\"\n        ? getAsConstEnum(schema, name, ctx)\n        : getTrueEnum(schema, name, ctx);\n    }\n    return cg.createEnumTypeNode(schema.enum);\n  }\n  if (schema.format == \"binary\") {\n    return ts.factory.createTypeReferenceNode(\"Blob\", []);\n  }\n  if (\"const\" in schema && schema.const) {\n    return getTypeFromEnum([schema.const]);\n  }\n  if (schema.type !== undefined) {\n    if (schema.type === null) return cg.keywordType.null;\n    if (isKeyOfKeywordType(schema.type)) return cg.keywordType[schema.type];\n  }\n\n  return getEmptySchemaType(ctx);\n}\n\nfunction isKeyOfKeywordType(key: string): key is keyof typeof cg.keywordType {\n  return key in cg.keywordType;\n}\n","import ts from \"typescript\";\nimport _ from \"lodash\";\nimport { resolve, getRefName } from \"@oazapfts/resolve\";\nimport { OazapftsContext, withMode } from \"../context\";\nimport * as cg from \"./tscodegen\";\nimport * as OpenApi from \"../helpers/openApi3-x\";\nimport * as h from \"../helpers\";\nimport { getTypeFromSchema } from \"./getTypeFromSchema\";\n\n/**\n * Create a type alias for the schema referenced by the given ReferenceObject\n */\nexport function getRefAlias(\n  obj: OpenApi.ReferenceObject,\n  ctx: OazapftsContext,\n  // If true, the discriminator property of the schema referenced by `obj` will be ignored.\n  // This is meant to be used when getting the type of a discriminating schema in an `allOf`\n  // construct.\n  ignoreDiscriminator?: boolean,\n) {\n  const $ref = ignoreDiscriminator\n    ? h.findAvailableRef(obj.$ref + \"Base\", ctx)\n    : obj.$ref;\n\n  if (!ctx.refs[$ref]) {\n    let schema = resolve<OpenApi.SchemaObject>(obj, ctx);\n    if (typeof schema !== \"boolean\" && ignoreDiscriminator) {\n      schema = _.cloneDeep(schema);\n      delete schema.discriminator;\n    }\n    const name =\n      (typeof schema !== \"boolean\" && schema.title) || getRefName($ref);\n    const identifier = h.toIdentifier(name, true);\n\n    // When this is a named enum (enum or as-const) we can reference it directly,\n    // no need to create a type alias\n    if (\n      h.getEnumStyle(ctx.opts) !== \"union\" &&\n      h.isNamedEnumSchema(schema, name)\n    ) {\n      return getTypeFromSchema(ctx, schema, name);\n    }\n\n    const alias = h.getUniqueAlias(identifier, ctx);\n\n    ctx.refs[$ref] = {\n      base: ts.factory.createTypeReferenceNode(alias, undefined),\n      readOnly: undefined,\n      writeOnly: undefined,\n    };\n\n    const baseType = getTypeFromSchema(withMode(ctx, undefined), schema);\n    ctx.aliases.push(\n      cg.createTypeAliasDeclaration({\n        modifiers: [cg.modifier.export],\n        name: alias,\n        type: baseType,\n      }),\n    );\n\n    const { readOnly, writeOnly } = h.checkSchemaOnlyMode(schema, ctx);\n\n    if (readOnly) {\n      const readOnlyAlias = h.getUniqueAlias(\n        h.toIdentifier(name, true, \"readOnly\"),\n        ctx,\n      );\n      ctx.refs[$ref][\"readOnly\"] = ts.factory.createTypeReferenceNode(\n        readOnlyAlias,\n        undefined,\n      );\n\n      const readOnlyType = getTypeFromSchema(\n        withMode(ctx, \"readOnly\"),\n        schema,\n        name,\n      );\n      ctx.aliases.push(\n        cg.createTypeAliasDeclaration({\n          modifiers: [cg.modifier.export],\n          name: readOnlyAlias,\n          type: readOnlyType,\n        }),\n      );\n    }\n\n    if (writeOnly) {\n      const writeOnlyAlias = h.getUniqueAlias(\n        h.toIdentifier(name, true, \"writeOnly\"),\n        ctx,\n      );\n      ctx.refs[$ref][\"writeOnly\"] = ts.factory.createTypeReferenceNode(\n        writeOnlyAlias,\n        undefined,\n      );\n      const writeOnlyType = getTypeFromSchema(\n        withMode(ctx, \"writeOnly\"),\n        schema,\n        name,\n      );\n      ctx.aliases.push(\n        cg.createTypeAliasDeclaration({\n          modifiers: [cg.modifier.export],\n          name: writeOnlyAlias,\n          type: writeOnlyType,\n        }),\n      );\n    }\n  }\n\n  // If not ref fallback to the regular reference\n  return ctx.refs[$ref][ctx.mode || \"base\"] ?? ctx.refs[$ref].base;\n}\n","import { isReference, resolve, getRefBasename } from \"@oazapfts/resolve\";\nimport { OazapftsContext } from \"../context\";\nimport * as OpenApi from \"../helpers/openApi3-x\";\n\n/**\n * In order to support discriminated unions.\n *\n * @see https://github.com/oazapfts/oazapfts/pull/473\n *\n * Does three things:\n * 1. Add a `x-component-ref-path` property.\n * 2. Record discriminating schemas in `this.discriminatingSchemas`. A discriminating schema\n *    refers to a schema that has a `discriminator` property which is neither used in conjunction\n *    with `oneOf` nor `anyOf`.\n * 3. Make all mappings of discriminating schemas explicit to generate types immediately.\n */\nexport function preprocessComponents(ctx: OazapftsContext) {\n  if (!ctx.spec.components?.schemas) {\n    return;\n  }\n\n  const prefix = \"#/components/schemas/\";\n  const schemas = ctx.spec.components.schemas;\n\n  // First scan: Add `x-component-ref-path` property and record discriminating schemas\n  for (const name of Object.keys(schemas)) {\n    const schema = schemas[name];\n    if (isReference(schema) || typeof schema === \"boolean\") continue;\n\n    if (schema.discriminator && !schema.oneOf && !schema.anyOf) {\n      ctx.discriminatingSchemas.add(schema);\n    }\n  }\n\n  const isExplicit = (\n    discriminator: OpenApi.DiscriminatorObject,\n    ref: string,\n  ) => {\n    const refs = Object.values(discriminator.mapping || {});\n    return refs.includes(ref);\n  };\n\n  // Second scan: Make all mappings of discriminating schemas explicit\n  for (const name of Object.keys(schemas)) {\n    const schema = schemas[name];\n\n    if (isReference(schema) || typeof schema === \"boolean\" || !schema.allOf) {\n      continue;\n    }\n\n    for (const childSchema of schema.allOf) {\n      if (\n        !isReference(childSchema) ||\n        !ctx.discriminatingSchemas.has(\n          resolve<OpenApi.SchemaObject>(childSchema, ctx),\n        )\n      ) {\n        continue;\n      }\n\n      const discriminatingSchema = schemas[\n        getRefBasename(childSchema.$ref)\n      ] as OpenApi.UNSTABLE_DiscriminatingSchemaObject;\n      if (isReference(discriminatingSchema)) {\n        throw new Error(\"Unexpected nested reference\");\n      }\n\n      const discriminator = discriminatingSchema.discriminator!;\n\n      if (isExplicit(discriminator, prefix + name)) continue;\n      if (!discriminator.mapping) {\n        discriminator.mapping = {};\n      }\n      discriminator.mapping[name] = prefix + name;\n    }\n  }\n}\n","import ts from \"typescript\";\nimport { OazapftsContext } from \"../context\";\nimport * as h from \"../helpers\";\nimport * as OpenAPI from \"../helpers/openApi3-x\";\nimport type { UNSTABLE_OazapftsPluginHooks } from \"../plugin\";\nimport { getRefAlias } from \"./getRefAlias\";\nimport { preprocessComponents } from \"./preprocessComponents\";\n\nexport async function generateApi(\n  ctx: OazapftsContext,\n  hooks: UNSTABLE_OazapftsPluginHooks,\n): Promise<ts.SourceFile> {\n  // Preprocess components (needs mutable context)\n  preprocessComponents(ctx);\n\n  // Hook: prepare - allow plugins to modify spec, context, or template parts\n  await hooks.prepare.promise(ctx);\n\n  // Generate methods with hook support\n  const methods: ts.Statement[] = [];\n  for (const [path, pathItem] of Object.entries(ctx.spec.paths || {})) {\n    if (!pathItem) continue;\n\n    for (const [verb, operation] of Object.entries(pathItem)) {\n      if (!operation) continue;\n      const method = verb.toUpperCase();\n      if (!h.isHttpMethod(method)) continue;\n      const endpoint = {\n        method,\n        path,\n        operation: operation as OpenAPI.OperationObject,\n        pathItem,\n      };\n\n      // Hook: filterEndpoint - allow plugins to skip endpoint generation\n      const shouldGenerate = hooks.filterEndpoint.call(true, endpoint, ctx);\n      if (!shouldGenerate) continue;\n\n      // Hook: generateMethod - first plugin returning methods wins\n      const generatedMethods =\n        (await hooks.generateMethod.promise(endpoint, ctx)) ?? [];\n      const refinedMethods = await hooks.refineMethod.promise(\n        generatedMethods,\n        endpoint,\n        ctx,\n      );\n\n      methods.push(...refinedMethods);\n    }\n  }\n\n  if (ctx.opts.allSchemas && ctx.spec.components?.schemas) {\n    for (const [name] of Object.entries(ctx.spec.components.schemas)) {\n      getRefAlias({ $ref: `#/components/schemas/${name}` }, ctx);\n    }\n  }\n\n  // Hook: composeSource/refineSource - compose and refine top-level statements\n  const composedStatements =\n    (await hooks.composeSource.promise(ctx, methods)) ?? [];\n  const statements = await hooks.refineSource.promise(\n    composedStatements,\n    ctx,\n    methods,\n  );\n\n  // Add banner comment to first statement if present\n  if (ctx.banner && statements.length > 0) {\n    const bannerComment = `*\\n * ${ctx.banner.split(\"\\n\").join(\"\\n * \")}\\n `;\n    statements[0] = ts.addSyntheticLeadingComment(\n      statements[0],\n      ts.SyntaxKind.MultiLineCommentTrivia,\n      bannerComment,\n      true,\n    );\n  }\n\n  // Create the source file with all parts in order\n  let apiSourceFile = ts.factory.createSourceFile(\n    statements,\n    ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),\n    ts.NodeFlags.None,\n  );\n\n  // Hook: astGenerated - allow plugins to modify final AST\n  apiSourceFile = await hooks.astGenerated.promise(apiSourceFile, ctx);\n\n  return apiSourceFile;\n}\n","import ts from \"typescript\";\nimport type { Defaults } from \"../context\";\n\n/** Creates: export const defaults: Oazapfts.Defaults<Oazapfts.CustomHeaders> = { ... }; */\nexport function createDefaultsStatement(\n  defaults: Defaults,\n): ts.VariableStatement {\n  const properties: ts.PropertyAssignment[] = [];\n\n  // headers (always include, default to empty object)\n  properties.push(\n    ts.factory.createPropertyAssignment(\n      \"headers\",\n      defaults.headers\n        ? ts.factory.createObjectLiteralExpression(\n            Object.entries(defaults.headers)\n              .filter(([, value]) => value !== undefined)\n              .map(([key, value]) =>\n                ts.factory.createPropertyAssignment(\n                  ts.factory.createStringLiteral(key),\n                  createHeaderValueLiteral(value),\n                ),\n              ),\n          )\n        : ts.factory.createObjectLiteralExpression([]),\n    ),\n  );\n\n  // baseUrl (include if defined)\n  if (defaults.baseUrl !== undefined) {\n    properties.push(\n      ts.factory.createPropertyAssignment(\n        \"baseUrl\",\n        ts.factory.createStringLiteral(defaults.baseUrl),\n      ),\n    );\n  }\n\n  // fetch (expression-based: FunctionExpression, ArrowFunction, or Identifier)\n  if (defaults.fetch) {\n    properties.push(\n      ts.factory.createPropertyAssignment(\"fetch\", defaults.fetch),\n    );\n  }\n\n  // FormData (expression-based: ClassExpression or Identifier)\n  if (defaults.FormData) {\n    properties.push(\n      ts.factory.createPropertyAssignment(\"FormData\", defaults.FormData),\n    );\n  }\n\n  return ts.factory.createVariableStatement(\n    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n    ts.factory.createVariableDeclarationList(\n      [\n        ts.factory.createVariableDeclaration(\n          \"defaults\",\n          undefined,\n          ts.factory.createTypeReferenceNode(\n            ts.factory.createQualifiedName(\n              ts.factory.createIdentifier(\"Oazapfts\"),\n              \"Defaults\",\n            ),\n            [\n              ts.factory.createTypeReferenceNode(\n                ts.factory.createQualifiedName(\n                  ts.factory.createIdentifier(\"Oazapfts\"),\n                  \"CustomHeaders\",\n                ),\n              ),\n            ],\n          ),\n          ts.factory.createObjectLiteralExpression(properties, true),\n        ),\n      ],\n      ts.NodeFlags.Const,\n    ),\n  );\n}\n\n/** Create a literal expression for a header value (string | number | boolean | null) */\nexport function createHeaderValueLiteral(\n  value: string | number | boolean | null | undefined,\n): ts.Expression {\n  if (value === null) {\n    return ts.factory.createNull();\n  }\n  if (typeof value === \"boolean\") {\n    return value ? ts.factory.createTrue() : ts.factory.createFalse();\n  }\n  if (typeof value === \"number\") {\n    return ts.factory.createNumericLiteral(value);\n  }\n  return ts.factory.createStringLiteral(String(value));\n}\n","import ts from \"typescript\";\nimport type { Import, ImportSpecifier } from \"../context\";\n\n/**\n * Convert an Import definition to a TypeScript ImportDeclaration AST node.\n *\n * Supported formats:\n * - string: side-effect import `import \"module\";`\n * - [specifiers[], { from }]: named imports `import { a, b } from \"module\";`\n * - [default, { from }]: default import `import X from \"module\";`\n * - [default, specifiers[], { from }]: default + named `import X, { a } from \"module\";`\n * - [{ namespace }, { from }]: namespace import `import * as X from \"module\";`\n */\nexport function createImportStatement(imp: Import): ts.ImportDeclaration {\n  // Side-effect import: import \"module\";\n  if (typeof imp === \"string\") {\n    return ts.factory.createImportDeclaration(\n      undefined,\n      undefined,\n      ts.factory.createStringLiteral(imp),\n    );\n  }\n\n  // Namespace import: [{ namespace: \"X\" }, { from: \"module\" }]\n  if (imp.length === 2 && typeof imp[0] === \"object\" && \"namespace\" in imp[0]) {\n    const [{ namespace }, { from }] = imp as [\n      { namespace: string },\n      { from: string },\n    ];\n    return ts.factory.createImportDeclaration(\n      undefined,\n      ts.factory.createImportClause(\n        false,\n        undefined,\n        ts.factory.createNamespaceImport(\n          ts.factory.createIdentifier(namespace),\n        ),\n      ),\n      ts.factory.createStringLiteral(from),\n    );\n  }\n\n  // Default import: [\"Default\", { from: \"module\" }]\n  if (\n    imp.length === 2 &&\n    typeof imp[0] === \"string\" &&\n    typeof imp[1] === \"object\" &&\n    \"from\" in imp[1]\n  ) {\n    const [defaultName, { from }] = imp as [string, { from: string }];\n    return ts.factory.createImportDeclaration(\n      undefined,\n      ts.factory.createImportClause(\n        false,\n        ts.factory.createIdentifier(defaultName),\n        undefined,\n      ),\n      ts.factory.createStringLiteral(from),\n    );\n  }\n\n  // Named imports: [[specifiers], { from: \"module\" }]\n  if (imp.length === 2 && Array.isArray(imp[0])) {\n    const [specifiers, { from }] = imp as [\n      (ImportSpecifier | string)[],\n      { from: string },\n    ];\n    return ts.factory.createImportDeclaration(\n      undefined,\n      ts.factory.createImportClause(\n        false,\n        undefined,\n        ts.factory.createNamedImports(specifiers.map(createImportSpecifier)),\n      ),\n      ts.factory.createStringLiteral(from),\n    );\n  }\n\n  // Default + named imports: [\"Default\", [specifiers], { from: \"module\" }]\n  if (imp.length === 3) {\n    const [defaultName, specifiers, { from }] = imp as [\n      string,\n      (ImportSpecifier | string)[],\n      { from: string },\n    ];\n    return ts.factory.createImportDeclaration(\n      undefined,\n      ts.factory.createImportClause(\n        false,\n        ts.factory.createIdentifier(defaultName),\n        ts.factory.createNamedImports(specifiers.map(createImportSpecifier)),\n      ),\n      ts.factory.createStringLiteral(from),\n    );\n  }\n\n  throw new Error(`Invalid import format: ${JSON.stringify(imp)}`);\n}\n\nfunction createImportSpecifier(\n  spec: ImportSpecifier | string,\n): ts.ImportSpecifier {\n  if (typeof spec === \"string\") {\n    return ts.factory.createImportSpecifier(\n      false,\n      undefined,\n      ts.factory.createIdentifier(spec),\n    );\n  }\n  return ts.factory.createImportSpecifier(\n    false,\n    spec.as ? ts.factory.createIdentifier(spec.name) : undefined,\n    ts.factory.createIdentifier(spec.as || spec.name),\n  );\n}\n","import * as OpenApi from \"../helpers/openApi3-x\";\nimport { isMimeType } from \"../helpers\";\n\nexport function getSchemaFromContent(\n  content: Record<string, OpenApi.MediaTypeObject>,\n): OpenApi.SchemaObject | OpenApi.ReferenceObject {\n  const contentType = Object.keys(content).find(isMimeType);\n  if (contentType) {\n    const { schema } = content[contentType];\n    if (schema) {\n      return schema;\n    }\n  }\n\n  // if no content is specified -> string\n  // `text/*` -> string\n  if (\n    Object.keys(content).length === 0 ||\n    Object.keys(content).some((type) => type.startsWith(\"text/\"))\n  ) {\n    return { type: \"string\" };\n  }\n\n  // rest (e.g. `application/octet-stream`, `application/gzip`, …) -> binary\n  return { type: \"string\", format: \"binary\" };\n}\n","import { isReference } from \"@oazapfts/resolve\";\nimport { OazapftsContext } from \"../context\";\nimport { ParameterObject } from \"../helpers/openApi3-x\";\nimport { getSchemaFromContent } from \"./getSchemaFromContent\";\nimport { getTypeFromSchema } from \"./getTypeFromSchema\";\n\nexport function getTypeFromParameter(p: ParameterObject, ctx: OazapftsContext) {\n  if (p.content) {\n    const schema = getSchemaFromContent(p.content);\n    return getTypeFromSchema(ctx, schema);\n  }\n  return getTypeFromSchema(ctx, isReference(p) ? p : p.schema);\n}\n","import { resolve } from \"@oazapfts/resolve\";\nimport { OazapftsContext } from \"../context\";\nimport { ResponsesObject } from \"../helpers/openApi3-x\";\nimport * as h from \"../helpers\";\n\nexport function getResponseType(\n  ctx: OazapftsContext,\n  responses?: ResponsesObject,\n): \"json\" | \"text\" | \"blob\" {\n  // backwards-compatibility\n  if (!responses) return \"text\";\n\n  const resolvedResponses = Object.values(responses).map((response) =>\n    resolve(response, ctx),\n  );\n\n  // if no content is specified, assume `text` (backwards-compatibility)\n  if (\n    !resolvedResponses.some((res) => Object.keys(res.content ?? {}).length > 0)\n  ) {\n    return \"text\";\n  }\n\n  const isJson = resolvedResponses.some((response) => {\n    const responseMimeTypes = Object.keys(response.content ?? {});\n    return responseMimeTypes.some(h.isJsonMimeType);\n  });\n\n  // if there’s `application/json` or `*/*`, assume `json`\n  if (isJson) {\n    return \"json\";\n  }\n\n  // if there’s `text/*`, assume `text`\n  if (\n    resolvedResponses.some((res) =>\n      Object.keys(res.content ?? []).some((type) => type.startsWith(\"text/\")),\n    )\n  ) {\n    return \"text\";\n  }\n\n  // for the rest, assume `blob`\n  return \"blob\";\n}\n","import ts from \"typescript\";\nimport { resolve } from \"@oazapfts/resolve\";\nimport { OazapftsContext } from \"../context\";\nimport * as OpenApi from \"../helpers/openApi3-x\";\nimport * as cg from \"./tscodegen\";\nimport { getTypeFromSchema } from \"./getTypeFromSchema\";\nimport { getSchemaFromContent } from \"./getSchemaFromContent\";\n\nexport function getTypeFromResponses(\n  responses: OpenApi.ResponsesObject,\n  ctx: OazapftsContext,\n) {\n  return ts.factory.createUnionTypeNode(\n    Object.entries(responses).map(([code, res]) => {\n      const statusType =\n        code === \"default\"\n          ? cg.keywordType.number\n          : ts.factory.createLiteralTypeNode(\n              ts.factory.createNumericLiteral(code),\n            );\n\n      const props = [\n        cg.createPropertySignature({\n          name: \"status\",\n          type: statusType,\n        }),\n      ];\n\n      const dataType = getTypeFromResponse(res, ctx);\n      if (dataType !== cg.keywordType.void) {\n        props.push(\n          cg.createPropertySignature({\n            name: \"data\",\n            type: dataType,\n          }),\n        );\n      }\n      return ts.factory.createTypeLiteralNode(props);\n    }),\n  );\n}\n\nexport function getTypeFromResponse(\n  resOrRef: OpenApi.ResponseObject | OpenApi.ReferenceObject,\n  ctx: OazapftsContext,\n) {\n  const res = resolve(resOrRef, ctx);\n  if (!res || !res.content) return cg.keywordType.void;\n  return getTypeFromSchema(ctx, getSchemaFromContent(res.content));\n}\n","import _ from \"lodash\";\nimport { toIdentifier } from \"../helpers/toIdentifier\";\nimport { isValidIdentifier } from \"./tscodegen\";\n\n/**\n * Result of getOperationNames containing the primary method name and\n * optionally a deprecated legacy name for backward compatibility.\n */\nexport type OperationNames = {\n  primaryName: string;\n  /**\n   * When set, indicates the legacy fallback name that older versions of\n   * oazapfts would have generated. A deprecated alias should be emitted.\n   */\n  deprecatedLegacyName?: string;\n};\n\n/**\n * Create method name(s) for a given operation, either from its operationId or\n * the HTTP verb and path. Returns the primary name and optionally a deprecated\n * legacy name for backward compatibility.\n *\n * @deprecated will be removed in next major version. Use `getOperationName` instead\n */\nexport function getOperationNames(\n  verb: string,\n  path: string,\n  operationId?: string,\n  operationNames: Map<string, number> = new Map(),\n): OperationNames {\n  const fallbackName = getFallbackName(verb, path);\n  const legacyId = getLegacyOperationIdentifier(operationId);\n  const newId = getOperationIdentifier(operationId);\n\n  // If new normalization produces a valid identifier but legacy did not,\n  // we need to emit a deprecated alias for backward compatibility.\n  if (newId && !legacyId) {\n    const primaryName = reserveOperationName(newId, operationNames);\n    const deprecatedLegacyName = reserveOperationName(\n      fallbackName,\n      operationNames,\n    );\n    return {\n      primaryName,\n      deprecatedLegacyName,\n    };\n  }\n\n  // Either both agree on the id, or both fall back\n  const primaryName = reserveOperationName(\n    newId || fallbackName,\n    operationNames,\n  );\n  return {\n    primaryName,\n  };\n}\n\n/**\n * Create a method name for a given operation, either from its operationId or\n * the HTTP verb and path.\n */\nexport function getOperationName(\n  verb: string,\n  path: string,\n  operationId?: string,\n  operationNames: Map<string, number> = new Map(),\n  /** @deprecated will be removed in next major version */\n  DEPRECATED_legacyName?: true,\n) {\n  const names = getOperationNames(verb, path, operationId, operationNames);\n  if (DEPRECATED_legacyName && names.deprecatedLegacyName) {\n    return names.deprecatedLegacyName;\n  }\n  return names.primaryName;\n}\n\n/**\n * Make sure the name is unique by appending a counter to the name.\n */\nfunction reserveOperationName(\n  name: string,\n  operationNames: Map<string, number>,\n): string {\n  let count = operationNames.get(name) ?? 0;\n  if (count === 0) {\n    operationNames.set(name, 1);\n    return name;\n  }\n\n  count += 1;\n  let dedupedName = `${name}${count}`;\n  while (operationNames.has(dedupedName)) {\n    count += 1;\n    dedupedName = `${name}${count}`;\n  }\n\n  operationNames.set(name, count);\n  operationNames.set(dedupedName, 1);\n  return dedupedName;\n}\n\n/**\n * Compute the fallback name from verb + path (used when operationId is missing\n * or cannot be normalized to a valid identifier).\n */\nfunction getFallbackName(verb: string, path: string) {\n  path = path.replace(/\\{(.+?)\\}/, \"by $1\").replace(/\\{(.+?)\\}/, \"and $1\");\n  return toIdentifier(`${verb} ${path}`);\n}\n\n/**\n * Normalize an operationId into a valid camelCase identifier.\n * - Replaces non-word characters (except whitespace) with spaces\n * - Strips invalid leading characters (digits, etc.)\n * - Returns undefined if the result is empty or invalid\n */\nfunction getOperationIdentifier(id?: string): string | undefined {\n  if (!id) return;\n\n  // Replace any non-word, non-whitespace character with a space\n  // This handles dots, colons, backslashes, dashes, etc.\n  const normalized = id.replace(/[^\\w\\s]/g, \" \");\n\n  let camelCased = _.camelCase(normalized);\n  if (!camelCased) return;\n\n  // Strip invalid leading characters (digits, etc.) until we have a valid start\n  camelCased = camelCased.replace(/^[^a-zA-Z_$]+/, \"\");\n\n  // Ensure it starts lowercase (function-style)\n  camelCased = _.lowerFirst(camelCased);\n\n  if (!camelCased) return;\n  if (isValidIdentifier(camelCased)) return camelCased;\n}\n\n/**\n * Legacy operationId handling: only accepts IDs with word characters and\n * whitespace. This matches the old behavior before relaxed operationId support.\n */\nfunction getLegacyOperationIdentifier(id?: string): string | undefined {\n  if (!id) return;\n  // Old behavior: reject any special characters\n  if (id.match(/[^\\w\\s]/)) return;\n  const camelCased = _.camelCase(id);\n  if (isValidIdentifier(camelCased)) return camelCased;\n}\n","import ts from \"typescript\";\nimport _ from \"lodash\";\nimport { resolveArray, resolve, getReferenceName } from \"@oazapfts/resolve\";\nimport { OazapftsContext, withMode } from \"../context\";\nimport * as OpenApi from \"../helpers/openApi3-x\";\nimport * as cg from \"./tscodegen\";\nimport * as h from \"../helpers\";\nimport { getTypeFromParameter } from \"./getTypeFromParameter\";\nimport { getSchemaFromContent } from \"./getSchemaFromContent\";\nimport { getTypeFromSchema } from \"./getTypeFromSchema\";\nimport { getResponseType } from \"./getResponseType\";\nimport { getTypeFromResponses } from \"./getTypeFromResponses\";\nimport * as OpenAPI from \"../helpers/openApi3-x\";\nimport type { UNSTABLE_OazapftsPluginHooks } from \"../plugin\";\nimport { getOperationNames } from \"./getOperationName\";\n\nexport const argumentStyleOptions = [\"positional\", \"object\"] as const;\nexport type ArgumentStyle = (typeof argumentStyleOptions)[number];\n\nexport function generateClientMethod(\n  method: h.HttpMethod,\n  path: string,\n  operation: OpenAPI.OperationObject,\n  pathItem: OpenAPI.PathItemObject,\n  ctx: OazapftsContext,\n  hooks: UNSTABLE_OazapftsPluginHooks,\n): ts.Statement[] {\n  const { operationId, requestBody, responses, summary, description } =\n    operation;\n\n  const { primaryName, deprecatedLegacyName } = getOperationNames(\n    method,\n    path,\n    operationId,\n    ctx.operationNames,\n  );\n\n  // merge item and op parameters\n  const parameters = resolveArray(ctx, pathItem.parameters);\n  for (const p of resolveArray(ctx, operation.parameters)) {\n    const existing = parameters.find((r) => r.name === p.name && r.in === p.in);\n    if (!existing) {\n      parameters.push(p);\n    }\n  }\n\n  // convert parameter names to argument names ...\n  const argNames = new Map<OpenApi.ParameterObject, string>();\n  _.sortBy(parameters, \"name.length\").forEach((p) => {\n    const identifier = h.toIdentifier(p.name);\n    const existing = [...argNames.values()];\n    const suffix = existing.includes(identifier) ? _.upperFirst(p.in) : \"\";\n    argNames.set(p, identifier + suffix);\n  });\n\n  const getArgName = (param: OpenApi.ParameterObject) => {\n    const name = argNames.get(param);\n    if (!name) throw new Error(`Can't find parameter: ${param.name}`);\n    return name;\n  };\n\n  const methodParams: ts.ParameterDeclaration[] = [];\n  let body: OpenApi.RequestBodyObject | undefined = undefined;\n  let bodyVar: string | undefined = undefined;\n  switch (ctx.opts.argumentStyle ?? \"positional\") {\n    case \"positional\":\n      // split into required/optional\n      const [required, optional] = _.partition(parameters, \"required\");\n\n      // build the method signature - first all the required parameters\n      const requiredParams = required.map((p) =>\n        cg.createParameter(getArgName(resolve(p, ctx)), {\n          type: getTypeFromParameter(p, ctx),\n        }),\n      );\n      methodParams.push(...requiredParams);\n\n      // add body if present\n      if (requestBody) {\n        body = resolve(requestBody, ctx);\n        const schema = getSchemaFromContent(body.content);\n        const type = getTypeFromSchema(withMode(ctx, \"writeOnly\"), schema);\n        bodyVar = h.toIdentifier(\n          (type as any).name || getReferenceName(schema) || \"body\",\n        );\n        methodParams.push(\n          cg.createParameter(bodyVar, {\n            type,\n            questionToken: !body.required,\n          }),\n        );\n      }\n\n      // add an object with all optional parameters\n      if (optional.length) {\n        methodParams.push(\n          cg.createParameter(\n            cg.createObjectBinding(\n              optional\n                .map((param) => resolve(param, ctx))\n                .map((param) => ({ name: getArgName(param) })),\n            ),\n            {\n              initializer: ts.factory.createObjectLiteralExpression(),\n              type: ts.factory.createTypeLiteralNode(\n                optional.map((p) =>\n                  cg.createPropertySignature({\n                    name: getArgName(resolve(p, ctx)),\n                    questionToken: true,\n                    type: getTypeFromParameter(p, ctx),\n                  }),\n                ),\n              ),\n            },\n          ),\n        );\n      }\n      break;\n\n    case \"object\":\n      // build the method signature - first all the required/optional parameters\n      const paramMembers = parameters.map((p) =>\n        cg.createPropertySignature({\n          name: getArgName(resolve(p, ctx)),\n          questionToken: !p.required,\n          type: getTypeFromParameter(p, ctx),\n        }),\n      );\n\n      // add body if present\n      if (requestBody) {\n        body = resolve(requestBody, ctx);\n        const schema = getSchemaFromContent(body.content);\n        const type = getTypeFromSchema(withMode(ctx, \"writeOnly\"), schema);\n        bodyVar = h.toIdentifier(\n          (type as any).name || getReferenceName(schema) || \"body\",\n        );\n        paramMembers.push(\n          cg.createPropertySignature({\n            name: bodyVar,\n            questionToken: !body.required,\n            type,\n          }),\n        );\n      }\n\n      // if there's no params, leave methodParams as is and prevent empty object argument generation\n      if (paramMembers.length === 0) {\n        break;\n      }\n\n      methodParams.push(\n        cg.createParameter(\n          cg.createObjectBinding([\n            ...parameters\n              .map((param) => resolve(param, ctx))\n              .map((param) => ({ name: getArgName(param) })),\n            ...(bodyVar ? [{ name: bodyVar }] : []),\n          ]),\n          {\n            type: ts.factory.createTypeLiteralNode(paramMembers),\n          },\n        ),\n      );\n      break;\n  }\n\n  // add oazapfts options\n  methodParams.push(\n    cg.createParameter(\"opts\", {\n      type: ts.factory.createTypeReferenceNode(\n        \"Oazapfts.RequestOpts\",\n        undefined,\n      ),\n      questionToken: true,\n    }),\n  );\n\n  // Next, build the method body...\n\n  const returnType = getResponseType(ctx, responses);\n  const query = parameters.filter((p) => p.in === \"query\");\n  const header = parameters.filter((p) => p.in === \"header\");\n\n  let qs;\n  if (query.length) {\n    const paramsByFormatter = _.groupBy(query, h.getFormatter);\n    qs = h.callQsFunction(\n      \"query\",\n      Object.entries(paramsByFormatter).map(([formatter, parameters]) => {\n        const args = hooks.querySerializerArgs.call(\n          [\n            cg.createObjectLiteral(\n              parameters.map((p) => [p.name, getArgName(p)]),\n            ),\n          ],\n          {\n            method,\n            path,\n            operation,\n            pathItem,\n            formatter,\n            parameters,\n            query,\n          },\n          ctx,\n        );\n        return h.callQsFunction(formatter, args);\n      }),\n    );\n  }\n\n  const url = h.createUrlExpression(path, qs);\n  const init: ts.ObjectLiteralElementLike[] = [\n    ts.factory.createSpreadAssignment(ts.factory.createIdentifier(\"opts\")),\n  ];\n\n  if (method !== \"GET\") {\n    init.push(\n      ts.factory.createPropertyAssignment(\n        \"method\",\n        ts.factory.createStringLiteral(method),\n      ),\n    );\n  }\n\n  if (bodyVar) {\n    init.push(\n      cg.createPropertyAssignment(\"body\", ts.factory.createIdentifier(bodyVar)),\n    );\n  }\n\n  if (header.length) {\n    init.push(\n      ts.factory.createPropertyAssignment(\n        \"headers\",\n        h.callOazapftsFunction(\"mergeHeaders\", [\n          ts.factory.createPropertyAccessChain(\n            ts.factory.createIdentifier(\"opts\"),\n            ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),\n            \"headers\",\n          ),\n          ts.factory.createObjectLiteralExpression(\n            [\n              ...header.map((param) =>\n                cg.createPropertyAssignment(\n                  param.name,\n                  ts.factory.createIdentifier(getArgName(param)),\n                ),\n              ),\n            ],\n            true,\n          ),\n        ]),\n      ),\n    );\n  }\n\n  const args: ts.Expression[] = [url];\n\n  if (init.length) {\n    const formatter = h.getBodyFormatter(body); // json, form, multipart\n    const initObj = ts.factory.createObjectLiteralExpression(init, true);\n    args.push(\n      formatter ? h.callOazapftsFunction(formatter, [initObj]) : initObj,\n    );\n  }\n\n  const methodBody = cg.block(\n    ts.factory.createReturnStatement(\n      h.wrapResult(\n        h.callOazapftsFunction(\n          {\n            json: \"fetchJson\",\n            text: \"fetchText\",\n            blob: \"fetchBlob\",\n          }[returnType],\n          args,\n          returnType === \"json\" || returnType === \"blob\"\n            ? [\n                getTypeFromResponses(responses!, withMode(ctx, \"readOnly\")) ||\n                  ts.SyntaxKind.AnyKeyword,\n              ]\n            : undefined,\n        ),\n        ctx,\n      ),\n    ),\n  );\n\n  const result: ts.Statement[] = [\n    cg.addComment(\n      cg.createFunctionDeclaration(\n        primaryName,\n        {\n          modifiers: [cg.modifier.export],\n        },\n        methodParams,\n        methodBody,\n      ),\n      summary || description,\n    ),\n  ];\n\n  // Generate deprecated legacy alias if needed for backward compatibility\n  if (deprecatedLegacyName && !ctx.opts.futureStripLegacyMethods) {\n    const deprecatedComment = [\n      `@deprecated Use {@link ${primaryName}} instead.`,\n      summary || description,\n    ]\n      .filter(Boolean)\n      .join(\"\\n\");\n\n    result.push(\n      cg.addComment(\n        cg.createFunctionDeclaration(\n          deprecatedLegacyName,\n          {\n            modifiers: [cg.modifier.export],\n          },\n          methodParams,\n          methodBody,\n        ),\n        deprecatedComment,\n      ),\n    );\n  }\n\n  return result;\n}\n"],"mappings":"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"}