@f3liz/rescript-autogen-openapi 0.1.0

package/lib/es6/src/generators/IRToTypeGenerator.mjs

@@ -0,0 +1,241 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SchemaIR from "../core/SchemaIR.mjs";
+import * as Text from "@std/text";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as GenerationContext from "../types/GenerationContext.mjs";
+import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
+import * as ReferenceResolver from "../core/ReferenceResolver.mjs";
+
+function generateTypeWithContext(ctx, depthOpt, irType) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  if (depth > 100) {
+    GenerationContext.addWarning(ctx, {
+      TAG: "DepthLimitReached",
+      depth: depth,
+      path: ctx.path
+    });
+    return "JSON.t";
+  }
+  let recurse = nextIrType => generateTypeWithContext(ctx, depth + 1 | 0, nextIrType);
+  if (typeof irType !== "object") {
+    switch (irType) {
+      case "Boolean" :
+        return "bool";
+      case "Null" :
+        return "unit";
+      case "Unknown" :
+        return "JSON.t";
+    }
+  } else {
+    switch (irType.TAG) {
+      case "String" :
+        return "string";
+      case "Number" :
+        return "float";
+      case "Integer" :
+        return "int";
+      case "Array" :
+        return `array<` + recurse(irType.items) + `>`;
+      case "Object" :
+        let additionalProperties = irType.additionalProperties;
+        let properties = irType.properties;
+        if (properties.length === 0) {
+          if (additionalProperties !== undefined) {
+            return `dict<` + recurse(additionalProperties) + `>`;
+          } else {
+            return "JSON.t";
+          }
+        }
+        let fields = properties.map(param => {
+          let name = param[0];
+          let typeCode = recurse(param[1]);
+          let finalType = param[2] ? typeCode : `option<` + typeCode + `>`;
+          let camelName = Text.toCamelCase(name);
+          let escapedName = CodegenUtils.escapeKeyword(camelName);
+          let aliasAnnotation = escapedName !== name ? `@as("` + name + `") ` : "";
+          return `  ` + aliasAnnotation + escapedName + `: ` + finalType + `,`;
+        }).join("\n");
+        return `{\n` + fields + `\n}`;
+      case "Literal" :
+        let tmp = irType._0;
+        if (typeof tmp !== "object") {
+          return "unit";
+        }
+        switch (tmp.TAG) {
+          case "StringLiteral" :
+            return "string";
+          case "NumberLiteral" :
+            return "float";
+          case "BooleanLiteral" :
+            return "bool";
+        }
+      case "Union" :
+        let types = irType._0;
+        let match = Stdlib_Array.reduce(types, [
+          false,
+          false,
+          undefined,
+          undefined
+        ], (param, t) => {
+          let arrItem = param[2];
+          let hArr = param[0];
+          if (typeof t !== "object" || t.TAG !== "Array") {
+            return [
+              hArr,
+              true,
+              arrItem,
+              t
+            ];
+          } else {
+            return [
+              true,
+              param[1],
+              t.items,
+              param[3]
+            ];
+          }
+        });
+        let arrayItemType = match[2];
+        if (match[0] && match[1] && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
+          return `array<` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `>`;
+        }
+        if (types.every(t => {
+            if (typeof t !== "object") {
+              return false;
+            }
+            if (t.TAG !== "Literal") {
+              return false;
+            }
+            let tmp = t._0;
+            if (typeof tmp !== "object") {
+              return false;
+            } else {
+              return tmp.TAG === "StringLiteral";
+            }
+          }) && types.length !== 0 && types.length <= 50) {
+          let variants = types.map(t => {
+            if (typeof t !== "object") {
+              return "#Unknown";
+            }
+            if (t.TAG !== "Literal") {
+              return "#Unknown";
+            }
+            let s = t._0;
+            if (typeof s !== "object" || s.TAG !== "StringLiteral") {
+              return "#Unknown";
+            } else {
+              return `#` + Text.toPascalCase(s._0);
+            }
+          }).join(" | ");
+          return `[` + variants + `]`;
+        }
+        GenerationContext.addWarning(ctx, {
+          TAG: "ComplexUnionSimplified",
+          location: ctx.path,
+          types: types.map(SchemaIR.toString).join(" | ")
+        });
+        return "JSON.t";
+      case "Intersection" :
+        let types$1 = irType._0;
+        if (types$1.every(t => typeof t !== "object" ? false : t.TAG === "Reference") && types$1.length !== 0) {
+          return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
+        } else {
+          GenerationContext.addWarning(ctx, {
+            TAG: "IntersectionNotFullySupported",
+            location: ctx.path,
+            note: "Complex intersection"
+          });
+          return "JSON.t";
+        }
+      case "Reference" :
+        let ref = irType._0;
+        let available = ctx.availableSchemas;
+        let typePath;
+        if (available !== undefined) {
+          let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
+          typePath = available.includes(name) ? Text.toPascalCase(name) + `.t` : `ComponentSchemas.` + Text.toPascalCase(name) + `.t`;
+        } else {
+          typePath = Stdlib_Option.getOr(ReferenceResolver.refToTypePath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "JSON.t");
+        }
+        if (typePath === "JSON.t") {
+          GenerationContext.addWarning(ctx, {
+            TAG: "FallbackToJson",
+            reason: `Unresolved ref: ` + ref,
+            context: {
+              path: ctx.path,
+              operation: "gen ref",
+              schema: undefined
+            }
+          });
+        }
+        return typePath;
+      case "Option" :
+        return `option<` + recurse(irType._0) + `>`;
+    }
+  }
+}
+
+function generateType(depthOpt, pathOpt, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, irType) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  let path = pathOpt !== undefined ? pathOpt : "";
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let ctx = GenerationContext.make(path, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  return [
+    generateTypeWithContext(ctx, depth, irType),
+    ctx.warnings
+  ];
+}
+
+function generateNamedType(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt) {
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let ctx = GenerationContext.make(`type.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  let d = namedSchema.description;
+  let doc = d !== undefined ? CodegenUtils.generateDocString(undefined, d, undefined) : "";
+  return [
+    doc + `type ` + namedSchema.name + ` = ` + generateTypeWithContext(ctx, 0, namedSchema.type_),
+    ctx.warnings
+  ];
+}
+
+function generateAllTypes(context) {
+  let warnings = [];
+  let types = Object.values(context.schemas).toSorted((a, b) => Primitive_string.compare(a.name, b.name)).map(s => {
+    let match = generateNamedType(s, undefined, undefined, undefined);
+    warnings.push(...match[1]);
+    return match[0];
+  });
+  return [
+    types,
+    warnings
+  ];
+}
+
+function generateTypeAndSchema(namedSchema) {
+  let match = generateNamedType(namedSchema, undefined, undefined, undefined);
+  let match$1 = IRToSuryGenerator.generateNamedSchema(namedSchema, undefined, undefined, undefined);
+  return [
+    [
+      match[0],
+      match$1[0]
+    ],
+    match[1].concat(match$1[1])
+  ];
+}
+
+let addWarning = GenerationContext.addWarning;
+
+export {
+  addWarning,
+  generateTypeWithContext,
+  generateType,
+  generateNamedType,
+  generateAllTypes,
+  generateTypeAndSchema,
+}
+/* @std/text Not a pure module */

package/lib/es6/src/generators/IRToTypeScriptGenerator.mjs

@@ -0,0 +1,143 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Text from "@std/text";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SchemaIRParser from "../core/SchemaIRParser.mjs";
+
+function generateType(_irType, _isOptionalOpt) {
+  while (true) {
+    let isOptionalOpt = _isOptionalOpt;
+    let irType = _irType;
+    let isOptional = isOptionalOpt !== undefined ? isOptionalOpt : false;
+    if (typeof irType !== "object") {
+      switch (irType) {
+        case "Boolean" :
+          return "boolean";
+        case "Null" :
+          return "null";
+        case "Unknown" :
+          return "unknown";
+      }
+    } else {
+      switch (irType.TAG) {
+        case "String" :
+          return "string";
+        case "Number" :
+        case "Integer" :
+          return "number";
+        case "Array" :
+          return generateType(irType.items, undefined) + `[]`;
+        case "Object" :
+          return generateObjectType(irType.properties, irType.additionalProperties);
+        case "Literal" :
+          let literal = irType._0;
+          if (typeof literal !== "object") {
+            return "null";
+          }
+          switch (literal.TAG) {
+            case "StringLiteral" :
+              return `"` + literal._0 + `"`;
+            case "NumberLiteral" :
+              return literal._0.toString();
+            case "BooleanLiteral" :
+              if (literal._0) {
+                return "true";
+              } else {
+                return "false";
+              }
+          }
+        case "Union" :
+          return irType._0.map(t => generateType(t, undefined)).join(" | ");
+        case "Intersection" :
+          return irType._0.map(t => generateType(t, undefined)).join(" & ");
+        case "Reference" :
+          let ref = irType._0;
+          let match = ref.split("/");
+          if (match.length !== 4) {
+            return ref;
+          }
+          let match$1 = match[1];
+          if (match$1 !== "components") {
+            return ref;
+          }
+          let match$2 = match[2];
+          if (match$2 !== "schemas") {
+            return ref;
+          }
+          let name = match[3];
+          return `ComponentSchemas.` + name;
+        case "Option" :
+          let inner = irType._0;
+          if (!isOptional) {
+            return generateType(inner, undefined) + ` | undefined`;
+          }
+          _isOptionalOpt = true;
+          _irType = inner;
+          continue;
+      }
+    }
+  };
+}
+
+function generateObjectType(properties, additionalProperties) {
+  let propertyLines = properties.map(param => {
+    let isRequired = param[2];
+    let fieldType = param[1];
+    let match;
+    match = typeof fieldType !== "object" ? [
+        fieldType,
+        !isRequired
+      ] : (
+        fieldType.TAG === "Option" ? [
+            fieldType._0,
+            true
+          ] : [
+            fieldType,
+            !isRequired
+          ]
+      );
+    return `  ` + param[0] + (
+      match[1] ? "?" : ""
+    ) + `: ` + generateType(match[0], true) + `;`;
+  });
+  let additionalPropertiesLines = Stdlib_Option.mapOr(additionalProperties, [], valueType => [`  [key: string]: ` + generateType(valueType, undefined) + `;`]);
+  let allLines = propertyLines.concat(additionalPropertiesLines);
+  if (allLines.length === 0) {
+    return "Record<string, never>";
+  } else {
+    return `{\n` + allLines.join("\n") + `\n}`;
+  }
+}
+
+function generateNamedType(namedSchema) {
+  let docComment = Stdlib_Option.mapOr(namedSchema.description, "", description => `/** ` + description + ` */\n`);
+  let typeCode = generateType(namedSchema.type_, undefined);
+  let match = namedSchema.type_;
+  let declaration;
+  let exit = 0;
+  if (typeof match !== "object" || match.TAG !== "Object") {
+    exit = 1;
+  } else {
+    declaration = `export interface ` + namedSchema.name + ` ` + typeCode;
+  }
+  if (exit === 1) {
+    declaration = `export type ` + namedSchema.name + ` = ` + typeCode + `;`;
+  }
+  return docComment + declaration;
+}
+
+function generateParameterType(name, schema) {
+  let match = SchemaIRParser.parseJsonSchema(undefined, schema);
+  return [
+    Text.toCamelCase(name),
+    generateType(match[0], undefined)
+  ];
+}
+
+export {
+  generateType,
+  generateObjectType,
+  generateNamedType,
+  generateParameterType,
+}
+/* @std/text Not a pure module */

package/lib/es6/src/generators/ModuleGenerator.mjs

@@ -0,0 +1,285 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pipeline from "../core/Pipeline.mjs";
+import * as Text from "@std/text";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as FileSystem from "../core/FileSystem.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SchemaIRParser from "../core/SchemaIRParser.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as EndpointGenerator from "./EndpointGenerator.mjs";
+import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
+import * as IRToTypeGenerator from "./IRToTypeGenerator.mjs";
+import * as ComponentSchemaGenerator from "./ComponentSchemaGenerator.mjs";
+
+function generateSchemaCodeForDict(schemaDict) {
+  return Object.entries(schemaDict).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).flatMap(param => {
+    let schema = param[1];
+    let name = param[0];
+    let match = SchemaIRParser.parseJsonSchema(undefined, schema);
+    let ir = match[0];
+    let match$1 = IRToTypeGenerator.generateNamedType({
+      name: name,
+      description: schema.description,
+      type_: ir
+    }, undefined, undefined, undefined);
+    let match$2 = IRToSuryGenerator.generateNamedSchema({
+      name: name + `Schema`,
+      description: schema.description,
+      type_: ir
+    }, undefined, undefined, undefined);
+    return [
+      CodegenUtils.indent(match$1[0], 2),
+      CodegenUtils.indent(match$2[0], 2),
+      ""
+    ];
+  });
+}
+
+function generateTagModulesCode(endpoints, overrideDir, indentOpt) {
+  let indent = indentOpt !== undefined ? indentOpt : 2;
+  let groupedByTag = OpenAPIParser.groupByTag(endpoints);
+  let indentStr = " ".repeat(indent);
+  return Stdlib_Array.filterMap(Object.keys(groupedByTag).toSorted(Primitive_string.compare), tag => Stdlib_Option.map(groupedByTag[tag], tagEndpoints => {
+    let moduleName = Text.toPascalCase(tag);
+    let endpointLines = tagEndpoints.flatMap(endpoint => [
+      CodegenUtils.indent(EndpointGenerator.generateEndpointCode(endpoint, overrideDir, moduleName, undefined), indent + 2 | 0),
+      ""
+    ]);
+    return [indentStr + `module ` + moduleName + ` = {`].concat(endpointLines.concat([
+      indentStr + `}`,
+      ""
+    ]));
+  })).flatMap(lines => lines);
+}
+
+function generateTagModuleFile(tag, endpoints, $staropt$star, $staropt$star$1, overrideDir) {
+  if ($staropt$star === undefined) {
+    true;
+  }
+  let wrapInModule = $staropt$star$1 !== undefined ? $staropt$star$1 : false;
+  let moduleName = Text.toPascalCase(tag);
+  let header = CodegenUtils.generateFileHeader(`API endpoints for ` + tag);
+  let body = endpoints.map(endpoint => EndpointGenerator.generateEndpointCode(endpoint, overrideDir, moduleName, undefined)).join("\n\n");
+  if (wrapInModule) {
+    return CodegenUtils.trimMargin(`
+      |` + header.trimEnd() + `
+      |
+      |module ` + moduleName + ` = {
+      |` + CodegenUtils.indent(body, 2) + `
+      |}
+      |`, undefined);
+  } else {
+    return CodegenUtils.trimMargin(`
+      |` + header.trimEnd() + `
+      |
+      |` + body + `
+      |`, undefined);
+  }
+}
+
+function generateAllTagModules(endpoints, includeSchemasOpt, wrapInModuleOpt, overrideDir) {
+  let includeSchemas = includeSchemasOpt !== undefined ? includeSchemasOpt : true;
+  let wrapInModule = wrapInModuleOpt !== undefined ? wrapInModuleOpt : false;
+  let groupedByTag = OpenAPIParser.groupByTag(endpoints);
+  return Object.entries(groupedByTag).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => {
+    let tag = param[0];
+    return [
+      tag,
+      generateTagModuleFile(tag, param[1], includeSchemas, wrapInModule, overrideDir)
+    ];
+  });
+}
+
+function generateIndexModule(tags, moduleNameOpt) {
+  let moduleName = moduleNameOpt !== undefined ? moduleNameOpt : "API";
+  let header = CodegenUtils.generateFileHeader("Main API module index");
+  let modules = tags.toSorted(Primitive_string.compare).map(tag => {
+    let m = Text.toPascalCase(tag);
+    return `  module ` + m + ` = ` + m;
+  }).join("\n");
+  return CodegenUtils.trimMargin(`
+    |` + header.trimEnd() + `
+    |
+    |module ` + moduleName + ` = {
+    |` + modules + `
+    |}
+    |`, undefined);
+}
+
+function generateFlatModuleCode(moduleName, endpoints, overrideDir) {
+  let header = CodegenUtils.generateFileHeader(`All API endpoints in ` + moduleName);
+  let body = endpoints.map(endpoint => CodegenUtils.indent(EndpointGenerator.generateEndpointCode(endpoint, overrideDir, moduleName, undefined), 2)).join("\n\n");
+  return CodegenUtils.trimMargin(`
+    |` + header.trimEnd() + `
+    |
+    |module ` + moduleName + ` = {
+    |` + body + `
+    |}
+    |`, undefined);
+}
+
+function internalGenerateIntegratedModule(name, description, endpoints, schemas, overrideDir, isExtensionOpt, includeHeaderOpt) {
+  let isExtension = isExtensionOpt !== undefined ? isExtensionOpt : false;
+  let includeHeader = includeHeaderOpt !== undefined ? includeHeaderOpt : true;
+  let lines = [];
+  if (includeHeader) {
+    lines.push(CodegenUtils.generateFileHeader(description), "");
+  }
+  lines.push(`module ` + name + ` = {`);
+  Stdlib_Option.forEach(schemas, schemaDict => {
+    if (Object.keys(schemaDict).length !== 0) {
+      lines.push(...Belt_Array.concatMany([
+        [
+          `  // ` + (
+            isExtension ? "Extension" : "Component"
+          ) + ` Schemas`,
+          ""
+        ],
+        generateSchemaCodeForDict(schemaDict)
+      ]));
+      return;
+    }
+  });
+  if (endpoints.length !== 0) {
+    if (isExtension) {
+      lines.push("  // Extension Endpoints", "");
+    }
+    lines.push(...generateTagModulesCode(endpoints, overrideDir, undefined));
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+function generateSharedModule(endpoints, schemas, overrideDir, includeHeaderOpt) {
+  let includeHeader = includeHeaderOpt !== undefined ? includeHeaderOpt : true;
+  return internalGenerateIntegratedModule("Shared", "Shared API code", endpoints, schemas, overrideDir, undefined, includeHeader);
+}
+
+function generateExtensionModule(forkName, endpoints, schemas, overrideDir, includeHeaderOpt) {
+  let includeHeader = includeHeaderOpt !== undefined ? includeHeaderOpt : true;
+  return internalGenerateIntegratedModule(Text.toPascalCase(forkName) + `Extensions`, forkName + ` extensions`, endpoints, schemas, overrideDir, true, includeHeader);
+}
+
+function generateCombinedModule(forkName, sharedEndpoints, extensionEndpoints, sharedSchemas, extensionSchemas, overrideDir) {
+  let header = CodegenUtils.generateFileHeader(`Combined Shared and ` + forkName + ` extensions`);
+  let shared = generateSharedModule(sharedEndpoints, sharedSchemas, overrideDir, false);
+  let extension = generateExtensionModule(forkName, extensionEndpoints, extensionSchemas, overrideDir, false);
+  return CodegenUtils.trimMargin(`
+    |` + header.trimEnd() + `
+    |
+    |` + shared + `
+    |
+    |` + extension + `
+    |`, undefined);
+}
+
+function generateTagModuleFiles(endpoints, outputDir, wrapInModuleOpt, overrideDir) {
+  let wrapInModule = wrapInModuleOpt !== undefined ? wrapInModuleOpt : false;
+  let files = generateAllTagModules(endpoints, true, wrapInModule, overrideDir).map(param => {
+    let path = FileSystem.makePath(outputDir, Text.toPascalCase(param[0]) + `.res`);
+    return {
+      path: path,
+      content: param[1]
+    };
+  });
+  return Pipeline.fromFilesAndWarnings(files, []);
+}
+
+function generateFlatModuleFile(moduleName, endpoints, outputDir, overrideDir) {
+  let path = FileSystem.makePath(outputDir, moduleName + `.res`);
+  let content = generateFlatModuleCode(moduleName, endpoints, overrideDir);
+  return Pipeline.fromFile({
+    path: path,
+    content: content
+  });
+}
+
+function generateInstanceTagModules(instanceName, modulePrefix, endpoints, schemas, outputDir, overrideDir) {
+  let apiDir = FileSystem.makePath(FileSystem.makePath(outputDir, instanceName), "api");
+  let schemaFiles = Stdlib_Option.mapOr(schemas, [], schemaDict => {
+    if (Object.keys(schemaDict).length === 0) {
+      return [];
+    }
+    let result = ComponentSchemaGenerator.generate({
+      openapi: "3.1.0",
+      info: {
+        title: instanceName,
+        version: "1.0.0",
+        description: undefined
+      },
+      paths: {},
+      components: {
+        schemas: schemaDict
+      }
+    }, apiDir);
+    return result.files.map(file => {
+      if (file.path.endsWith("ComponentSchemas.res")) {
+        return {
+          path: file.path.replace("ComponentSchemas.res", modulePrefix + `ComponentSchemas.res`),
+          content: file.content
+        };
+      } else {
+        return file;
+      }
+    });
+  });
+  let groupedByTag = OpenAPIParser.groupByTag(endpoints);
+  let endpointFiles = Stdlib_Array.filterMap(Object.entries(groupedByTag).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])), param => {
+    let tag = param[0];
+    let moduleName = modulePrefix + Text.toPascalCase(tag);
+    let endpointCodes = param[1].flatMap(endpoint => [
+      EndpointGenerator.generateEndpointCode(endpoint, overrideDir, moduleName, modulePrefix),
+      ""
+    ]);
+    let content = Belt_Array.concatMany([
+      [
+        CodegenUtils.generateFileHeader(instanceName + ` API for ` + tag),
+        ""
+      ],
+      endpointCodes
+    ]).join("\n");
+    let path = FileSystem.makePath(apiDir, moduleName + `.res`);
+    return {
+      path: path,
+      content: content
+    };
+  });
+  return Pipeline.fromFilesAndWarnings(schemaFiles.concat(endpointFiles), []);
+}
+
+let generateBaseTagModules = generateInstanceTagModules;
+
+let generateForkTagModules = generateInstanceTagModules;
+
+function generateSeparatePerTagModules(baseName, basePrefix, forkName, forkPrefixOpt, sharedEndpoints, extensionEndpoints, sharedSchemas, extensionSchemas, outputDir, overrideDir) {
+  let forkPrefix = forkPrefixOpt !== undefined ? Primitive_option.valFromOption(forkPrefixOpt) : undefined;
+  return Pipeline.combine([
+    generateBaseTagModules(baseName, basePrefix, sharedEndpoints, sharedSchemas, outputDir, overrideDir),
+    generateForkTagModules(forkName, Stdlib_Option.getOr(forkPrefix, Text.toPascalCase(forkName)), extensionEndpoints, extensionSchemas, outputDir, overrideDir)
+  ]);
+}
+
+export {
+  generateSchemaCodeForDict,
+  generateTagModulesCode,
+  generateTagModuleFile,
+  generateAllTagModules,
+  generateIndexModule,
+  generateFlatModuleCode,
+  internalGenerateIntegratedModule,
+  generateSharedModule,
+  generateExtensionModule,
+  generateCombinedModule,
+  generateTagModuleFiles,
+  generateFlatModuleFile,
+  generateInstanceTagModules,
+  generateBaseTagModules,
+  generateForkTagModules,
+  generateSeparatePerTagModules,
+}
+/* @std/text Not a pure module */