@himenon/openapi-typescript-code-generator/dist/templates.cjs

OpenAPI Code Generator using TypeScript AST.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/templates.ts
var templates_exports = {};
__export(templates_exports, {
  ClassApiClient: () => class_api_client_exports,
  CurryingFunctionalApiClient: () => currying_functional_api_client_exports,
  FunctionalApiClient: () => functional_api_client_exports
});
module.exports = __toCommonJS(templates_exports);

// src/code-templates/class-api-client/index.ts
var class_api_client_exports = {};
__export(class_api_client_exports, {
  generator: () => generator
});

// src/internal/TsGenerator/index.ts
var TsGenerator_exports = {};
__export(TsGenerator_exports, {
  Factory: () => factory_exports,
  Utils: () => utils_exports,
  convertAstToTypeScriptCode: () => convertAstToTypeScriptCode,
  generate: () => generate
});
var import_typescript19 = __toESM(require("typescript"), 1);

// 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 DevelopmentError = class extends BaseError {
};

// src/internal/TsGenerator/factory/index.ts
var factory_exports = {};
__export(factory_exports, {
  create: () => create44
});
var import_typescript16 = __toESM(require("typescript"), 1);

// 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
var import_typescript = __toESM(require("typescript"), 1);
var operators = {
  "+": import_typescript.default.SyntaxKind.PlusToken,
  "=": import_typescript.default.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
var import_typescript2 = __toESM(require("typescript"), 1);
var create5 = ({ factory }) => (params) => {
  const node = factory.createClassDeclaration(
    params.export && [factory.createModifier(import_typescript2.default.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
var import_typescript3 = __toESM(require("typescript"), 1);
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(import_typescript3.default.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
var import_typescript4 = __toESM(require("typescript"), 1);

// src/internal/TsGenerator/factory/utils.ts
var import_os = require("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: `*${import_os.EOL}${comments.map((comment2) => ` * ${comment2}`).join(import_os.EOL)}${import_os.EOL} `
  };
};

// src/internal/TsGenerator/factory/InterfaceDeclaration.ts
var create13 = ({ factory }) => (params) => {
  const node = import_typescript4.default.factory.createInterfaceDeclaration(
    params.export && [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
    factory.createIdentifier(escapeIdentiferText(params.name)),
    params.typeParameters,
    void 0,
    params.members
  );
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return import_typescript4.default.addSyntheticLeadingComment(node, import_typescript4.default.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
var import_typescript5 = __toESM(require("typescript"), 1);
var create15 = ({ factory }) => (params) => {
  const createNode = () => {
    if (typeof params.value === "string") {
      const literal = import_typescript5.default.setEmitFlags(factory.createStringLiteral(params.value), import_typescript5.default.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 import_typescript5.default.addSyntheticLeadingComment(node, import_typescript5.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make15 = (context) => {
  return {
    create: create15(context)
  };
};

// src/internal/TsGenerator/factory/MethodDeclaration.ts
var import_typescript6 = __toESM(require("typescript"), 1);
var create16 = ({ factory }) => (params) => {
  const modifiers = [];
  if (params.private) {
    modifiers.push(factory.createModifier(import_typescript6.default.SyntaxKind.PrivateKeyword));
  } else {
    modifiers.push(factory.createModifier(import_typescript6.default.SyntaxKind.PublicKeyword));
  }
  if (params.async) {
    modifiers.push(factory.createModifier(import_typescript6.default.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 import_typescript6.default.addSyntheticLeadingComment(node, import_typescript6.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
  }
  return node;
};
var make16 = (context) => {
  return {
    create: create16(context)
  };
};

// src/internal/TsGenerator/factory/Namespace.ts
var import_typescript7 = __toESM(require("typescript"), 1);

// 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 (import_typescript7.default.isModuleDeclaration(node) && node.name.text === params.name) {
      statement = node;
    }
  });
  return statement;
};
var create17 = ({ factory }) => (params) => {
  const node = factory.createModuleDeclaration(
    params.export && [factory.createModifier(import_typescript7.default.SyntaxKind.ExportKeyword)],
    factory.createIdentifier(params.name),
    factory.createModuleBlock(params.statements),
    import_typescript7.default.NodeFlags.Namespace
  );
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return import_typescript7.default.addSyntheticLeadingComment(node, import_typescript7.default.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 && import_typescript7.default.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 && import_typescript7.default.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
var import_typescript8 = __toESM(require("typescript"), 1);
var create20 = ({ factory }) => (params) => {
  const modifiers = (() => {
    if (params.modifiers === "private") {
      return [factory.createModifier(import_typescript8.default.SyntaxKind.PrivateKeyword)];
    }
    if (params.modifiers === "public") {
      return [factory.createModifier(import_typescript8.default.SyntaxKind.PublicKeyword)];
    }
    return;
  })();
  const node = factory.createParameterDeclaration(
    modifiers,
    void 0,
    factory.createIdentifier(params.name),
    params.optional && factory.createToken(import_typescript8.default.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
var import_typescript9 = __toESM(require("typescript"), 1);
var create22 = ({ factory }) => (params) => {
  const node = factory.createPropertyAssignment(params.name, params.initializer);
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return import_typescript9.default.addSyntheticLeadingComment(node, import_typescript9.default.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
var import_typescript10 = __toESM(require("typescript"), 1);
var create24 = ({ factory }) => (params) => {
  const node = factory.createPropertySignature(
    params.readOnly ? [factory.createModifier(import_typescript10.default.SyntaxKind.ReadonlyKeyword)] : void 0,
    params.name,
    params.optional ? factory.createToken(import_typescript10.default.SyntaxKind.QuestionToken) : void 0,
    params.type
  );
  if (params.comment) {
    const comment = generateComment(params.comment);
    return import_typescript10.default.addSyntheticLeadingComment(node, import_typescript10.default.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
var import_typescript11 = __toESM(require("typescript"), 1);
var create34 = ({ factory }) => (params) => {
  const node = factory.createTypeAliasDeclaration(
    params.export && [factory.createModifier(import_typescript11.default.SyntaxKind.ExportKeyword)],
    factory.createIdentifier(params.name),
    void 0,
    params.type
  );
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return import_typescript11.default.addSyntheticLeadingComment(node, import_typescript11.default.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
var import_typescript12 = __toESM(require("typescript"), 1);

// 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(import_typescript12.default.SyntaxKind.StringKeyword);
      case "number":
      case "integer":
        if (params.enum) {
          return unionTypeNode({
            typeNodes: params.enum.map((value) => literalTypeNode({ value }))
          });
        }
        return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.NumberKeyword);
      case "boolean": {
        if (params.enum) {
          return unionTypeNode({
            typeNodes: params.enum.map((value) => literalTypeNode({ value }))
          });
        }
        return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.BooleanKeyword);
      }
      case "object":
        return factory.createTypeLiteralNode(params.value);
      case "undefined":
        return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.UndefinedKeyword);
      case "null":
        return factory.createLiteralTypeNode(factory.createNull());
      case "array":
        return factory.createArrayTypeNode(params.value);
      case "never":
        return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.NeverKeyword);
      case "void":
        return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.VoidKeyword);
      case "any":
        return factory.createKeywordTypeNode(import_typescript12.default.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
var import_typescript13 = __toESM(require("typescript"), 1);
var syntaxKinds = {
  keyof: import_typescript13.default.SyntaxKind.KeyOfKeyword,
  unique: import_typescript13.default.SyntaxKind.UniqueKeyword,
  readonly: import_typescript13.default.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
var import_typescript14 = __toESM(require("typescript"), 1);
var flags = {
  const: import_typescript14.default.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
var import_typescript15 = __toESM(require("typescript"), 1);
var create43 = ({ factory }) => (params) => {
  const node = factory.createVariableStatement(params.modifiers, params.declarationList);
  if (params.comment) {
    const comment = generateComment(params.comment, params.deprecated);
    return import_typescript15.default.addSyntheticLeadingComment(node, import_typescript15.default.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: import_typescript16.default.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
var import_typescript17 = __toESM(require("typescript"), 1);
var traverse = (create61) => (context) => (rootNode) => {
  const visit = (node) => {
    if (!import_typescript17.default.isSourceFile(node)) {
      return node;
    }
    return context.factory.updateSourceFile(
      node,
      create61(context),
      node.isDeclarationFile,
      node.referencedFiles,
      node.typeReferenceDirectives,
      node.hasNoDefaultLib,
      node.libReferenceDirectives
    );
  };
  return import_typescript17.default.visitNode(rootNode, visit);
};

// src/internal/TsGenerator/utils.ts
var utils_exports = {};
__export(utils_exports, {
  convertIntermediateCodes: () => convertIntermediateCodes,
  stringToStatements: () => stringToStatements
});
var import_typescript18 = __toESM(require("typescript"), 1);
var stringToStatements = (code) => {
  const source = import_typescript18.default.createSourceFile("", code, import_typescript18.default.ScriptTarget.ESNext, false, import_typescript18.default.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 = import_typescript19.default.createPrinter();
  return printer.printFile(sourceFile);
};
var generate = (createFunction) => {
  const source = import_typescript19.default.createSourceFile("", "", import_typescript19.default.ScriptTarget.ESNext);
  const transformers = [traverse(createFunction)];
  const result = import_typescript19.default.transform(source, transformers);
  result.dispose();
  if (result.transformed.length > 1) {
    throw new DevelopmentError("Invalid length");
  }
  return convertAstToTypeScriptCode(result.transformed[0]);
};

// src/utils.ts
var isAvailableVariableName = (text) => {
  return /^[A-Za-z_0-9]+$/.test(text);
};
var isFirstCharacterIsValidText = (text) => {
  return /^[A-Za-z]+/.test(text);
};
var escapeText = (text) => {
  if (isAvailableVariableName(text) && isFirstCharacterIsValidText(text)) {
    return text;
  }
  return `"${text}"`;
};
var escapeText2 = (text) => {
  if (isAvailableVariableName(text)) {
    return {
      escaped: false,
      text
    };
  }
  return {
    escaped: true,
    text: `"${text}"`
  };
};

// src/code-templates/_shared/ApiClientArgument.ts
var createRequestContentTypeReference = (factory, { convertedParams }) => {
  return factory.TypeAliasDeclaration.create({
    export: true,
    name: convertedParams.requestContentTypeName,
    type: factory.TypeOperatorNode.create({
      syntaxKind: "keyof",
      type: factory.TypeReferenceNode.create({
        name: convertedParams.requestBodyName
      })
    })
  });
};
var createResponseContentTypeReference = (factory, { convertedParams }) => {
  if (convertedParams.has2OrMoreSuccessResponseContentTypes) {
    return factory.TypeAliasDeclaration.create({
      export: true,
      name: convertedParams.responseContentTypeName,
      type: factory.UnionTypeNode.create({
        typeNodes: convertedParams.responseSuccessNames.map((item) => {
          return factory.TypeOperatorNode.create({
            syntaxKind: "keyof",
            type: factory.TypeReferenceNode.create({
              name: item
            })
          });
        })
      })
    });
  }
  return factory.TypeAliasDeclaration.create({
    export: true,
    name: convertedParams.responseContentTypeName,
    type: factory.TypeOperatorNode.create({
      syntaxKind: "keyof",
      type: factory.TypeReferenceNode.create({
        name: convertedParams.responseSuccessNames[0]
      })
    })
  });
};
var createHeaders = (factory, { convertedParams }) => {
  const members = [];
  if (convertedParams.has2OrMoreRequestContentTypes) {
    members.push(
      factory.PropertySignature.create({
        readOnly: false,
        name: `"Content-Type"`,
        optional: false,
        type: factory.TypeReferenceNode.create({ name: "T" })
      })
    );
  }
  if (convertedParams.has2OrMoreSuccessResponseContentTypes) {
    members.push(
      factory.PropertySignature.create({
        readOnly: false,
        name: "Accept",
        optional: false,
        type: factory.TypeReferenceNode.create({ name: "U" })
      })
    );
  }
  if (members.length === 0) {
    return void 0;
  }
  return factory.TypeLiteralNode.create({ members });
};
var create45 = (factory, params) => {
  const { convertedParams } = params;
  const typeParameters = [];
  const members = [];
  if (convertedParams.hasRequestBody && convertedParams.has2OrMoreRequestContentTypes) {
    typeParameters.push(
      factory.TypeParameterDeclaration.create({
        name: "T",
        constraint: factory.TypeReferenceNode.create({
          name: convertedParams.requestContentTypeName
        })
      })
    );
  }
  if (convertedParams.has2OrMoreSuccessResponseContentTypes) {
    typeParameters.push(
      factory.TypeParameterDeclaration.create({
        name: "U",
        constraint: factory.TypeReferenceNode.create({
          name: convertedParams.responseContentTypeName
        })
      })
    );
  }
  const headerDeclaration = createHeaders(factory, params);
  if (headerDeclaration) {
    const extraHeader = factory.PropertySignature.create({
      readOnly: false,
      name: "headers",
      optional: false,
      type: headerDeclaration
    });
    members.push(extraHeader);
  }
  if (convertedParams.hasParameter) {
    const parameter = factory.PropertySignature.create({
      readOnly: false,
      name: "parameter",
      optional: false,
      type: factory.TypeReferenceNode.create({
        name: convertedParams.parameterName
      })
    });
    members.push(parameter);
  }
  if (convertedParams.hasRequestBody) {
    const requestBody = factory.PropertySignature.create({
      readOnly: false,
      name: "requestBody",
      optional: false,
      type: factory.IndexedAccessTypeNode.create({
        objectType: factory.TypeReferenceNode.create({
          name: convertedParams.requestBodyName
        }),
        indexType: factory.TypeReferenceNode.create({
          name: convertedParams.requestFirstContentType ? `"${convertedParams.requestFirstContentType}"` : "T"
        })
      })
    });
    members.push(requestBody);
  }
  if (members.length === 0) {
    return;
  }
  return factory.InterfaceDeclaration.create({
    export: true,
    name: convertedParams.argumentParamsTypeDeclaration,
    members,
    typeParameters
  });
};

// src/code-templates/_shared/ApiClientInterface.ts
var import_typescript20 = __toESM(require("typescript"), 1);
var httpMethodList = ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
var createErrorResponsesTypeAlias = (typeName, factory, errorResponseNames) => {
  if (errorResponseNames.length === 0) {
    return factory.TypeAliasDeclaration.create({
      export: true,
      name: typeName,
      type: import_typescript20.default.factory.createToken(import_typescript20.default.SyntaxKind.VoidKeyword)
    });
  }
  return factory.TypeAliasDeclaration.create({
    export: true,
    name: typeName,
    type: factory.UnionTypeNode.create({
      typeNodes: errorResponseNames.map((name) => {
        return factory.TypeReferenceNode.create({
          name
        });
      })
    })
  });
};
var createSuccessResponseTypeAlias = (typeName, factory, successResponseNames) => {
  if (successResponseNames.length === 0) {
    return factory.TypeAliasDeclaration.create({
      export: true,
      name: typeName,
      type: import_typescript20.default.factory.createToken(import_typescript20.default.SyntaxKind.VoidKeyword)
    });
  }
  return factory.TypeAliasDeclaration.create({
    export: true,
    name: typeName,
    type: factory.UnionTypeNode.create({
      typeNodes: successResponseNames.map((name) => {
        return factory.TypeReferenceNode.create({
          name
        });
      })
    })
  });
};
var createHttpMethod = (factory) => {
  return factory.TypeAliasDeclaration.create({
    export: true,
    name: "HttpMethod",
    type: factory.TypeNode.create({ type: "string", enum: httpMethodList })
  });
};
var createQueryParamsDeclarations = (factory) => {
  const queryParameterDeclaration = factory.InterfaceDeclaration.create({
    export: true,
    name: "QueryParameter",
    members: [
      factory.PropertySignature.create({
        readOnly: false,
        name: "value",
        optional: false,
        type: factory.TypeNode.create({ type: "any" })
      }),
      factory.PropertySignature.create({
        readOnly: false,
        name: "style",
        optional: true,
        type: factory.TypeNode.create({ type: "string", enum: ["form", "spaceDelimited", "pipeDelimited", "deepObject"] })
      }),
      factory.PropertySignature.create({
        readOnly: false,
        name: "explode",
        optional: false,
        type: factory.TypeNode.create({ type: "boolean" })
      })
    ]
  });
  const queryParametersDeclaration = factory.InterfaceDeclaration.create({
    export: true,
    name: "QueryParameters",
    members: [
      factory.IndexSignatureDeclaration.create({
        name: "key",
        type: factory.TypeReferenceNode.create({ name: "QueryParameter" })
      })
    ]
  });
  return [queryParameterDeclaration, queryParametersDeclaration];
};
var createObjectLikeInterface = (factory) => {
  return factory.InterfaceDeclaration.create({
    export: true,
    name: "ObjectLike",
    members: [
      factory.IndexSignatureDeclaration.create({
        name: "key",
        type: factory.TypeNode.create({ type: "any" })
      })
    ]
  });
};
var createEncodingInterface = (factory) => {
  return factory.InterfaceDeclaration.create({
    export: true,
    name: "Encoding",
    members: [
      factory.PropertySignature.create({
        name: "contentType",
        readOnly: true,
        optional: true,
        type: factory.TypeReferenceNode.create({
          name: "string"
        })
      }),
      factory.PropertySignature.create({
        name: "headers",
        readOnly: false,
        optional: true,
        type: factory.TypeReferenceNode.create({
          name: "Record<string, any>"
        })
      }),
      factory.PropertySignature.create({
        name: "style",
        readOnly: true,
        optional: true,
        type: factory.TypeNode.create({ type: "string", enum: ["form", "spaceDelimited", "pipeDelimited", "deepObject"] })
      }),
      factory.PropertySignature.create({
        name: "explode",
        readOnly: true,
        optional: true,
        type: factory.TypeReferenceNode.create({
          name: "boolean"
        })
      }),
      factory.PropertySignature.create({
        name: "allowReserved",
        readOnly: true,
        optional: true,
        type: factory.TypeReferenceNode.create({
          name: "boolean"
        })
      })
    ]
  });
};
var create46 = (factory, list, methodType, option) => {
  const objectLikeOrAnyType = factory.UnionTypeNode.create({
    typeNodes: [
      factory.TypeReferenceNode.create({
        name: "ObjectLike"
      }),
      factory.TypeNode.create({
        type: "any"
      })
    ]
  });
  const encodingInterface = createEncodingInterface(factory);
  const requestArgs = factory.ParameterDeclaration.create({
    name: "requestArgs",
    type: factory.TypeReferenceNode.create({
      name: "RequestArgs"
    })
  });
  const options = factory.ParameterDeclaration.create({
    name: "options",
    optional: true,
    type: factory.TypeReferenceNode.create({
      name: "RequestOption"
    })
  });
  const successResponseNames = list.flatMap((item) => item.convertedParams.responseSuccessNames);
  const errorResponseNamespace = factory.Namespace.create({
    export: true,
    name: "ErrorResponse",
    statements: list.map((item) => {
      return createErrorResponsesTypeAlias(`${item.convertedParams.escapedOperationId}`, factory, item.convertedParams.responseErrorNames);
    })
  });
  const returnType = option.sync ? factory.TypeReferenceNode.create({
    name: "T"
  }) : factory.TypeReferenceNode.create({
    name: "Promise",
    typeArguments: [
      factory.TypeReferenceNode.create({
        name: "T"
      })
    ]
  });
  const functionType = factory.FunctionTypeNode.create({
    typeParameters: [
      factory.TypeParameterDeclaration.create({
        name: "T",
        defaultType: factory.TypeReferenceNode.create({
          name: "SuccessResponses"
        })
      })
    ],
    parameters: [requestArgs, options],
    type: returnType
  });
  const requestFunction = factory.PropertySignature.create({
    readOnly: false,
    name: "request",
    optional: false,
    type: functionType
  });
  const requestArgsInterfaceDeclaration = factory.InterfaceDeclaration.create({
    export: true,
    name: "RequestArgs",
    members: [
      factory.PropertySignature.create({
        name: "httpMethod",
        readOnly: true,
        optional: false,
        type: factory.TypeReferenceNode.create({ name: "HttpMethod" })
      }),
      factory.PropertySignature.create({
        name: methodType === "currying-function" ? "uri" : "url",
        readOnly: true,
        optional: false,
        type: factory.TypeReferenceNode.create({ name: "string" })
      }),
      factory.PropertySignature.create({
        name: "headers",
        readOnly: false,
        optional: false,
        type: objectLikeOrAnyType
      }),
      factory.PropertySignature.create({
        name: "requestBody",
        readOnly: false,
        optional: true,
        type: objectLikeOrAnyType
      }),
      factory.PropertySignature.create({
        name: "requestBodyEncoding",
        readOnly: false,
        optional: true,
        type: factory.TypeReferenceNode.create({ name: "Record<string, Encoding>" })
      }),
      factory.PropertySignature.create({
        name: "queryParameters",
        optional: true,
        readOnly: false,
        type: factory.UnionTypeNode.create({
          typeNodes: [
            factory.TypeReferenceNode.create({
              name: "QueryParameters"
            }),
            factory.TypeNode.create({ type: "undefined" })
          ]
        })
      })
    ],
    typeParameters: []
  });
  return [
    createHttpMethod(factory),
    createObjectLikeInterface(factory),
    ...createQueryParamsDeclarations(factory),
    createSuccessResponseTypeAlias("SuccessResponses", factory, successResponseNames),
    errorResponseNamespace,
    encodingInterface,
    requestArgsInterfaceDeclaration,
    factory.InterfaceDeclaration.create({
      export: true,
      name: "ApiClient",
      members: [requestFunction],
      typeParameters: [
        factory.TypeParameterDeclaration.create({
          name: "RequestOption"
        })
      ]
    })
  ];
};

// src/code-templates/class-api-client/ApiClientClass/Class.ts
var import_typescript21 = __toESM(require("typescript"), 1);
var create47 = (factory, members) => {
  return factory.ClassDeclaration.create({
    name: "Client",
    export: true,
    members: [
      factory.PropertyDeclaration.create({
        modifiers: [import_typescript21.default.factory.createModifier(import_typescript21.default.SyntaxKind.PrivateKeyword)],
        name: "baseUrl",
        type: import_typescript21.default.factory.createKeywordTypeNode(import_typescript21.default.SyntaxKind.StringKeyword)
      }),
      ...members
    ],
    typeParameterDeclaration: [
      factory.TypeParameterDeclaration.create({
        name: "RequestOption"
      })
    ]
  });
};

// src/code-templates/class-api-client/ApiClientClass/Constructor.ts
var create48 = (factory) => {
  const parameter1 = factory.ParameterDeclaration.create({
    modifiers: "private",
    name: "apiClient",
    type: factory.TypeReferenceNode.create({
      name: "ApiClient",
      typeArguments: [
        factory.TypeReferenceNode.create({
          name: "RequestOption"
        })
      ]
    })
  });
  const parameter2 = factory.ParameterDeclaration.create({
    name: "baseUrl",
    type: factory.TypeNode.create({
      type: "string"
    })
  });
  return factory.ConstructorDeclaration.create({
    parameters: [parameter1, parameter2],
    body: factory.Block.create({
      statements: [
        factory.ExpressionStatement.create({
          expression: factory.BinaryExpression.create({
            left: factory.PropertyAccessExpression.create({
              expression: "this",
              name: "baseUrl"
            }),
            operator: "=",
            right: factory.CallExpression.create({
              expression: factory.PropertyAccessExpression.create({
                expression: "baseUrl",
                name: "replace"
              }),
              argumentsArray: [factory.RegularExpressionLiteral.create({ text: "/\\/$/" }), factory.StringLiteral.create({ text: "" })]
            })
          })
        })
      ],
      multiLine: false
    })
  });
};

// src/code-templates/class-api-client/ApiClientClass/Method.ts
var import_os2 = require("os");

// src/code-templates/_shared/utils.ts
var getTemplateSpan = (factory, currentIndex, nextIndex, lastIndex, currentItem, nextItem) => {
  if (!nextItem) {
    return [
      factory.TemplateSpan.create({
        expression: currentItem.value,
        literal: factory.TemplateTail.create({
          text: ""
        })
      })
    ];
  }
  if (nextItem.type === "property") {
    if (lastIndex === nextIndex) {
      return [
        factory.TemplateSpan.create({
          expression: currentItem.value,
          literal: factory.TemplateTail.create({
            text: ""
          })
        }),
        factory.TemplateSpan.create({
          expression: nextItem.value,
          literal: factory.TemplateTail.create({
            text: ""
          })
        })
      ];
    }
    return [
      factory.TemplateSpan.create({
        expression: currentItem.value,
        literal: factory.TemplateTail.create({
          text: ""
        })
      }),
      factory.TemplateSpan.create({
        expression: nextItem.value,
        literal: factory.TemplateMiddle.create({
          text: ""
        })
      })
    ];
  }
  if (lastIndex === nextIndex) {
    return [
      factory.TemplateSpan.create({
        expression: currentItem.value,
        literal: factory.TemplateTail.create({
          text: nextItem.value
        })
      })
    ];
  }
  return [
    factory.TemplateSpan.create({
      expression: currentItem.value,
      literal: factory.TemplateMiddle.create({
        text: nextItem.value
      })
    })
  ];
};
var generateTemplateExpression = (factory, list) => {
  if (list.length === 0) {
    return factory.NoSubstitutionTemplateLiteral.create({
      text: ""
    });
  }
  const templateHead = factory.TemplateHead.create({
    text: list[0].type === "property" ? "" : list[0].value
  });
  const spanList = list.splice(1, list.length);
  if (spanList.length === 0 && list[0].type === "string") {
    return factory.NoSubstitutionTemplateLiteral.create({
      text: list[0].value
    });
  }
  const lastIndex = spanList.length - 1;
  const restValue = lastIndex % 2;
  let templateSpans = [];
  for (let i = 0; i <= (lastIndex - restValue) / 2; i++) {
    if (spanList.length === 0) {
      continue;
    }
    const currentIndex = 2 * i;
    const nextIndex = 2 * i + 1;
    const currentItem = spanList[currentIndex];
    const nextItem = spanList[nextIndex];
    if (currentItem.type === "string") {
      throw new Error("Logic Error");
    }
    templateSpans = templateSpans.concat(getTemplateSpan(factory, currentIndex, nextIndex, lastIndex, currentItem, nextItem));
  }
  return factory.TemplateExpression.create({
    head: templateHead,
    templateSpans
  });
};
var splitVariableText = (text) => {
  const pattern = '["[a-zA-Z_0-9.]+"]';
  const splitTexts = text.split(/(\["[a-zA-Z_0-9\\.]+"\])/g);
  return splitTexts.reduce((splitList, value) => {
    if (value === "") {
      return splitList;
    }
    if (new RegExp(pattern).test(value)) {
      const matchedValue = value.match(/[a-zA-Z_0-9\\.]+/);
      if (matchedValue) {
        splitList.push({
          kind: "element-access",
          value: matchedValue[0]
        });
      }
      return splitList;
    }
    const dotSplited = value.split(".");
    const items = dotSplited.map((childValue) => ({ kind: "string", value: childValue }));
    return splitList.concat(items);
  }, []);
};
var generateVariableIdentifier = (factory, name) => {
  if (name.startsWith("/")) {
    throw new Error(`can't start '/'. name=${name}`);
  }
  const list = splitVariableText(name);
  if (list.length === 1) {
    return factory.Identifier.create({
      name
    });
  }
  const [n1, n2, ...rest] = list;
  const first = factory.PropertyAccessExpression.create({
    expression: n1.value,
    name: n2.value
  });
  return rest.reduce((previous, current) => {
    if (current.kind === "string" && isAvailableVariableName(cu