@grandlinex/swagger-mate 0.30.8

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, GrandlineX
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,137 @@
+# Swagger-Mate
+> GrandLineX Swagger-Mate  project
+
+[![GitHub](https://badge.fury.io/gh/grandlinex%2Fswagger-mate.svg)](https://github.com/GrandlineX/swagger-mate)
+[![NPM](https://img.shields.io/static/v1?label=NPM&message=Package&color=red&logo=NPM)](https://www.npmjs.com/package/@grandlinex/swagger-mate)
+![TS](https://img.shields.io/static/v1?label=Language&message=TypeScript&color=blue&logo=TypeScript)
+
+### Status
+![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=alert_status)
+![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=security_rating)
+![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=sqale_rating)
+![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=reliability_rating)
+![Coverage](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=coverage)
+
+### Issues
+![Bugs](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=bugs)
+![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=vulnerabilities)
+![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=GrandlineX_swagger-mate&metric=code_smells)
+
+## Features
+
+- Generate swagger.{json|yml} from code
+- Generate Api client from swagger.{json|yml}
+
+
+## Quick Start
+
+### Install
+
+1. Insatal npm package
+```shell
+  npm i  @grandlinex/swagger-mate
+```
+
+2. Update package.json 
+```json
+{
+  //...
+  "scripts": {
+    "makeSpec": "swagger-mate",
+    "serveSpec": "swagger-mate --serve",
+    "buildSpecMain": "swagger-mate --build --main",
+    "buildSpecDev": "swagger-mate --build --dev"
+  },
+  "glx": {
+    "kernel": "dist/Kernel.js"
+  }
+  //...
+}
+```
+
+|Command| Description                                                                       |
+|---|-----------------------------------------------------------------------------------|
+|`npm run makeSpec`| make `openapi.json`                                                               |
+|`npm run serveSpec`| serve `openapi.json` with [swagger-ui](https://github.com/swagger-api/swagger-ui) |
+|`npm run buildSpecMain`| build api client (prod)                                                           |
+|`npm run buildSpecDev`| build api client (dev)                                                           |
+
+### Serve option
+
+> Default port = 9000
+
+ENV variables
+
+| ENV | Description              |
+|-----|--------------------------|
+|  SW_PORT   | set custom serve port    |
+|  SW_AUTH   | set default bearer token |
+
+## Define types
+
+### Kernel
+
+```typescript
+import { SPathUtil, Swagger } from '@grandlinex/swagger-mate';
+// OpenApi 3.0.3 - Root Api definition
+@Swagger({
+  info: {
+    title: 'KernelTest',
+    version: '0.1.0', // Version (optional) will be read from package.json
+  },
+  openapi: '3.0.3',
+  servers: [
+    {
+      url: 'http://localhost:9257',
+      description: 'LocalDev',
+    },
+  ],
+  paths: {
+      // Static definition
+    '/version': {
+      get: {
+        description: 'Get version',
+        operationId: 'getVersion',
+        responses: SPathUtil.defaultResponse('200', '500'),
+      },
+    },
+   // Dynamic definition will be read from @SPath
+  },
+  security: [
+    {
+      bearerAuth: [],
+    },
+  ],
+  components: {
+    securitySchemes: {
+      bearerAuth: {
+        type: 'http',
+        scheme: 'bearer',
+        bearerFormat: 'JWT',
+      },
+    },
+  },
+})
+export default class SomeKernel {}
+
+```
+
+### Action
+
+```typescript
+import { SPathUtil, Swagger } from '@grandlinex/swagger-mate';
+
+// OpenApi 3.0.3 - Patch definition
+@SPath({
+    '/test': {
+        get: {
+            description: 'test',
+            operationId: 'getTest', // name for the js api client
+            summary: 'Descritption summary',
+            responses: SPathUtil.defaultResponse('200','400', '500')
+        },
+    },
+})
+export default class SomeBaseApiAction {}
+
+```

package/dist/cjs/PathHelp.d.ts

@@ -0,0 +1,2 @@
+export declare function getBaseFolder(): string;
+export default function PathHelp(base: string, ...inp: string[]): string;

package/dist/cjs/PathHelp.js

@@ -0,0 +1,47 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseFolder = void 0;
+const path_1 = __importDefault(require("path"));
+const process = __importStar(require("process"));
+function getBaseFolder() {
+    const dir = typeof __dirname !== 'undefined' ? __dirname : process.env.SM__DIRNAME;
+    if (!dir) {
+        throw new Error('Cant find base folder');
+    }
+    return dir;
+}
+exports.getBaseFolder = getBaseFolder;
+function PathHelp(base, ...inp) {
+    const { env } = process;
+    if (env.dev) {
+        return path_1.default.join(base, ...inp);
+    }
+    return path_1.default.join(base, '..', ...inp);
+}
+exports.default = PathHelp;

package/dist/cjs/Swagger/Client/ClientUtil.d.ts

@@ -0,0 +1,59 @@
+import { SSchemaEl } from '../Meta/SwaggerTypes.js';
+export type IfMappingKeyType = {
+    key: string;
+    type: string;
+    required?: boolean;
+};
+export type IfMappingType = {
+    name: string;
+    keys: IfMappingKeyType[];
+    rawType?: string;
+};
+/**
+ * Save string from unknown
+ * @param e
+ */
+export declare function eS(e: any): string;
+/**
+ * Optional field
+ * @param required
+ */
+export declare function rq(required?: boolean): string;
+export declare function sK(e: string): string;
+/**
+ * Cast first letter to uppercase
+ * @param e
+ */
+export declare function fuc(e: string): string;
+/**
+ * Spacing function
+ * @param c number of spaces
+ */
+export declare function S(c: number): string;
+export declare enum IFTag {
+    'RequestBody' = "RequestBody",
+    'Response' = "Response"
+}
+/**
+ * InterfaceName secure function
+ */
+export declare function saveName(inp: string): string;
+/**
+ * InterfaceName Helper function
+ */
+export declare function ifName(operation: string, tag: IFTag | string, use?: boolean): string;
+export declare function typeByRef(ref: string, use?: boolean): string;
+/**
+ * Map schema to typescript interface
+ * @param operation
+ * @param tag
+ * @param schema
+ */
+export declare function transformInterface(operation: string, tag: IFTag | string, schema: SSchemaEl): IfMappingType[];
+/**
+ * Map schema to typescript interface
+ * @param operation
+ * @param tag
+ * @param schema
+ */
+export declare function transformFormInterface(operation: string, tag: IFTag | string, schema: SSchemaEl): IfMappingType[];

package/dist/cjs/Swagger/Client/ClientUtil.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFormInterface = exports.transformInterface = exports.typeByRef = exports.ifName = exports.saveName = exports.IFTag = exports.S = exports.fuc = exports.sK = exports.rq = exports.eS = void 0;
+const SwaggerTypes_js_1 = require("../Meta/SwaggerTypes.js");
+/**
+ * Save string from unknown
+ * @param e
+ */
+function eS(e) {
+    return e || '';
+}
+exports.eS = eS;
+/**
+ * Optional field
+ * @param required
+ */
+function rq(required) {
+    if (!required) {
+        return '?:';
+    }
+    return ':';
+}
+exports.rq = rq;
+function sK(e) {
+    if (e.indexOf(':') >= 0) {
+        return `'${e}'`;
+    }
+    return e;
+}
+exports.sK = sK;
+/**
+ * Cast first letter to uppercase
+ * @param e
+ */
+function fuc(e) {
+    if (e.length === 0) {
+        return '';
+    }
+    return e.charAt(0).toUpperCase() + e.substring(1);
+}
+exports.fuc = fuc;
+/**
+ * Spacing function
+ * @param c number of spaces
+ */
+function S(c) {
+    let o = '';
+    for (let i = 0; i < c; i++) {
+        o += ' ';
+    }
+    return o;
+}
+exports.S = S;
+var IFTag;
+(function (IFTag) {
+    IFTag["RequestBody"] = "RequestBody";
+    IFTag["Response"] = "Response";
+})(IFTag || (exports.IFTag = IFTag = {}));
+/**
+ * InterfaceName secure function
+ */
+function saveName(inp) {
+    return inp.replace(/[^a-zA-Z0-9[\]]/g, 'X');
+}
+exports.saveName = saveName;
+/**
+ * InterfaceName Helper function
+ */
+function ifName(operation, tag, use) {
+    return `${use ? 'TX.' : ''}${saveName(fuc(operation))}${saveName(fuc(tag))}`;
+}
+exports.ifName = ifName;
+function typeByRef(ref, use) {
+    return `${use ? 'TX.' : ''}${fuc(ref.substring(1 + ref.lastIndexOf('/')))}`;
+}
+exports.typeByRef = typeByRef;
+/**
+ * Map schema to typescript interface
+ * @param operation
+ * @param tag
+ * @param schema
+ */
+function transformInterface(operation, tag, schema) {
+    const out = [];
+    const cur = {
+        name: ifName(operation, tag),
+        keys: [],
+    };
+    let keys = null;
+    if (!(0, SwaggerTypes_js_1.isSwaggerRef)(schema)) {
+        switch (schema.type) {
+            case 'object':
+                if (schema.properties) {
+                    keys = Object.keys(schema.properties || {});
+                    for (const key of keys) {
+                        const prop = schema.properties[key];
+                        const isRequired = schema.required && schema.required.includes(key);
+                        if (!(0, SwaggerTypes_js_1.isSwaggerRef)(prop)) {
+                            switch (prop.type) {
+                                case 'number':
+                                case 'integer':
+                                    cur.keys.push({ key, type: 'number', required: isRequired });
+                                    break;
+                                case 'string':
+                                    cur.keys.push({ key, type: 'string', required: isRequired });
+                                    break;
+                                case 'boolean':
+                                    cur.keys.push({ key, type: 'boolean', required: isRequired });
+                                    break;
+                                case 'object':
+                                    if (!prop.properties) {
+                                        cur.keys.push({ key, type: 'any', required: isRequired });
+                                    }
+                                    else {
+                                        cur.keys.push({
+                                            key,
+                                            type: ifName(cur.name, key),
+                                            required: isRequired,
+                                        });
+                                        out.push(...transformInterface(cur.name, key, prop));
+                                    }
+                                    break;
+                                case 'array':
+                                    if ((0, SwaggerTypes_js_1.isSwaggerRef)(prop.items)) {
+                                        cur.keys.push({
+                                            key,
+                                            type: `${typeByRef(prop.items.$ref)}[]`,
+                                            required: isRequired,
+                                        });
+                                    }
+                                    else {
+                                        cur.keys.push({
+                                            key,
+                                            type: `${ifName(cur.name, `${key}Element`)}[]`,
+                                            required: isRequired,
+                                        });
+                                        out.push(...transformInterface(cur.name, key, prop));
+                                    }
+                                    break;
+                                default:
+                            }
+                        }
+                        else {
+                            cur.keys.push({
+                                key,
+                                type: typeByRef(prop.$ref),
+                                required: isRequired,
+                            });
+                        }
+                    }
+                    out.push(cur);
+                }
+                else {
+                    out.push({
+                        ...cur,
+                        rawType: 'any',
+                    });
+                }
+                break;
+            case 'array':
+                if (schema.items) {
+                    if ((0, SwaggerTypes_js_1.isSwaggerRef)(schema.items)) {
+                        out.push({
+                            keys: [],
+                            name: cur.name,
+                            rawType: `${typeByRef(schema.items.$ref)}[]`,
+                        });
+                    }
+                    else {
+                        const int = transformInterface(cur.name, 'Element', schema.items);
+                        out.push(...int);
+                        out.push({
+                            keys: [],
+                            name: cur.name,
+                            rawType: `${ifName(cur.name, 'Element')}[]`,
+                        });
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    else {
+        cur.rawType = `${typeByRef(schema.$ref)}`;
+        out.push(cur);
+    }
+    return out;
+}
+exports.transformInterface = transformInterface;
+/**
+ * Map schema to typescript interface
+ * @param operation
+ * @param tag
+ * @param schema
+ */
+function transformFormInterface(operation, tag, schema) {
+    const out = [];
+    const cur = {
+        name: ifName(operation, tag),
+        keys: [],
+    };
+    const keys = null;
+    cur.rawType = `FormData`;
+    out.push(cur);
+    return out;
+}
+exports.transformFormInterface = transformFormInterface;

package/dist/cjs/Swagger/Client/FunctionProps.d.ts

@@ -0,0 +1,4 @@
+import { SwaggerRPathConf } from '../Meta/SwaggerTypes.js';
+import { FunctionTemplateProps } from './FunctionTemplate.js';
+declare function functionProps(route: string, t: 'get' | 'post' | 'patch' | 'delete' | 'update', cur: SwaggerRPathConf): FunctionTemplateProps;
+export default functionProps;

package/dist/cjs/Swagger/Client/FunctionProps.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SwaggerTypes_js_1 = require("../Meta/SwaggerTypes.js");
+const ClientUtil_js_1 = require("./ClientUtil.js");
+const FunctionTemplate_js_1 = require("./FunctionTemplate.js");
+function functionProps(route, t, cur) {
+    const comments = [];
+    if (cur.description) {
+        comments.push(cur.description);
+    }
+    if (cur.summary) {
+        comments.push(cur.summary);
+    }
+    const queryKey = [];
+    const param = [];
+    const paramKey = [];
+    let bodyType = 'unknown';
+    cur.parameters
+        ?.filter((el) => el.in === 'path')
+        .forEach((el) => {
+        param.push(`${el.name}: string `);
+        paramKey.push(el.name);
+        if (el.description) {
+            comments.push(`@param ${el.name} ${el.description}`);
+        }
+    });
+    if (cur.requestBody && cur.operationId) {
+        bodyType = (0, ClientUtil_js_1.ifName)(cur.operationId, ClientUtil_js_1.IFTag.RequestBody, true);
+        param.push(`body: ${bodyType}`);
+    }
+    cur.parameters
+        ?.filter((el) => el.in === 'query')
+        .forEach((el) => {
+        param.push(`${el.name}?: string `);
+        queryKey.push(el.name);
+        if (el.description) {
+            comments.push(`@param ${el.name} ${el.description}`);
+        }
+    });
+    let type = 'unknown';
+    const active = cur.responses?.['200'] || cur.responses?.['201'];
+    if (cur.operationId &&
+        active &&
+        !(0, SwaggerTypes_js_1.isSwaggerRef)(active) &&
+        active.content?.['application/json']) {
+        type = (0, ClientUtil_js_1.ifName)(cur.operationId, ClientUtil_js_1.IFTag.Response, true);
+    }
+    else if (cur.operationId && active && (0, SwaggerTypes_js_1.isSwaggerRef)(active)) {
+        type = (0, ClientUtil_js_1.typeByRef)(active.$ref, true);
+    }
+    return {
+        FC_PROPS: `${param.join(',')}`,
+        FC_BODY: (0, FunctionTemplate_js_1.reqBody)(t.toUpperCase(), route, paramKey, !!cur.requestBody, type, bodyType, queryKey),
+        FC_GEN: '',
+        FC_RETURN: `: Promise<HandleRes<${type}>> `,
+        FC_ASYNC: 'async ',
+        FC_DOC: comments,
+    };
+}
+exports.default = functionProps;

package/dist/cjs/Swagger/Client/FunctionTemplate.d.ts

@@ -0,0 +1,13 @@
+export type FunctionTemplateProps = {
+    FC_PROPS: string;
+    FC_BODY: string;
+    FC_GEN: string;
+    FC_RETURN: string;
+    FC_ASYNC: string;
+    FC_DOC: string[];
+};
+declare function functionTemplate(FC_NAME: string, props: Partial<FunctionTemplateProps>): string;
+declare function functionInterfaceTemplate(FC_NAME: string, props: Partial<FunctionTemplateProps>): string;
+declare function abstractInterfaceTemplate(FC_NAME: string, props: Partial<FunctionTemplateProps>): string;
+declare function reqBody(rType: string, path: string, paramKey: string[], hasBody: boolean, type: string, bodyType: string, queryKey: string[]): string;
+export { functionTemplate, reqBody, functionInterfaceTemplate, abstractInterfaceTemplate, };

package/dist/cjs/Swagger/Client/FunctionTemplate.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abstractInterfaceTemplate = exports.functionInterfaceTemplate = exports.reqBody = exports.functionTemplate = void 0;
+const ClientUtil_js_1 = require("./ClientUtil.js");
+function docTemplate(inp, doc) {
+    const dDoc = [];
+    if (doc && doc.length > 0) {
+        dDoc.push(`${(0, ClientUtil_js_1.S)(2)}/**`);
+        doc.forEach((el) => dDoc.push(`${(0, ClientUtil_js_1.S)(2)} * ${el}`));
+        dDoc.push(`${(0, ClientUtil_js_1.S)(2)} */`);
+        return [...dDoc, inp].join('\n');
+    }
+    return inp;
+}
+function functionTemplate(FC_NAME, props) {
+    const { FC_PROPS, FC_BODY, FC_RETURN, FC_GEN, FC_ASYNC } = props;
+    return docTemplate(`${(0, ClientUtil_js_1.S)(2)}${(0, ClientUtil_js_1.eS)(FC_ASYNC)}${(0, ClientUtil_js_1.eS)(FC_NAME)}${(0, ClientUtil_js_1.eS)(FC_GEN)}(${(0, ClientUtil_js_1.eS)(FC_PROPS)})${(0, ClientUtil_js_1.eS)(FC_RETURN)}{
+${(0, ClientUtil_js_1.S)(4)}${(0, ClientUtil_js_1.eS)(FC_BODY)}
+${(0, ClientUtil_js_1.S)(2)}}`, props.FC_DOC);
+}
+exports.functionTemplate = functionTemplate;
+function functionInterfaceTemplate(FC_NAME, props) {
+    const { FC_PROPS, FC_RETURN, FC_GEN, FC_DOC } = props;
+    return docTemplate(`${(0, ClientUtil_js_1.S)(2)}${(0, ClientUtil_js_1.eS)(FC_NAME)}${(0, ClientUtil_js_1.eS)(FC_GEN)}(${(0, ClientUtil_js_1.eS)(FC_PROPS)})${(0, ClientUtil_js_1.eS)(FC_RETURN)}`, FC_DOC);
+}
+exports.functionInterfaceTemplate = functionInterfaceTemplate;
+function abstractInterfaceTemplate(FC_NAME, props) {
+    const { FC_PROPS, FC_RETURN, FC_GEN, FC_DOC } = props;
+    return docTemplate(`${(0, ClientUtil_js_1.S)(2)}abstract ${(0, ClientUtil_js_1.eS)(FC_NAME)}${(0, ClientUtil_js_1.eS)(FC_GEN)}(${(0, ClientUtil_js_1.eS)(FC_PROPS)})${(0, ClientUtil_js_1.eS)(FC_RETURN)};`, FC_DOC);
+}
+exports.abstractInterfaceTemplate = abstractInterfaceTemplate;
+function reqBody(rType, path, paramKey, hasBody, type, bodyType, queryKey) {
+    let q = 'undefined';
+    if (queryKey.length > 0 || paramKey.length > 0) {
+        const comp = [];
+        if (paramKey.length > 0) {
+            comp.push(`param: {${paramKey.join(',')}}`);
+        }
+        if (queryKey.length > 0) {
+            comp.push(`query: {${queryKey.join(',')}}`);
+        }
+        q = `{${comp.join(',')}}`;
+    }
+    return `return this.handle<${type}, ${bodyType}>('${rType}','${path}',${hasBody ? 'body' : 'undefined'}, ${q});`;
+}
+exports.reqBody = reqBody;

package/dist/cjs/Swagger/Client/InterfaceTemplate.d.ts

@@ -0,0 +1,3 @@
+import { IfMappingKeyType } from './ClientUtil.js';
+declare function interfaceTemplate(IF_NAME: string, types: IfMappingKeyType[], rawType?: string): string;
+export { interfaceTemplate, };

package/dist/cjs/Swagger/Client/InterfaceTemplate.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interfaceTemplate = void 0;
+/* eslint-disable prettier/prettier */
+const ClientUtil_js_1 = require("./ClientUtil.js");
+function interfaceTemplate(IF_NAME, types, rawType) {
+    if (rawType) {
+        return `export type ${IF_NAME} = ${rawType};`;
+    }
+    return `export interface ${IF_NAME} {
+${types.map(({ key, type, required }) => `${(0, ClientUtil_js_1.S)(2)}${(0, ClientUtil_js_1.sK)(key)}${(0, ClientUtil_js_1.rq)(required)} ${type};`).join('\n')}
+}`;
+}
+exports.interfaceTemplate = interfaceTemplate;

package/dist/cjs/Swagger/Client/SwaggerClient.d.ts

@@ -0,0 +1,4 @@
+import { SwaggerConfig } from '../Meta/SwaggerTypes.js';
+export default class SwaggerClient {
+    static genAPICConnector(conf: SwaggerConfig, name?: string, version?: string, writeMeta?: boolean): void;
+}