@himenon/openapi-typescript-code-generator/dist/chunk-IRTN2Z2Z.js

OpenAPI Code Generator using TypeScript AST.

import {
  Name,
  Version
} from "./chunk-PH24P4KQ.js";
import {
  argumentParamsTypeDeclaration,
  escapeText,
  isAvailableVariableName,
  parameterName,
  requestBodyName,
  requestContentType,
  responseContentType,
  responseName
} from "./chunk-R3KKVR43.js";
import {
  __export
} from "./chunk-PZ5AY32C.js";

// src/internal/TsGenerator/index.ts
var TsGenerator_exports = {};
__export(TsGenerator_exports, {
  Factory: () => factory_exports,
  Utils: () => utils_exports,
  convertAstToTypeScriptCode: () => convertAstToTypeScriptCode,
  generate: () => generate
});
import ts19 from "typescript";

// src/internal/Exception/index.ts
var BaseError = class extends Error {
  constructor(message) {
    super(message);
    Object.setPrototypeOf(this, new.target.prototype);
  }
};
var UnSupportError = class extends BaseError {
};
var NotFoundFileError = class extends BaseError {
};
var FeatureDevelopmentError = class extends BaseError {
};
var UndefinedComponent = class extends BaseError {
};
var DevelopmentError = class extends BaseError {
};

// src/internal/TsGenerator/factory/index.ts
var factory_exports = {};
__export(factory_exports, {
  create: () => create44
});
import ts16 from "typescript";

// src/internal/TsGenerator/factory/ArrowFunction.ts
var create = ({ factory }) => (params) => {
  const node = factory.createArrowFunction(
    void 0,
    params.typeParameters,
    params.parameters,
    params.type,
    params.equalsGreaterThanToken,
    params.body
  );
  return node;
};
var make = (context) => {
  return {
    create: create(context)
  };
};

// src/internal/TsGenerator/factory/BinaryExpression.ts
import ts from "typescript";
var operators = {
  "+": ts.SyntaxKind.PlusToken,
  "=": ts.SyntaxKind.EqualsToken
};
var create2 = ({ factory }) => (params) => {
  const node = factory.createBinaryExpression(params.left, operators[params.operator], params.right);
  return node;
};
var make2 = (context) => {
  return {
    create: create2(context)
  };
};

// src/internal/TsGenerator/factory/Block.ts
var create3 = ({ factory }) => (params) => {
  const node = factory.createBlock(params.statements, params.multiLine);
  return node;
};
var make3 = (context) => {
  return {
    create: create3(context)
  };
};

// src/internal/TsGenerator/factory/CallExpression.ts
var create4 = ({ factory }) => (params) => {
  const node = factory.createCallExpression(params.expression, params.typeArguments, params.argumentsArray);
  return node;
};
var make4 = (context) => {
  return {
    create: create4(context)
  };
};

// src/internal/TsGenerator/factory/ClassDeclaration.ts
import ts2 from "typescript";
var create5 = ({ factory }) => (params) => {
  const node = factory.createClassDeclaration(
    params.export && [factory.createModifier(ts2.SyntaxKind.ExportKeyword)],
    factory.createIdentifier(params.name),
    params.typeParameterDeclaration,
    void 0,
    params.members
  );
  return node;
};
var make5 = (context) => {
  return {
    create: create5(context)
  };
};

// src/internal/TsGenerator/factory/ConstructorDeclaration.ts
var create6 = ({ factory }) => (params) => {
  const node = factory.createConstructorDeclaration(void 0, params.parameters || [], params.body);
  return node;
};
var make6 = (context) => {
  return {
    create: create6(context)
  };
};

// src/internal/TsGenerator/factory/ElementAccessExpression.ts
var create7 = ({ factory }) => (params) => {
  const index = typeof params.index === "string" ? factory.createStringLiteral(params.index) : params.index;
  const node = factory.createElementAccessExpression(params.expression, index);
  return node;
};
var make7 = (context) => {
  return {
    create: create7(context)
  };
};

// src/internal/TsGenerator/factory/ExpressionStatement.ts
var create8 = ({ factory }) => (params) => {
  const node = factory.createExpressionStatement(params.expression);
  return node;
};
var make8 = (context) => {
  return {
    create: create8(context)
  };
};

// src/internal/TsGenerator/factory/FunctionTypeNode.ts
var create9 = ({ factory }) => (params) => {
  const node = factory.createFunctionTypeNode(params.typeParameters, params.parameters, params.type);
  return node;
};
var make9 = (context) => {
  return {
    create: create9(context)
  };
};

// src/internal/TsGenerator/factory/Identifier.ts
var create10 = ({ factory }) => (params) => {
  const node = factory.createIdentifier(params.name);
  return node;
};
var make10 = (context) => {
  return {
    create: create10(context)
  };
};

// src/internal/TsGenerator/factory/IndexSignatureDeclaration.ts
import ts3 from "typescript";
var create11 = ({ factory }) => (params) => {
  const node = factory.createIndexSignature(
    void 0,
    // TODO Feature Development: Refactoring
    [
      factory.createParameterDeclaration(
        void 0,
        void 0,
        factory.createIdentifier(params.name),
        void 0,
        factory.createKeywordTypeNode(ts3.SyntaxKind.StringKeyword),
        void 0
      )
    ],
    params.type
  );
  return node;
};
var make11 = (context) => {
  return {
    create: create11(context)
  };
};

// src/internal/TsGenerator/factory/IndexedAccessTypeNode.ts
var create12 = ({ factory }) => (params) => {
  const node = factory.createIndexedAccessTypeNode(params.objectType, params.indexType);
  return node;
};
var make12 = (context) => {
  return {
    create: create12(context)
  };
};

// src/internal/TsGenerator/factory/InterfaceDeclaration.ts
import ts4 from "typescript";

// src/internal/TsGenerator/factory/utils.ts
import { EOL } from "os";
var escapeIdentiferText = (text) => {
  return text.replace(/-/g, "_");
};
var generateComment = (comment, deprecated) => {
  const excapedComment = comment.replace(/\*\//, "\\*\\\\/").replace(/\/\*/, "/\\\\*").replace(/\*\/\*/, "\\*\\/\\*");
  const splitComments = deprecated ? ["@deprecated"].concat(excapedComment.split(/\r?\n/)) : excapedComment.split(/\r?\n/);
  const comments = splitComments.filter((comment2, index) => {
    if (index === splitComments.length - 1 && comment2 === "") {
      return false;
    }
    return true;
  });
  if (comments.length === 1) {
    return {
      hasTrailingNewLine: true,
      value: `* ${comments.join("")} `
    };
  }
  return {
    hasTrailingNewLine: true,
    value: `*${EOL}${comments.map((comment2) => ` * ${comment2}`).join(EOL)}${EOL} `
  };
};

// src/internal/TsGenerator/factory/InterfaceDeclaration.ts
var create13 = ({ factory }) => (params) => {
  const node = ts4.factory.createInterfaceDeclaration(
    params.export && [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
    factory.createIdentifier(escapeIdentiferText(params.name)),
    params.typeParameters,
    void 0,
    params.members
  );
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return ts4.addSyntheticLeadingComment(node, ts4.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make13 = (context) => {
  return {
    create: create13(context)
  };
};

// src/internal/TsGenerator/factory/IntersectionTypeNode.ts
var create14 = ({ factory }) => (params) => {
  const node = factory.createIntersectionTypeNode(params.typeNodes);
  return node;
};
var make14 = (context) => {
  return {
    create: create14(context)
  };
};

// src/internal/TsGenerator/factory/LiteralTypeNode.ts
import ts5 from "typescript";
var create15 = ({ factory }) => (params) => {
  const createNode = () => {
    if (typeof params.value === "string") {
      const literal = ts5.setEmitFlags(factory.createStringLiteral(params.value), ts5.EmitFlags.NoAsciiEscaping);
      return factory.createLiteralTypeNode(literal);
    }
    if (typeof params.value === "number") {
      return factory.createLiteralTypeNode(factory.createNumericLiteral(params.value));
    }
    return factory.createLiteralTypeNode(params.value ? factory.createTrue() : factory.createFalse());
  };
  const node = createNode();
  if (params.comment) {
    const comment = generateComment(params.comment);
    return ts5.addSyntheticLeadingComment(node, ts5.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make15 = (context) => {
  return {
    create: create15(context)
  };
};

// src/internal/TsGenerator/factory/MethodDeclaration.ts
import ts6 from "typescript";
var create16 = ({ factory }) => (params) => {
  const modifiers = [];
  if (params.private) {
    modifiers.push(factory.createModifier(ts6.SyntaxKind.PrivateKeyword));
  } else {
    modifiers.push(factory.createModifier(ts6.SyntaxKind.PublicKeyword));
  }
  if (params.async) {
    modifiers.push(factory.createModifier(ts6.SyntaxKind.AsyncKeyword));
  }
  const node = factory.createMethodDeclaration(
    modifiers,
    void 0,
    factory.createIdentifier(params.name),
    void 0,
    params.typeParameters,
    params.parameters || [],
    params.type,
    params.body
  );
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return ts6.addSyntheticLeadingComment(node, ts6.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make16 = (context) => {
  return {
    create: create16(context)
  };
};

// src/internal/TsGenerator/factory/Namespace.ts
import ts7 from "typescript";

// src/internal/TsGenerator/factory/ModuleBlock.ts
var update = ({ factory }) => (params) => {
  const { node, statements } = params;
  return factory.updateModuleBlock(node, statements);
};

// src/internal/TsGenerator/factory/Namespace.ts
var findStatement = (_context) => (params) => {
  let statement;
  params.node.forEachChild((node) => {
    if (ts7.isModuleDeclaration(node) && node.name.text === params.name) {
      statement = node;
    }
  });
  return statement;
};
var create17 = ({ factory }) => (params) => {
  const node = factory.createModuleDeclaration(
    params.export && [factory.createModifier(ts7.SyntaxKind.ExportKeyword)],
    factory.createIdentifier(params.name),
    factory.createModuleBlock(params.statements),
    ts7.NodeFlags.Namespace
  );
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return ts7.addSyntheticLeadingComment(node, ts7.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var createMultiple = (context) => (params) => {
  const names = params.names.reverse();
  const firstName = names[0];
  const restNames = names.slice(1, names.length);
  const child = create17(context)({
    export: true,
    name: firstName,
    statements: params.statements,
    comment: params.comment,
    deprecated: params.deprecated
  });
  return restNames.reduce((previousStatement, currentName) => {
    return create17(context)({
      export: true,
      name: currentName,
      statements: [previousStatement]
    });
  }, child);
};
var update2 = (context) => (params) => {
  const { factory } = context;
  const { node, statements } = params;
  if (node.body && ts7.isModuleBlock(node.body)) {
    const body = update(context)({ node: node.body, statements });
    return factory.updateModuleDeclaration(node, node.modifiers, node.name, body);
  }
  return factory.updateModuleDeclaration(node, node.modifiers, node.name, node.body);
};
var addStatements = (context) => (params) => {
  const { factory } = context;
  const { node, statements } = params;
  if (node.body && ts7.isModuleBlock(node.body)) {
    const body = update(context)({ node: node.body, statements: node.body.statements.concat(statements) });
    return factory.updateModuleDeclaration(node, node.modifiers, node.name, body);
  }
  return factory.updateModuleDeclaration(node, node.modifiers, node.name, node.body);
};
var make17 = (context) => {
  return {
    findNamespace: findStatement(context),
    create: create17(context),
    update: update2(context),
    createMultiple: createMultiple(context),
    addStatements: addStatements(context)
  };
};

// src/internal/TsGenerator/factory/NoSubstitutionTemplateLiteral.ts
var create18 = ({ factory }) => (params) => {
  const node = factory.createNoSubstitutionTemplateLiteral(params.text, params.rawText);
  return node;
};
var make18 = (context) => {
  return {
    create: create18(context)
  };
};

// src/internal/TsGenerator/factory/ObjectLiteralExpression.ts
var create19 = ({ factory }) => (params) => {
  const node = factory.createObjectLiteralExpression(params.properties, params.multiLine);
  return node;
};
var make19 = (context) => {
  return {
    create: create19(context)
  };
};

// src/internal/TsGenerator/factory/ParameterDeclaration.ts
import ts8 from "typescript";
var create20 = ({ factory }) => (params) => {
  const modifiers = (() => {
    if (params.modifiers === "private") {
      return [factory.createModifier(ts8.SyntaxKind.PrivateKeyword)];
    }
    if (params.modifiers === "public") {
      return [factory.createModifier(ts8.SyntaxKind.PublicKeyword)];
    }
    return;
  })();
  const node = factory.createParameterDeclaration(
    modifiers,
    void 0,
    factory.createIdentifier(params.name),
    params.optional && factory.createToken(ts8.SyntaxKind.QuestionToken),
    params.type,
    void 0
  );
  return node;
};
var make20 = (context) => {
  return {
    create: create20(context)
  };
};

// src/internal/TsGenerator/factory/PropertyAccessExpression.ts
var generateExpression = (factory) => {
  return {
    this: factory.createThis()
  };
};
var create21 = ({ factory }) => (params) => {
  let expression = typeof params.expression === "string" ? factory.createIdentifier(params.expression) : params.expression;
  const expressionMap = generateExpression(factory);
  if (typeof params.expression === "string" && params.expression in expressionMap) {
    expression = generateExpression(factory)[params.expression];
  }
  const node = factory.createPropertyAccessExpression(expression, factory.createIdentifier(params.name));
  return node;
};
var make21 = (context) => {
  return {
    create: create21(context)
  };
};

// src/internal/TsGenerator/factory/PropertyAssignment.ts
import ts9 from "typescript";
var create22 = ({ factory }) => (params) => {
  const node = factory.createPropertyAssignment(params.name, params.initializer);
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return ts9.addSyntheticLeadingComment(node, ts9.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make22 = (context) => {
  return {
    create: create22(context)
  };
};

// src/internal/TsGenerator/factory/PropertyDeclaration.ts
var create23 = ({ factory }) => (params) => {
  const node = factory.createPropertyDeclaration(
    params.modifiers,
    params.name,
    params.questionOrExclamationToken,
    params.type,
    params.initializer
  );
  return node;
};
var make23 = (context) => {
  return {
    create: create23(context)
  };
};

// src/internal/TsGenerator/factory/PropertySignature.ts
import ts10 from "typescript";
var create24 = ({ factory }) => (params) => {
  const node = factory.createPropertySignature(
    params.readOnly ? [factory.createModifier(ts10.SyntaxKind.ReadonlyKeyword)] : void 0,
    params.name,
    params.optional ? factory.createToken(ts10.SyntaxKind.QuestionToken) : void 0,
    params.type
  );
  if (params.comment) {
    const comment = generateComment(params.comment);
    return ts10.addSyntheticLeadingComment(node, ts10.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make24 = (context) => {
  return {
    create: create24(context)
  };
};

// src/internal/TsGenerator/factory/RegularExpressionLiteral.ts
var create25 = ({ factory }) => (params) => {
  return factory.createRegularExpressionLiteral(params.text);
};
var make25 = (context) => {
  return {
    create: create25(context)
  };
};

// src/internal/TsGenerator/factory/ReturnStatement.ts
var create26 = ({ factory }) => (params) => {
  const node = factory.createReturnStatement(params.expression);
  return node;
};
var make26 = (context) => {
  return {
    create: create26(context)
  };
};

// src/internal/TsGenerator/factory/ShorthandPropertyAssignment.ts
var create27 = ({ factory }) => (params) => {
  const node = factory.createShorthandPropertyAssignment(params.name, void 0);
  return node;
};
var make27 = (context) => {
  return {
    create: create27(context)
  };
};

// src/internal/TsGenerator/factory/StringLiteral.ts
var create28 = ({ factory }) => (params) => {
  const node = factory.createStringLiteral(params.text, params.isSingleQuote);
  return node;
};
var make28 = (context) => {
  return {
    create: create28(context)
  };
};

// src/internal/TsGenerator/factory/TemplateExpression.ts
var create29 = ({ factory }) => (params) => {
  const node = factory.createTemplateExpression(params.head, params.templateSpans);
  return node;
};
var make29 = (context) => {
  return {
    create: create29(context)
  };
};

// src/internal/TsGenerator/factory/TemplateHead.ts
var create30 = ({ factory }) => (params) => {
  const node = factory.createTemplateHead(params.text, params.rawText, void 0);
  return node;
};
var make30 = (context) => {
  return {
    create: create30(context)
  };
};

// src/internal/TsGenerator/factory/TemplateMiddle.ts
var create31 = ({ factory }) => (params) => {
  const node = factory.createTemplateMiddle(params.text, params.rawText, void 0);
  return node;
};
var make31 = (context) => {
  return {
    create: create31(context)
  };
};

// src/internal/TsGenerator/factory/TemplateSpan.ts
var create32 = ({ factory }) => (params) => {
  const node = factory.createTemplateSpan(params.expression, params.literal);
  return node;
};
var make32 = (context) => {
  return {
    create: create32(context)
  };
};

// src/internal/TsGenerator/factory/TemplateTail.ts
var create33 = ({ factory }) => (params) => {
  const node = factory.createTemplateTail(params.text, params.rawText);
  return node;
};
var make33 = (context) => {
  return {
    create: create33(context)
  };
};

// src/internal/TsGenerator/factory/TypeAliasDeclaration.ts
import ts11 from "typescript";
var create34 = ({ factory }) => (params) => {
  const node = factory.createTypeAliasDeclaration(
    params.export && [factory.createModifier(ts11.SyntaxKind.ExportKeyword)],
    factory.createIdentifier(params.name),
    void 0,
    params.type
  );
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return ts11.addSyntheticLeadingComment(node, ts11.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make34 = (context) => {
  return {
    create: create34(context)
  };
};

// src/internal/TsGenerator/factory/TypeLiteralNode.ts
var create35 = ({ factory }) => (params) => {
  const node = factory.createTypeLiteralNode(params.members);
  return node;
};
var make35 = (context) => {
  return {
    create: create35(context)
  };
};

// src/internal/TsGenerator/factory/TypeNode.ts
import ts12 from "typescript";

// src/internal/TsGenerator/factory/UnionTypeNode.ts
var create36 = ({ factory }) => (params) => {
  const node = factory.createUnionTypeNode(params.typeNodes);
  return node;
};
var make36 = (context) => {
  return {
    create: create36(context)
  };
};

// src/internal/TsGenerator/factory/TypeNode.ts
var create37 = (context) => (params) => {
  const { factory } = context;
  const literalTypeNode = create15(context);
  const unionTypeNode = create36(context);
  const createNode = () => {
    switch (params.type) {
      case "string":
        if (params.enum) {
          return unionTypeNode({
            typeNodes: params.enum.map((value) => literalTypeNode({ value }))
          });
        }
        return factory.createKeywordTypeNode(ts12.SyntaxKind.StringKeyword);
      case "number":
      case "integer":
        if (params.enum) {
          return unionTypeNode({
            typeNodes: params.enum.map((value) => literalTypeNode({ value }))
          });
        }
        return factory.createKeywordTypeNode(ts12.SyntaxKind.NumberKeyword);
      case "boolean": {
        if (params.enum) {
          return unionTypeNode({
            typeNodes: params.enum.map((value) => literalTypeNode({ value }))
          });
        }
        return factory.createKeywordTypeNode(ts12.SyntaxKind.BooleanKeyword);
      }
      case "object":
        return factory.createTypeLiteralNode(params.value);
      case "undefined":
        return factory.createKeywordTypeNode(ts12.SyntaxKind.UndefinedKeyword);
      case "null":
        return factory.createLiteralTypeNode(factory.createNull());
      case "array":
        return factory.createArrayTypeNode(params.value);
      case "never":
        return factory.createKeywordTypeNode(ts12.SyntaxKind.NeverKeyword);
      case "void":
        return factory.createKeywordTypeNode(ts12.SyntaxKind.VoidKeyword);
      case "any":
        return factory.createKeywordTypeNode(ts12.SyntaxKind.AnyKeyword);
      default:
        throw new UnSupportError(`UnSupport Type: ${JSON.stringify(params)}`);
    }
  };
  const node = createNode();
  return node;
};
var make37 = (context) => {
  return {
    create: create37(context)
  };
};

// src/internal/TsGenerator/factory/TypeOperatorNode.ts
import ts13 from "typescript";
var syntaxKinds = {
  keyof: ts13.SyntaxKind.KeyOfKeyword,
  unique: ts13.SyntaxKind.UniqueKeyword,
  readonly: ts13.SyntaxKind.ReadonlyKeyword
};
var create38 = ({ factory }) => (params) => {
  const node = factory.createTypeOperatorNode(syntaxKinds[params.syntaxKind], params.type);
  return node;
};
var make38 = (context) => {
  return {
    create: create38(context)
  };
};

// src/internal/TsGenerator/factory/TypeParameterDeclaration.ts
var create39 = ({ factory }) => (params) => {
  const node = factory.createTypeParameterDeclaration([], factory.createIdentifier(params.name), params.constraint, params.defaultType);
  return node;
};
var make39 = (context) => {
  return {
    create: create39(context)
  };
};

// src/internal/TsGenerator/factory/TypeReferenceNode.ts
var create40 = ({ factory }) => (params) => {
  const node = factory.createTypeReferenceNode(factory.createIdentifier(params.name), params.typeArguments);
  return node;
};
var make40 = (context) => {
  return {
    create: create40(context)
  };
};

// src/internal/TsGenerator/factory/VariableDeclaration.ts
var create41 = ({ factory }) => (params) => {
  const node = factory.createVariableDeclaration(params.name, void 0, params.type, params.initializer);
  return node;
};
var make41 = (context) => {
  return {
    create: create41(context)
  };
};

// src/internal/TsGenerator/factory/VariableDeclarationList.ts
import ts14 from "typescript";
var flags = {
  const: ts14.NodeFlags.Const
};
var create42 = ({ factory }) => (params) => {
  const node = factory.createVariableDeclarationList(params.declarations, flags[params.flag]);
  return node;
};
var make42 = (context) => {
  return {
    create: create42(context)
  };
};

// src/internal/TsGenerator/factory/VariableStatement.ts
import ts15 from "typescript";
var create43 = ({ factory }) => (params) => {
  const node = factory.createVariableStatement(params.modifiers, params.declarationList);
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return ts15.addSyntheticLeadingComment(node, ts15.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make43 = (context) => {
  return {
    create: create43(context)
  };
};

// src/internal/TsGenerator/factory/index.ts
var create44 = () => {
  const context = {
    factory: ts16.factory
  };
  return {
    ArrowFunction: make(context),
    Block: make3(context),
    ClassDeclaration: make5(context),
    ParameterDeclaration: make20(context),
    InterfaceDeclaration: make13(context),
    IndexedAccessTypeNode: make12(context),
    Namespace: make17(context),
    PropertySignature: make24(context),
    PropertyDeclaration: make23(context),
    TypeAliasDeclaration: make34(context),
    TypeNode: make37(context),
    LiteralTypeNode: make15(context),
    IndexSignatureDeclaration: make11(context),
    UnionTypeNode: make36(context),
    IntersectionTypeNode: make14(context),
    TypeReferenceNode: make40(context),
    TypeParameterDeclaration: make39(context),
    TypeOperatorNode: make38(context),
    MethodDeclaration: make16(context),
    ConstructorDeclaration: make6(context),
    ReturnStatement: make26(context),
    VariableDeclaration: make41(context),
    VariableDeclarationList: make42(context),
    VariableStatement: make43(context),
    BinaryExpression: make2(context),
    PropertyAccessExpression: make21(context),
    RegularExpressionLiteral: make25(context),
    NoSubstitutionTemplateLiteral: make18(context),
    TemplateSpan: make32(context),
    TemplateExpression: make29(context),
    TemplateHead: make30(context),
    TemplateMiddle: make31(context),
    TemplateTail: make33(context),
    Identifier: make10(context),
    ShorthandPropertyAssignment: make27(context),
    PropertyAssignment: make22(context),
    ObjectLiteralExpression: make19(context),
    ElementAccessExpression: make7(context),
    ExpressionStatement: make8(context),
    CallExpression: make4(context),
    StringLiteral: make28(context),
    FunctionTypeNode: make9(context),
    TypeLiteralNode: make35(context)
  };
};

// src/internal/TsGenerator/traverse.ts
import ts17 from "typescript";
var traverse = (create49) => (context) => (rootNode) => {
  const visit = (node) => {
    if (!ts17.isSourceFile(node)) {
      return node;
    }
    return context.factory.updateSourceFile(
      node,
      create49(context),
      node.isDeclarationFile,
      node.referencedFiles,
      node.typeReferenceDirectives,
      node.hasNoDefaultLib,
      node.libReferenceDirectives
    );
  };
  return ts17.visitNode(rootNode, visit);
};

// src/internal/TsGenerator/utils.ts
var utils_exports = {};
__export(utils_exports, {
  convertIntermediateCodes: () => convertIntermediateCodes,
  stringToStatements: () => stringToStatements
});
import ts18 from "typescript";
var stringToStatements = (code) => {
  const source = ts18.createSourceFile("", code, ts18.ScriptTarget.ESNext, false, ts18.ScriptKind.TS);
  return Array.from(source.statements);
};
var convertIntermediateCodes = (intermediateCodes) => {
  return intermediateCodes.reduce((result, intermediateCode) => {
    if (typeof intermediateCode === "string") {
      return [...result, ...stringToStatements(intermediateCode)];
    }
    return result.concat(intermediateCode);
  }, []);
};

// src/internal/TsGenerator/index.ts
var convertAstToTypeScriptCode = (sourceFile) => {
  const printer = ts19.createPrinter();
  return printer.printFile(sourceFile);
};
var generate = (createFunction) => {
  const source = ts19.createSourceFile("", "", ts19.ScriptTarget.ESNext);
  const transformers = [traverse(createFunction)];
  const result = ts19.transform(source, transformers);
  result.dispose();
  if (result.transformed.length > 1) {
    throw new DevelopmentError("Invalid length");
  }
  return convertAstToTypeScriptCode(result.transformed[0]);
};

// src/internal/OpenApiTools/index.ts
var OpenApiTools_exports = {};
__export(OpenApiTools_exports, {
  Comment: () => Comment_exports,
  ConvertContext: () => ConverterContext_exports,
  Parser: () => Parser
});

// src/internal/OpenApiTools/Comment.ts
var Comment_exports = {};
__export(Comment_exports, {
  generateLeading: () => generateLeading
});
import { EOL as EOL2 } from "os";
var generateLeading = (schema) => {
  const messages = [];
  messages.push("");
  messages.push(`Generated by ${Name} v${Version}`);
  messages.push("");
  messages.push(`OpenApi : ${schema.openapi}`);
  messages.push("");
  if (schema.info.license) {
    if (schema.info.license.name) {
      messages.push(`License  : ${schema.info.license.name}`);
    }
    if (schema.info.license.url) {
      messages.push(`Url      : ${schema.info.license.url}`);
    }
  }
  messages.push("");
  return messages.map((message) => {
    return `// ${message}`;
  }).join(EOL2);
};

// src/internal/OpenApiTools/ConverterContext.ts
var ConverterContext_exports = {};
__export(ConverterContext_exports, {
  create: () => create45
});
var createFormatSchemaToTypeNode = (factory, target) => {
  const typeNodes = target.output.type.map((value) => {
    return factory.TypeReferenceNode.create({
      name: value
    });
  });
  if (target.output.multiType === "allOf") {
    return factory.IntersectionTypeNode.create({
      typeNodes
    });
  }
  return factory.UnionTypeNode.create({
    typeNodes
  });
};
var create45 = (factory, options) => {
  const convertReservedWord = (word) => {
    if (["import", "export"].includes(word)) {
      return `${word}_`;
    }
    return word;
  };
  const convertString = (text) => {
    if (isAvailableVariableName(text)) {
      return text;
    }
    return text.replace(/-/g, "$").replace(/\//g, "$");
  };
  const convertOperationId = (text) => {
    return convertString(text).replace(/[^a-zA-Z0-9_]/g, "$");
  };
  return {
    escapeOperationIdText: (operationId) => {
      return convertOperationId(operationId);
    },
    escapeDeclarationText: (text) => {
      return convertReservedWord(convertString(text).replace(/\./g, "$"));
    },
    escapeReferenceDeclarationText: (text) => {
      return convertReservedWord(convertString(text));
    },
    escapePropertySignatureName: (text) => {
      return escapeText(text);
    },
    escapeTypeReferenceNodeName: (text) => {
      return convertString(text);
    },
    generateResponseName: (operationId, statusCode) => {
      return responseName(convertOperationId(operationId), statusCode);
    },
    generateArgumentParamsTypeDeclaration: (operationId) => {
      return argumentParamsTypeDeclaration(convertOperationId(operationId));
    },
    generateRequestContentTypeName: (operationId) => {
      return requestContentType(convertOperationId(operationId));
    },
    generateResponseContentTypeName: (operationId) => {
      return responseContentType(convertOperationId(operationId));
    },
    generateParameterName: (operationId) => {
      return parameterName(convertOperationId(operationId));
    },
    generateRequestBodyName: (operationId) => {
      return requestBodyName(convertOperationId(operationId));
    },
    generateFunctionName: (operationId) => {
      return convertOperationId(operationId);
    },
    convertFormatTypeNode: (schema) => {
      const formatConversions = options?.formatConversions;
      if (!formatConversions || formatConversions.length === 0) {
        return;
      }
      if (typeof schema === "boolean") {
        return;
      }
      if (!schema.format) {
        return;
      }
      const target = formatConversions.find((formatConvertion) => formatConvertion.selector.format === schema.format);
      if (!target) {
        return;
      }
      return createFormatSchemaToTypeNode(factory, target);
    }
  };
};

// src/internal/OpenApiTools/Extractor.ts
var extractPickedParameter = (parameter) => {
  return {
    name: parameter.name,
    in: parameter.in,
    required: parameter.required,
    style: parameter.style,
    explode: parameter.explode
  };
};
var extractResponseNamesByStatusCode = (type, responses) => {
  const statusCodeList = [];
  for (const [statusCodeLike, response] of Object.entries(responses || {})) {
    const hasValidMediaType = Object.values(response.content || {}).filter((mediaType) => Object.values(mediaType).length > 0).length > 0;
    if (!hasValidMediaType) {
      continue;
    }
    if (typeof statusCodeLike === "string") {
      const statusCodeNumberValue = parseInt(statusCodeLike, 10);
      if (type === "success") {
        if (200 <= statusCodeNumberValue && statusCodeNumberValue < 300) {
          statusCodeList.push(statusCodeNumberValue.toString());
        }
      } else if (type === "error") {
        if (400 <= statusCodeNumberValue && statusCodeNumberValue < 600) {
          statusCodeList.push(statusCodeNumberValue.toString());
        }
      }
    }
  }
  return statusCodeList;
};
var getRequestContentTypeList = (requestBody) => {
  return Object.entries(requestBody.content).reduce((list, [key, mediaType]) => {
    const hasValidContent = Object.values(mediaType).length > 0;
    if (hasValidContent) {
      return list.concat(key);
    }
    return list;
  }, []);
};
var getSuccessResponseContentTypeList = (responses) => {
  const contentTypeList = [];
  for (const statusCode of extractResponseNamesByStatusCode("success", responses)) {
    const response = responses[statusCode];
    for (const [key, mediaType] of Object.entries(response.content || {})) {
      if (Object.values(mediaType).length > 0) {
        contentTypeList.push(key);
      }
    }
  }
  return Array.from(new Set(contentTypeList));
};
var hasQueryParameters = (parameters) => {
  if (!parameters) {
    return false;
  }
  return parameters.filter((parameter) => parameter.in === "query").length > 0;
};
var generateCodeGeneratorParamsArray = (store, converterContext, allowOperationIds) => {
  const operationState = store.getNoReferenceOperationState();
  const params = [];
  for (const [operationId, item] of Object.entries(operationState)) {
    if (allowOperationIds && !allowOperationIds.includes(operationId)) {
      continue;
    }
    const responseSuccessNames = extractResponseNamesByStatusCode("success", item.responses).map(
      (statusCode) => converterContext.generateResponseName(operationId, statusCode)
    );
    const responseErrorNames = extractResponseNamesByStatusCode("error", item.responses).map(
      (statusCode) => converterContext.generateResponseName(operationId, statusCode)
    );
    const requestContentTypeList = item.requestBody ? getRequestContentTypeList(item.requestBody) : [];
    const responseSuccessContentTypes = getSuccessResponseContentTypeList(item.responses);
    const hasOver2RequestContentTypes = requestContentTypeList.length > 1;
    const hasOver2SuccessNames = responseSuccessNames.length > 1;
    const convertedParams = {
      escapedOperationId: converterContext.escapeOperationIdText(operationId),
      argumentParamsTypeDeclaration: converterContext.generateArgumentParamsTypeDeclaration(operationId),
      functionName: converterContext.generateFunctionName(operationId),
      requestContentTypeName: converterContext.generateRequestContentTypeName(operationId),
      responseContentTypeName: converterContext.generateResponseContentTypeName(operationId),
      parameterName: converterContext.generateParameterName(operationId),
      requestBodyName: converterContext.generateRequestBodyName(operationId),
      hasRequestBody: !!item.requestBody,
      hasParameter: item.parameters ? item.parameters.length > 0 : false,
      pickedParameters: item.parameters ? item.parameters.map(extractPickedParameter) : [],
      requestContentTypes: requestContentTypeList,
      requestFirstContentType: requestContentTypeList.length === 1 ? requestContentTypeList[0] : void 0,
      responseSuccessNames,
      responseFirstSuccessName: responseSuccessNames.length === 1 ? responseSuccessNames[0] : void 0,
      has2OrMoreSuccessNames: hasOver2SuccessNames,
      responseErrorNames,
      has2OrMoreRequestContentTypes: hasOver2RequestContentTypes,
      successResponseContentTypes: responseSuccessContentTypes,
      successResponseFirstContentType: responseSuccessContentTypes.length === 1 ? responseSuccessContentTypes[0] : void 0,
      has2OrMoreSuccessResponseContentTypes: responseSuccessContentTypes.length > 1,
      hasAdditionalHeaders: hasOver2RequestContentTypes || hasOver2SuccessNames,
      hasQueryParameters: hasQueryParameters(item.parameters)
    };
    const formatParams = {
      operationId,
      convertedParams,
      operationParams: item
    };
    params.push(formatParams);
  }
  return params;
};

// src/internal/OpenApiTools/TypeNodeContext.ts
import * as Path from "path";

// node_modules/.pnpm/dot-prop@9.0.0/node_modules/dot-prop/index.js
var isObject = (value) => {
  const type = typeof value;
  return value !== null && (type === "object" || type === "function");
};
var disallowedKeys = /* @__PURE__ */ new Set([
  "__proto__",
  "prototype",
  "constructor"
]);
var digits = new Set("0123456789");
function getPathSegments(path6) {
  const parts = [];
  let currentSegment = "";
  let currentPart = "start";
  let isIgnoring = false;
  for (const character of path6) {
    switch (character) {
      case "\\": {
        if (currentPart === "index") {
          throw new Error("Invalid character in an index");
        }
        if (currentPart === "indexEnd") {
          throw new Error("Invalid character after an index");
        }
        if (isIgnoring) {
          currentSegment += character;
        }
        currentPart = "property";
        isIgnoring = !isIgnoring;
        break;
      }
      case ".": {
        if (currentPart === "index") {
          throw new Error("Invalid character in an index");
        }
        if (currentPart === "indexEnd") {
          currentPart = "property";
          break;
        }
        if (isIgnoring) {
          isIgnoring = false;
          currentSegment += character;
          break;
        }
        if (disallowedKeys.has(currentSegment)) {
          return [];
        }
        parts.push(currentSegment);
        currentSegment = "";
        currentPart = "property";
        break;
      }
      case "[": {
        if (currentPart === "index") {
          throw new Error("Invalid character in an index");
        }
        if (currentPart === "indexEnd") {
          currentPart = "index";
          break;
        }
        if (isIgnoring) {
          isIgnoring = false;
          currentSegment += character;
          break;
        }
        if (currentPart === "property") {
          if (disallowedKeys.has(currentSegment)) {
            return [];
          }
          parts.push(currentSegment);
          currentSegment = "";
        }
        currentPart = "index";
        break;
      }
      case "]": {
        if (currentPart === "index") {
          parts.push(Number.parseInt(currentSegment, 10));
          currentSegment = "";
          currentPart = "indexEnd";
          break;
        }
        if (currentPart === "indexEnd") {
          throw new Error("Invalid character after an index");
        }
      }
      default: {
        if (currentPart === "index" && !digits.has(character)) {
          throw new Error("Invalid character in an index");
        }
        if (currentPart === "indexEnd") {
          throw new Error("Invalid character after an index");
        }
        if (currentPart === "start") {
          currentPart = "property";
        }
        if (isIgnoring) {
          isIgnoring = false;
          currentSegment += "\\";
        }
        currentSegment += character;
      }
    }
  }
  if (isIgnoring) {
    currentSegment += "\\";
  }
  switch (currentPart) {
    case "property": {
      if (disallowedKeys.has(currentSegment)) {
        return [];
      }
      parts.push(currentSegment);
      break;
    }
    case "index": {
      throw new Error("Index was not closed");
    }
    case "start": {
      parts.push("");
      break;
    }
  }
  return parts;
}
function isStringIndex(object, key) {
  if (typeof key !== "number" && Array.isArray(object)) {
    const index = Number.parseInt(key, 10);
    return Number.isInteger(index) && object[index] === object[key];
  }
  return false;
}
function getProperty(object, path6, value) {
  if (!isObject(object) || typeof path6 !== "string") {
    return value === void 0 ? object : value;
  }
  const pathArray = getPathSegments(path6);
  if (pathArray.length === 0) {
    return value;
  }
  for (let index = 0; index < pathArray.length; index++) {
    const key = pathArray[index];
    if (isStringIndex(object, key)) {
      object = index === pathArray.length - 1 ? void 0 : null;
    } else {
      object = object[key];
    }
    if (object === void 0 || object === null) {
      if (index !== pathArray.length - 1) {
        return value;
      }
      break;
    }
  }
  return object === void 0 ? value : object;
}

// src/internal/OpenApiTools/TypeNodeContext.ts
import ts20 from "typescript";

// src/internal/OpenApiTools/Guard.ts
var isReference = (data) => {
  if (typeof data !== "object" || data === null) {
    return false;
  }
  return typeof data.$ref === "string";
};
var isObjectSchema = (schema) => {
  return schema.type === "object";
};
var isHasNoMembersObject = (schema) => {
  return Object.keys(schema).length === 0;
};
var isArraySchema = (schema) => {
  return schema.type === "array";
};
var isPrimitiveSchema = (schema) => {
  if (typeof schema.type !== "string") {
    return false;
  }
  if (schema.type === "object") {
    return false;
  }
  if (schema.type === "array") {
    return false;
  }
  return true;
};
var isBooleanArray = (list) => {
  return !list.some((item) => typeof item !== "boolean");
};
var isNumberArray = (list) => {
  return !list.some((item) => typeof item !== "number");
};
var isStringArray = (list) => {
  return !list.some((item) => typeof item !== "string");
};
var isObjectSchemaWithAdditionalProperties = (schema) => {
  return !!schema.additionalProperties;
};
var isOneOfSchema = (schema) => {
  return !!schema.oneOf && typeof schema.oneOf !== "boolean" && Array.isArray(schema.oneOf);
};
var isAllOfSchema = (schema) => {
  return !!schema.allOf && typeof schema.allOf !== "boolean" && Array.isArray(schema.allOf);
};
var isAnyOfSchema = (schema) => {
  return !!schema.anyOf && typeof schema.anyOf !== "boolean" && Array.isArray(schema.anyOf);
};
var isComponentName = (name) => {
  return ["schemas", "headers", "responses", "parameters", "requestBodies", "securitySchemes", "pathItems"].includes(name);
};

// src/internal/OpenApiTools/components/Reference.ts
import { posix as path2 } from "path";

// src/internal/FileSystem/index.ts
import * as fs from "fs";
import * as path from "path";
import * as yaml from "js-yaml";
var FileSystem = class _FileSystem {
  static FRAGMENT = "#/";
  static internalLoadJsonOrYaml(filename) {
    const ext = path.extname(filename);
    const data = fs.readFileSync(filename, { encoding: "utf-8" });
    switch (ext) {
      case ".json":
        return JSON.parse(data);
      case ".yml":
      case ".yaml":
        return yaml.load(data);
      default:
        throw new UnSupportError(`Not support file: ${filename}`);
    }
  }
  static existSync(entryPoint) {
    const fragmentIndex = entryPoint.indexOf(_FileSystem.FRAGMENT);
    const hasFragment = fragmentIndex !== -1;
    if (hasFragment) {
      const filename = entryPoint.substring(0, fragmentIndex);
      return !!(fs.existsSync(filename) && fs.statSync(filename).isFile());
    }
    return !!(fs.existsSync(entryPoint) && fs.statSync(entryPoint).isFile());
  }
  static loadJsonOrYaml(entryPoint) {
    const hasFragment = entryPoint.indexOf(_FileSystem.FRAGMENT) !== -1;
    if (hasFragment) {
      const [filename, fragment] = entryPoint.split(_FileSystem.FRAGMENT);
      const data = _FileSystem.internalLoadJsonOrYaml(filename);
      return getProperty(data, fragment.replace(/\//g, "."));
    }
    return _FileSystem.internalLoadJsonOrYaml(entryPoint);
  }
};

// src/internal/Logger/index.ts
var info = (message) => {
  console.info(message);
};
var showFilePosition = (entryPoint, currentPoint, referencePoint) => {
  console.log("");
  console.log("FilePointInfo");
  console.log(`- EntryPoint     : ${entryPoint}`);
  console.log(`- CurrentPoint   : ${currentPoint}`);
  referencePoint && console.log(`- ReferencePoint : ${referencePoint}`);
  console.log("");
};
var error = (message) => {
  console.error(message);
};
var warn = (message) => {
  console.log(message);
};

// src/internal/OpenApiTools/components/Reference.ts
var localReferencePatterns = [
  "#/components/schemas/",
  "#/components/responses/",
  "#/components/parameters/",
  "#/components/examples/",
  "#/components/requestBodies/",
  "#/components/headers/",
  "#/components/securitySchemes/",
  "#/components/links/",
  "#/components/callbacks/",
  "#/components/pathItems/"
];
var localReferenceComponents = {
  "#/components/schemas/": "components/schemas",
  "#/components/responses/": "components/responses",
  "#/components/parameters/": "components/parameters",
  "#/components/examples/": "components/examples",
  "#/components/requestBodies/": "components/requestBodies",
  "#/components/headers/": "components/headers",
  "#/components/securitySchemes/": "components/securitySchemes",
  "#/components/links/": "components/links",
  "#/components/callbacks/": "components/callbacks",
  "#/components/pathItems/": "components/pathItems"
};
var getLocalReferencePattern = (reference) => {
  let localReferencePattern;
  localReferencePatterns.forEach((referencePattern) => {
    if (new RegExp(`^${referencePattern}`).test(reference.$ref)) {
      localReferencePattern = referencePattern;
    }
  });
  return localReferencePattern;
};
var generateLocalReference = (reference) => {
  const localReferencePattern = getLocalReferencePattern(reference);
  if (!localReferencePattern) {
    return;
  }
  const name = reference.$ref.split(localReferencePattern)[1];
  const localPath = path2.posix.join(localReferenceComponents[localReferencePattern], name);
  if (!localPath.startsWith("components")) {
    throw new DevelopmentError(`localPath is not start "components":
${localPath}`);
  }
  return {
    type: "local",
    name,
    path: localPath
  };
};
var generateReferencePoint = (currentPoint, reference) => {
  const basedir = path2.dirname(currentPoint);
  const ref = reference.$ref;
  const referencePoint = path2.join(basedir, ref);
  return referencePoint;
};
var generate2 = (entryPoint, currentPoint, reference) => {
  const localReference = generateLocalReference(reference);
  if (localReference) {
    return localReference;
  }
  if (reference.$ref.startsWith("http")) {
    throw new FeatureDevelopmentError("Please Pull Request ! Welcome !");
  }
  const referencePoint = generateReferencePoint(currentPoint, reference);
  if (!FileSystem.existSync(referencePoint)) {
    showFilePosition(entryPoint, currentPoint, referencePoint);
    error(JSON.stringify(reference, null, 2));
    throw new NotFoundFileError(`Not found reference point from current point. 
 Path: ${referencePoint}`);
  }
  const fragmentIndex = referencePoint.indexOf("#/");
  let targetPath;
  if (fragmentIndex !== -1) {
    targetPath = referencePoint.substring(fragmentIndex + 2);
  } else {
    const relativePathFromEntryPoint = path2.relative(path2.dirname(entryPoint), referencePoint);
    const pathArray2 = relativePathFromEntryPoint.split(path2.sep);
    if (pathArray2[0] !== "components") {
      throw new DevelopmentError(`targetPath is not start "components":
${relativePathFromEntryPoint}`);
    }
    const ext = path2.extname(relativePathFromEntryPoint);
    targetPath = pathArray2.join("/").substring(0, relativePathFromEntryPoint.length - ext.length);
  }
  const pathArray = targetPath.split("/");
  const schemaName = pathArray[pathArray.length - 1];
  const componentName = pathArray[0] === "components" ? pathArray[1] : "";
  const data = FileSystem.loadJsonOrYaml(referencePoint);
  if (isReference(data)) {
    return generate2(entryPoint, referencePoint, data);
  }
  return {
    type: "remote",
    referencePoint,
    path: targetPath,
    name: schemaName,
    componentName: isComponentName(componentName) ? componentName : void 0,
    data
  };
};
var resolveRemoteReference = (entryPoint, currentPoint, reference) => {
  if (reference.$ref.startsWith("#") || reference.$ref.startsWith("http")) {
    return { referencePoint: currentPoint, data: reference };
  }
  const referencePoint = generateReferencePoint(currentPoint, reference);
  if (!FileSystem.existSync(referencePoint)) {
    showFilePosition(entryPoint, currentPoint, referencePoint);
    error(JSON.stringify(reference, null, 2));
    throw new NotFoundFileError(`Not found reference point from current point. 
 Path: ${referencePoint}`);
  }
  const data = FileSystem.loadJsonOrYaml(referencePoint);
  if (isReference(data)) {
    return resolveRemoteReference(entryPoint, referencePoint, data);
  }
  return {
    referencePoint,
    data
  };
};

// src/internal/OpenApiTools/InferredType.ts
var getInferredType = (schema) => {
  if (schema.type || schema.oneOf || schema.allOf || schema.anyOf) {
    return schema;
  }
  if (schema.items) {
    return { ...schema, type: "array" };
  }
  if (schema.enum) {
    return { ...schema, type: "string" };
  }
  if (schema.properties) {
    return { ...schema, type: "object" };
  }
  if (schema.required) {
    const properties = schema.required.reduce((s, name) => {
      return { ...s, [name]: { type: "any" } };
    }, {});
    return { ...schema, type: "object", properties };
  }
  return void 0;
};

// src/internal/OpenApiTools/toTypeNode.ts
var generateMultiTypeNode = (entryPoint, currentPoint, factory, schemas, setReference, convert2, convertContext, multiType) => {
  const typeNodes = schemas.map((schema) => convert2(entryPoint, currentPoint, factory, schema, setReference, convertContext));
  if (multiType === "oneOf") {
    return factory.UnionTypeNode.create({
      typeNodes
    });
  }
  if (multiType === "allOf") {
    return factory.IntersectionTypeNode.create({
      typeNodes
    });
  }
  return factory.UnionTypeNode.create({
    typeNodes
  });
};
var nullable = (factory, typeNode, nullable3) => {
  if (nullable3) {
    return factory.