@alagoni97/cli 0.72.1

package/dist/codegen/generators/typescript/client/protocols/nats.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNatsClient = void 0;
+/* eslint-disable security/detect-object-injection */
+/* eslint-disable sonarjs/no-duplicate-string */
+const channels_1 = require("../../channels");
+const utils_1 = require("../../../../utils");
+const coreSubscribe_1 = require("./nats/coreSubscribe");
+const corePublish_1 = require("./nats/corePublish");
+const jetstreamPublish_1 = require("./nats/jetstreamPublish");
+const jetStreamPullSubscription_1 = require("./nats/jetStreamPullSubscription");
+const jetstreamPushSubscription_1 = require("./nats/jetstreamPushSubscription");
+const utils_2 = require("../../channels/utils");
+const errors_1 = require("../../../../errors");
+async function generateNatsClient(context) {
+    const { asyncapiDocument, generator, inputType } = context;
+    if (inputType === 'asyncapi' && asyncapiDocument === undefined) {
+        throw (0, errors_1.createMissingInputDocumentError)({
+            expectedType: 'asyncapi',
+            generatorPreset: 'client'
+        });
+    }
+    if (!context.dependencyOutputs) {
+        throw (0, errors_1.createMissingDependencyOutputError)({
+            generatorPreset: 'client',
+            dependencyName: 'dependencyOutputs'
+        });
+    }
+    const channels = context.dependencyOutputs[generator.channelsGeneratorId];
+    if (!channels) {
+        throw (0, errors_1.createMissingDependencyOutputError)({
+            generatorPreset: 'client',
+            dependencyName: 'channels'
+        });
+    }
+    const renderedFunctions = channels.renderedFunctions;
+    const renderedNatsFunctions = renderedFunctions['nats'] ?? [];
+    const payloads = channels.payloadRender;
+    const parameters = channels.parameterRender;
+    const dependencies = [];
+    const importExtension = (0, utils_1.resolveImportExtension)(context.generator, context.config);
+    const modelPayloads = [
+        ...Object.values(payloads.operationModels),
+        ...Object.values(payloads.channelModels),
+        ...Object.values(payloads.otherModels)
+    ];
+    (0, utils_2.addPayloadsToDependencies)(modelPayloads, payloads.generator, context.generator, dependencies, importExtension);
+    (0, utils_2.addPayloadsToExports)(modelPayloads, dependencies);
+    (0, utils_2.addParametersToDependencies)(parameters.channelModels, parameters.generator, context.generator, dependencies, importExtension);
+    (0, utils_2.addParametersToExports)(parameters.channelModels, dependencies);
+    const natsFunctions = [];
+    for (const func of renderedNatsFunctions) {
+        const context = {
+            channelName: func.functionName,
+            channelParameterType: func.parameterType,
+            description: '',
+            messageType: func.messageType
+        };
+        switch (func.functionType) {
+            case channels_1.ChannelFunctionTypes.NATS_SUBSCRIBE:
+                natsFunctions.push((0, coreSubscribe_1.renderCoreSubscribe)(context));
+                break;
+            case channels_1.ChannelFunctionTypes.NATS_PUBLISH:
+                natsFunctions.push((0, corePublish_1.renderCorePublish)(context));
+                break;
+            case channels_1.ChannelFunctionTypes.NATS_JETSTREAM_PUBLISH:
+                natsFunctions.push((0, jetstreamPublish_1.renderJetStreamPublish)(context));
+                break;
+            case channels_1.ChannelFunctionTypes.NATS_JETSTREAM_PULL_SUBSCRIBE:
+                natsFunctions.push((0, jetStreamPullSubscription_1.renderJetStreamPullSubscription)(context));
+                break;
+            case channels_1.ChannelFunctionTypes.NATS_JETSTREAM_PUSH_SUBSCRIBE:
+                natsFunctions.push((0, jetstreamPushSubscription_1.renderJetStreamPushSubscription)(context));
+                break;
+            default:
+                break;
+        }
+    }
+    const natsChannelsImportPath = (0, utils_1.relativePath)(context.generator.outputPath, (0, utils_1.joinPath)(channels.generator.outputPath, 'nats'));
+    const channelImportPath = (0, utils_1.appendImportExtension)(`./${(0, utils_1.ensureRelativePath)(natsChannelsImportPath)}`, importExtension);
+    return `${[...new Set(dependencies)].join('\n')}
+
+//Import channel functions
+import * as nats from '${channelImportPath}';
+
+import * as Nats from 'nats';
+
+/**
+ * @class NatsClient
+ */
+export class NatsClient {
+  public nc?: Nats.NatsConnection;
+  public js?: Nats.JetStreamClient;
+  public codec?: Nats.Codec<any>;
+  public options?: Nats.ConnectionOptions;
+
+  /**
+   * Disconnect all clients from the server and drain subscriptions.
+   * 
+   * This is a gentle disconnect and make take a little.
+   */
+  async disconnect() {
+    if (!this.isClosed() && this.nc !== undefined) {
+      await this.nc.drain();
+    }
+  }
+  /**
+   * Returns whether or not any of the clients are closed
+   */
+  isClosed() {
+    if (!this.nc || this.nc.isClosed()) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Try to connect to the NATS server with user credentials
+   *
+   * @param userCreds to use
+   * @param options to connect with
+   */
+  async connectWithUserCreds(userCreds: string, options?: Nats.ConnectionOptions, codec?: Nats.Codec<any> ) {
+    return await this.connect({
+      user: userCreds,
+      ...options
+    }, codec);
+  }
+  /**
+   * Try to connect to the NATS server with user and password
+   * 
+   * @param user username to use
+   * @param pass password to use
+   * @param options to connect with
+   */
+  async connectWithUserPass(user: string, pass: string, options?: Nats.ConnectionOptions, codec?: Nats.Codec<any> ) {
+    return await this.connect({
+      user: user,
+      pass: pass,
+      ...options
+    }, codec);
+  }
+  /**
+   * Try to connect to the NATS server which has no authentication
+   
+    * @param host to connect to
+    * @param options to connect with
+    */
+  async connectToHost(host: string, options?: Nats.ConnectionOptions, codec?: Nats.Codec<any> ) {
+    return await this.connect({
+      servers: [host],
+      ...options
+    }, codec);
+  }
+
+  /**
+   * Try to connect to the NATS server with the different payloads.
+   * @param options to use, payload is omitted if sat in the AsyncAPI document.
+   */
+  connect(options: Nats.ConnectionOptions, codec?: Nats.Codec<any>): Promise<{nc: Nats.NatsConnection, js: Nats.JetStreamClient}> {
+    return new Promise(async (resolve, reject: (error: any) => void) => {
+      if (!this.isClosed()) {
+        return reject('Client is still connected, please close it first.');
+      }
+      this.options = options;
+      if (codec) {
+        this.codec = codec;
+      } else {
+        this.codec = Nats.JSONCodec();
+      }
+      try {
+        this.nc = await Nats.connect(this.options);
+        this.js = this.nc.jetstream();
+        resolve({nc: this.nc, js: this.js});
+      } catch (e: any) {
+        reject('Could not connect to NATS server');
+      }
+    })
+  }
+  ${natsFunctions.join('\n')}
+}`;
+}
+exports.generateNatsClient = generateNatsClient;

package/dist/codegen/generators/typescript/client/types.d.ts

@@ -0,0 +1,49 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { z } from 'zod';
+import { GenericCodegenContext } from '../../../types';
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+export type SupportedProtocols = 'nats';
+export declare const zodTypescriptClientGenerator: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    preset: z.ZodDefault<z.ZodLiteral<"client">>;
+    outputPath: z.ZodDefault<z.ZodString>;
+    protocols: z.ZodDefault<z.ZodArray<z.ZodEnum<["nats"]>, "many">>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"typescript">>>;
+    channelsGeneratorId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    importExtension: z.ZodOptional<z.ZodEnum<[".ts", ".js", "none"]>>;
+}, "strip", z.ZodTypeAny, {
+    preset: "client";
+    id: string;
+    dependencies: string[];
+    language: "typescript";
+    outputPath: string;
+    protocols: "nats"[];
+    channelsGeneratorId: string;
+    importExtension?: ".ts" | ".js" | "none" | undefined;
+}, {
+    preset?: "client" | undefined;
+    id?: string | undefined;
+    dependencies?: string[] | undefined;
+    language?: "typescript" | undefined;
+    outputPath?: string | undefined;
+    protocols?: "nats"[] | undefined;
+    importExtension?: ".ts" | ".js" | "none" | undefined;
+    channelsGeneratorId?: string | undefined;
+}>;
+export type TypeScriptClientGenerator = z.input<typeof zodTypescriptClientGenerator>;
+export type TypeScriptClientGeneratorInternal = z.infer<typeof zodTypescriptClientGenerator>;
+export declare const defaultTypeScriptClientGenerator: TypeScriptClientGeneratorInternal;
+export interface TypeScriptClientContext extends GenericCodegenContext {
+    inputType: 'asyncapi' | 'openapi';
+    asyncapiDocument?: AsyncAPIDocumentInterface;
+    openapiDocument?: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+    generator: TypeScriptClientGeneratorInternal;
+}
+export interface TypeScriptClientRenderType {
+    protocolResult: Record<SupportedProtocols, string>;
+    /**
+     * Generated files with path and content.
+     */
+    files: import('../../../types').GeneratedFile[];
+}

package/dist/codegen/generators/typescript/client/types.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTypeScriptClientGenerator = exports.zodTypescriptClientGenerator = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.zodTypescriptClientGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('client-typescript')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the client generator here](https://the-codegen-project.org/docs/generators/client)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default(['channels-typescript'])
+        .describe('The list of other generator IDs that this generator depends on. The client generator depends on the channels generator by default. [Read more about the client generator here](https://the-codegen-project.org/docs/generators/client)'),
+    preset: zod_1.z
+        .literal('client')
+        .default('client')
+        .describe('Generates a full-featured client that wraps the channel functions with built-in protocol connection handling. [Read more about the client generator here](https://the-codegen-project.org/docs/generators/client)'),
+    outputPath: zod_1.z
+        .string()
+        .default('src/__gen__/clients')
+        .describe('The directory path where the generated client code will be written. [Read more about the client generator here](https://the-codegen-project.org/docs/generators/client)'),
+    protocols: zod_1.z
+        .array(zod_1.z.enum(['nats']))
+        .default(['nats'])
+        .describe('The protocols to generate clients for. The client wraps the protocol channel functions and manages the underlying connection. [Read more about supported protocols here](https://the-codegen-project.org/docs/getting-started/protocols)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript'),
+    channelsGeneratorId: zod_1.z
+        .string()
+        .optional()
+        .describe('When multiple TypeScript channels generators are configured, specify which one this client generator should depend on. Defaults to "channels-typescript". [Read more about the client generator here](https://the-codegen-project.org/docs/generators/client)')
+        .default('channels-typescript'),
+    importExtension: utils_1.zodImportExtension.describe('File extension appended to relative import paths in generated client code. Use ".ts" for moduleResolution: "node16"/"nodenext", ".js" for compiled ESM output, or "none" (default) for bundlers. Overrides the global importExtension. [Read more about import extensions here](https://the-codegen-project.org/docs/configurations)')
+});
+exports.defaultTypeScriptClientGenerator = exports.zodTypescriptClientGenerator.parse({});

package/dist/codegen/generators/typescript/headers.d.ts

@@ -0,0 +1,54 @@
+import { OutputModel } from '@asyncapi/modelina';
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { GenericCodegenContext, HeadersRenderType, GeneratedFile } from '../../types';
+import { z } from 'zod';
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+export declare const zodTypescriptHeadersGenerator: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    preset: z.ZodDefault<z.ZodLiteral<"headers">>;
+    outputPath: z.ZodDefault<z.ZodString>;
+    serializationType: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"json">>>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"typescript">>>;
+    includeValidation: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    preset: "headers";
+    id: string;
+    dependencies: string[];
+    language: "typescript";
+    outputPath: string;
+    serializationType: "json";
+    includeValidation: boolean;
+}, {
+    preset?: "headers" | undefined;
+    id?: string | undefined;
+    dependencies?: string[] | undefined;
+    language?: "typescript" | undefined;
+    outputPath?: string | undefined;
+    serializationType?: "json" | undefined;
+    includeValidation?: boolean | undefined;
+}>;
+export type TypescriptHeadersGenerator = z.input<typeof zodTypescriptHeadersGenerator>;
+export type TypescriptHeadersGeneratorInternal = z.infer<typeof zodTypescriptHeadersGenerator>;
+export declare const defaultTypeScriptHeadersOptions: TypescriptHeadersGeneratorInternal;
+export interface TypescriptHeadersContext extends GenericCodegenContext {
+    inputType: 'asyncapi' | 'openapi';
+    asyncapiDocument?: AsyncAPIDocumentInterface;
+    openapiDocument?: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+    generator: TypescriptHeadersGeneratorInternal;
+}
+export type TypeScriptHeadersRenderType = HeadersRenderType<TypescriptHeadersGeneratorInternal>;
+export interface ProcessedHeadersData {
+    channelHeaders: Record<string, {
+        schema: unknown;
+        schemaId: string;
+    } | undefined>;
+}
+export declare function generateTypescriptHeadersCore({ processedData, context }: {
+    processedData: ProcessedHeadersData;
+    context: TypescriptHeadersContext;
+}): Promise<{
+    channelModels: Record<string, OutputModel | undefined>;
+    files: GeneratedFile[];
+}>;
+export declare function generateTypescriptHeaders(context: TypescriptHeadersContext): Promise<TypeScriptHeadersRenderType>;

package/dist/codegen/generators/typescript/headers.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypescriptHeaders = exports.generateTypescriptHeadersCore = exports.defaultTypeScriptHeadersOptions = exports.zodTypescriptHeadersGenerator = void 0;
+/* eslint-disable security/detect-object-injection */
+const modelina_1 = require("@asyncapi/modelina");
+const zod_1 = require("zod");
+const utils_1 = require("./utils");
+const headers_1 = require("../../inputs/asyncapi/generators/headers");
+const headers_2 = require("../../inputs/openapi/generators/headers");
+const modelina_2 = require("@asyncapi/modelina");
+const presets_1 = require("../../modelina/presets");
+const errors_1 = require("../../errors");
+const output_1 = require("../../output");
+exports.zodTypescriptHeadersGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('headers-typescript')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the headers generator here](https://the-codegen-project.org/docs/generators/headers)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default([])
+        .describe('The list of other generator IDs that this generator depends on. [Read more about the headers generator here](https://the-codegen-project.org/docs/generators/headers)'),
+    preset: zod_1.z
+        .literal('headers')
+        .default('headers')
+        .describe('Generates typed message header models with optional runtime validation. [Read more about the headers generator here](https://the-codegen-project.org/docs/generators/headers)'),
+    outputPath: zod_1.z
+        .string()
+        .default('src/__gen__/headers')
+        .describe('The directory path where the generated header models will be written. [Read more about the headers generator here](https://the-codegen-project.org/docs/generators/headers)'),
+    serializationType: zod_1.z
+        .literal('json')
+        .optional()
+        .default('json')
+        .describe('The serialization format used by the generated header models. Currently only "json" is supported. [Read more about the headers generator here](https://the-codegen-project.org/docs/generators/headers)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript'),
+    includeValidation: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('When true (default), the generated header models include built-in JSON Schema validation methods so headers can be validated at runtime. [Read more about the headers generator here](https://the-codegen-project.org/docs/generators/headers)')
+});
+exports.defaultTypeScriptHeadersOptions = exports.zodTypescriptHeadersGenerator.parse({});
+// Core generator function that works with processed data
+async function generateTypescriptHeadersCore({ processedData, context }) {
+    const { generator } = context;
+    const modelinaGenerator = new modelina_1.TypeScriptFileGenerator({
+        ...utils_1.defaultCodegenTypescriptModelinaOptions,
+        constraints: {
+            propertyKey: (0, modelina_2.typeScriptDefaultPropertyKeyConstraints)({
+                NO_SPECIAL_CHAR: (value) => value.replace(/[^a-zA-Z0-9]/g, '_')
+            })
+        },
+        enumType: 'union',
+        useJavascriptReservedKeywords: false,
+        presets: [
+            modelina_2.TS_DESCRIPTION_PRESET,
+            {
+                preset: modelina_2.TS_COMMON_PRESET,
+                options: {
+                    marshalling: true
+                }
+            },
+            (0, presets_1.createValidationPreset)({
+                includeValidation: generator.includeValidation
+            }, context)
+        ]
+    });
+    const channelModels = {};
+    const files = [];
+    for (const [channelId, headerData] of Object.entries(processedData.channelHeaders)) {
+        if (headerData) {
+            const result = await (0, output_1.generateModels)({
+                generator: modelinaGenerator,
+                input: headerData.schema,
+                outputPath: generator.outputPath
+            });
+            channelModels[channelId] =
+                result.models.length > 0 ? result.models[0] : undefined;
+            files.push(...result.files);
+        }
+        else {
+            channelModels[channelId] = undefined;
+        }
+    }
+    // Deduplicate files by path
+    const uniqueFiles = [];
+    const seenPaths = new Set();
+    for (const file of files) {
+        if (!seenPaths.has(file.path)) {
+            seenPaths.add(file.path);
+            uniqueFiles.push(file);
+        }
+    }
+    return { channelModels, files: uniqueFiles };
+}
+exports.generateTypescriptHeadersCore = generateTypescriptHeadersCore;
+// Main generator function that orchestrates input processing and generation
+async function generateTypescriptHeaders(context) {
+    const { asyncapiDocument, openapiDocument, inputType, generator } = context;
+    let processedData;
+    // Process input based on type
+    switch (inputType) {
+        case 'asyncapi':
+            if (!asyncapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'asyncapi',
+                    generatorPreset: 'headers'
+                });
+            }
+            processedData = (0, headers_1.processAsyncAPIHeaders)(asyncapiDocument);
+            break;
+        case 'openapi':
+            if (!openapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'openapi',
+                    generatorPreset: 'headers'
+                });
+            }
+            processedData = (0, headers_2.processOpenAPIHeaders)(openapiDocument);
+            break;
+        default:
+            throw new Error(`Unsupported input type: ${inputType}`);
+    }
+    // Generate models using processed data
+    const { channelModels, files } = await generateTypescriptHeadersCore({
+        processedData,
+        context
+    });
+    return {
+        channelModels,
+        generator,
+        files
+    };
+}
+exports.generateTypescriptHeaders = generateTypescriptHeaders;

package/dist/codegen/generators/typescript/index.d.ts

@@ -0,0 +1,7 @@
+export { TypeScriptChannelsGenerator, generateTypeScriptChannels, defaultTypeScriptChannelsGenerator, TypeScriptChannelsContext, TypeScriptChannelsGeneratorInternal, ChannelFunctionTypes } from './channels';
+export { TypeScriptPayloadGenerator, generateTypescriptPayload, defaultTypeScriptPayloadGenerator, TypeScriptPayloadContext, TypeScriptPayloadGeneratorInternal } from './payloads';
+export { TypescriptParametersGenerator, generateTypescriptParameters, defaultTypeScriptParametersOptions, TypescriptParametersContext, TypeScriptParameterRenderType, TypescriptParametersGeneratorInternal } from './parameters';
+export { TypeScriptClientGenerator, generateTypeScriptClient, defaultTypeScriptClientGenerator, TypeScriptClientContext, TypeScriptClientGeneratorInternal } from './client';
+export { generateTypescriptHeaders, TypescriptHeadersContext, TypescriptHeadersGenerator, defaultTypeScriptHeadersOptions, TypescriptHeadersGeneratorInternal } from './headers';
+export { generateTypescriptTypes, TypescriptTypesContext, TypescriptTypesGenerator, defaultTypeScriptTypesOptions, TypescriptTypesGeneratorInternal } from './types';
+export * from '../../modelina/presets';

package/dist/codegen/generators/typescript/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTypeScriptTypesOptions = exports.generateTypescriptTypes = exports.defaultTypeScriptHeadersOptions = exports.generateTypescriptHeaders = exports.defaultTypeScriptClientGenerator = exports.generateTypeScriptClient = exports.defaultTypeScriptParametersOptions = exports.generateTypescriptParameters = exports.defaultTypeScriptPayloadGenerator = exports.generateTypescriptPayload = exports.ChannelFunctionTypes = exports.defaultTypeScriptChannelsGenerator = exports.generateTypeScriptChannels = void 0;
+var channels_1 = require("./channels");
+Object.defineProperty(exports, "generateTypeScriptChannels", { enumerable: true, get: function () { return channels_1.generateTypeScriptChannels; } });
+Object.defineProperty(exports, "defaultTypeScriptChannelsGenerator", { enumerable: true, get: function () { return channels_1.defaultTypeScriptChannelsGenerator; } });
+Object.defineProperty(exports, "ChannelFunctionTypes", { enumerable: true, get: function () { return channels_1.ChannelFunctionTypes; } });
+var payloads_1 = require("./payloads");
+Object.defineProperty(exports, "generateTypescriptPayload", { enumerable: true, get: function () { return payloads_1.generateTypescriptPayload; } });
+Object.defineProperty(exports, "defaultTypeScriptPayloadGenerator", { enumerable: true, get: function () { return payloads_1.defaultTypeScriptPayloadGenerator; } });
+var parameters_1 = require("./parameters");
+Object.defineProperty(exports, "generateTypescriptParameters", { enumerable: true, get: function () { return parameters_1.generateTypescriptParameters; } });
+Object.defineProperty(exports, "defaultTypeScriptParametersOptions", { enumerable: true, get: function () { return parameters_1.defaultTypeScriptParametersOptions; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "generateTypeScriptClient", { enumerable: true, get: function () { return client_1.generateTypeScriptClient; } });
+Object.defineProperty(exports, "defaultTypeScriptClientGenerator", { enumerable: true, get: function () { return client_1.defaultTypeScriptClientGenerator; } });
+var headers_1 = require("./headers");
+Object.defineProperty(exports, "generateTypescriptHeaders", { enumerable: true, get: function () { return headers_1.generateTypescriptHeaders; } });
+Object.defineProperty(exports, "defaultTypeScriptHeadersOptions", { enumerable: true, get: function () { return headers_1.defaultTypeScriptHeadersOptions; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "generateTypescriptTypes", { enumerable: true, get: function () { return types_1.generateTypescriptTypes; } });
+Object.defineProperty(exports, "defaultTypeScriptTypesOptions", { enumerable: true, get: function () { return types_1.defaultTypeScriptTypesOptions; } });
+// Export presets for external use
+__exportStar(require("../../modelina/presets"), exports);