@skmtc/core 0.0.29 → 0.0.218

package/script/server/createServer.js

@@ -0,0 +1,134 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+const Sentry = __importStar(require("@sentry/deno"));
+const hono_1 = require("hono");
+const ts_pattern_1 = require("ts-pattern");
+const zod_1 = require("zod");
+const Settings_js_1 = require("../types/Settings.js");
+const generate_js_1 = require("../generate/generate.js");
+const ParseContext_js_1 = require("../context/ParseContext.js");
+const CoreContext_js_1 = require("../context/CoreContext.js");
+const parse_js_1 = require("../parse/parse.js");
+const postSettingsBody = zod_1.z.object({
+    schema: zod_1.z.string(),
+    clientSettings: Settings_js_1.clientSettings.optional()
+});
+const postGenerateBody = zod_1.z.object({
+    schema: zod_1.z.string(),
+    clientSettings: Settings_js_1.clientSettings.optional(),
+    prettier: zod_1.z.record(zod_1.z.unknown()).optional()
+});
+const createServer = (generators) => {
+    const app = new hono_1.Hono();
+    app.post('/artifacts', async (c) => {
+        const result = await Sentry.startSpan({ name: 'POST /artifacts' }, async () => {
+            console.log('HEADERS ', c.req.header());
+            const body = await Sentry.startSpan({ name: 'Parse JSON' }, () => c.req.json());
+            const { schema, clientSettings, prettier } = await Sentry.startSpan({ name: 'Validate request content' }, () => postGenerateBody.parseAsync(body));
+            return await Sentry.startSpan({ name: 'Generate' }, async () => {
+                const generatorsMap = Object.fromEntries(generators.map(generator => [generator.id, generator]));
+                return await (0, generate_js_1.generate)({
+                    schema,
+                    prettier,
+                    settings: clientSettings,
+                    generatorsMap
+                });
+            });
+        });
+        return c.json(result);
+    });
+    app.get('/generators', c => {
+        return Sentry.startSpan({ name: 'GET /generators' }, () => c.json({ generators }));
+    });
+    app.post('/settings', async (c) => {
+        return await Sentry.startSpan({ name: 'POST /settings' }, async () => {
+            const body = await c.req.json();
+            const { clientSettings } = postSettingsBody.parse(body);
+            const oasDocument = await toOasDocument(body.schema);
+            const out = generators.map(generator => {
+                const generatorSettings = clientSettings?.generators?.find(({ id }) => id === generator.id);
+                const generatorType = generator.type;
+                return (0, ts_pattern_1.match)(generatorType)
+                    .with('operation', () => ({
+                    ...generatorSettings,
+                    id: generator.id,
+                    operations: toOperations({
+                        generator: generator,
+                        oasDocument,
+                        operationsSettings: generatorSettings && 'operations' in generatorSettings
+                            ? generatorSettings.operations
+                            : undefined
+                    })
+                }))
+                    .with('model', () => ({
+                    ...generatorSettings,
+                    id: generator.id,
+                    models: toModels({
+                        oasDocument,
+                        modelsSettings: generatorSettings && 'models' in generatorSettings
+                            ? generatorSettings.models
+                            : undefined
+                    })
+                }))
+                    .otherwise(matched => {
+                    throw new Error(`Invalid generator type: '${matched}' for ${generator.id}`);
+                });
+            });
+            return c.json({ generators: out });
+        });
+    });
+    return app;
+};
+exports.createServer = createServer;
+const toModels = ({ oasDocument, modelsSettings }) => {
+    return Object.fromEntries(Object.keys(oasDocument.components?.schemas ?? {}).map(refName => [
+        refName,
+        modelsSettings?.[refName]
+            ? modelsSettings?.[refName]
+            : { selected: false }
+    ]));
+};
+const toOperations = ({ generator, oasDocument, operationsSettings }) => {
+    return Object.values(oasDocument.operations)
+        .filter(operation => generator.isSupported?.(operation) ?? true)
+        .reduce((acc, operation) => {
+        const { path, method } = operation;
+        acc[path] = acc[path] ?? {};
+        acc[path][method] = operationsSettings?.[path]?.[method]
+            ? operationsSettings?.[path]?.[method]
+            : { selected: false };
+        return acc;
+    }, {});
+};
+const toOasDocument = (schema) => {
+    const parsedDocument = (0, generate_js_1.parseSchema)(schema);
+    const parseContext = new ParseContext_js_1.ParseContext({ parsedDocument });
+    const context = new CoreContext_js_1.CoreContext({
+        phase: { type: 'parse', context: parseContext }
+    });
+    return (0, parse_js_1.oasToSkmtc)(context);
+};

package/script/types/Brand.d.ts

@@ -0,0 +1,6 @@
+declare const brand: unique symbol;
+export type Brand<T, TBrand> = T & {
+    [brand]: TBrand;
+};
+export {};
+//# sourceMappingURL=Brand.d.ts.map

package/script/types/Brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Brand.d.ts","sourceRoot":"","sources":["../../src/types/Brand.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAA;AAElC,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,GAAG;IAAE,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA"}

package/script/types/CustomValue.d.ts

@@ -1,10 +1,18 @@
+import type { CoreContext } from '../context/CoreContext.js';
+import { ValueBase } from '../dsl/ValueBase.js';
 import type { Stringable } from '../dsl/Stringable.js';
-export declare class CustomValue {
-    type: 'custom';
+import type { GeneratorKey } from './GeneratorKeys.js';
+type CreateArgs = {
+    context: CoreContext;
     value: Stringable;
-    private constructor();
-    static create(value: Stringable): CustomValue;
+    generatorKey: GeneratorKey;
+};
+export declare class CustomValue extends ValueBase {
+    type: "custom";
+    value: Stringable;
+    constructor({ context, value, generatorKey }: CreateArgs);
     toString(): string;
 }
 export declare const isCustomValue: (value: unknown) => value is CustomValue;
+export {};
 //# sourceMappingURL=CustomValue.d.ts.map

package/script/types/CustomValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CustomValue.d.ts","sourceRoot":"","sources":["../../src/types/CustomValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAEtD,qBAAa,WAAW;IACtB,IAAI,EAAE,QAAQ,CAAW;IACzB,KAAK,EAAE,UAAU,CAAA;IAEjB,OAAO;IAIP,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW;IAI7C,QAAQ,IAAI,MAAM;CAGnB;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,yBAO3C,CAAA"}
+{"version":3,"file":"CustomValue.d.ts","sourceRoot":"","sources":["../../src/types/CustomValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,WAAW,CAAA;IACpB,KAAK,EAAE,UAAU,CAAA;IACjB,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAA;AAED,qBAAa,WAAY,SAAQ,SAAS;IACxC,IAAI,WAAoB;IACxB,KAAK,EAAE,UAAU,CAAA;gBAEL,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,UAAU;IAMxD,QAAQ,IAAI,MAAM;CAGnB;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,KAAK,IAAI,WAOvD,CAAA"}

package/script/types/CustomValue.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCustomValue = exports.CustomValue = void 0;
-class CustomValue {
-    constructor(value) {
+const ValueBase_js_1 = require("../dsl/ValueBase.js");
+class CustomValue extends ValueBase_js_1.ValueBase {
+    constructor({ context, value, generatorKey }) {
+        super({ context, generatorKey });
         Object.defineProperty(this, "type", {
             enumerable: true,
             configurable: true,
@@ -17,9 +19,6 @@ class CustomValue {
         });
         this.value = value;
     }
-    static create(value) {
-        return new CustomValue(value);
-    }
     toString() {
         return `${this.value}`;
     }

package/script/types/GeneratedValue.d.ts

@@ -0,0 +1,6 @@
+import type { Stringable } from '../dsl/Stringable.js';
+import type { GeneratorKey } from './GeneratorKeys.js';
+export type GeneratedValue = Stringable & {
+    generatorKey: GeneratorKey;
+};
+//# sourceMappingURL=GeneratedValue.d.ts.map

package/script/types/GeneratedValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratedValue.d.ts","sourceRoot":"","sources":["../../src/types/GeneratedValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG;IACxC,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAA"}

package/script/types/GeneratedValue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/types/GenerationType.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 'force' - will generate content even it is not selected.
+ * Use this option when generating code via a dependency.
+ * For example, when you are generating a form and it needs
+ * an accompanying API client as well. You should use 'force'
+ * when generating the API client to ensure it is generated
+ * event the API client itself is not selected.
+ *
+ * 'regular' - will generate content only if it is selected.
+ *
+ * 'lazy' - will create a Driver instance but not apply it, until
+ * the value is accessed. This is useful when you want a quick way
+ * to access settings for a creator without generating the content.
+ */
+export type GenerationType = 'force' | 'regular' | 'lazy';
+//# sourceMappingURL=GenerationType.d.ts.map

package/script/types/GenerationType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerationType.d.ts","sourceRoot":"","sources":["../../src/types/GenerationType.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA"}

package/script/types/GenerationType.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * 'force' - will generate content even it is not selected.
+ * Use this option when generating code via a dependency.
+ * For example, when you are generating a form and it needs
+ * an accompanying API client as well. You should use 'force'
+ * when generating the API client to ensure it is generated
+ * event the API client itself is not selected.
+ *
+ * 'regular' - will generate content only if it is selected.
+ *
+ * 'lazy' - will create a Driver instance but not apply it, until
+ * the value is accessed. This is useful when you want a quick way
+ * to access settings for a creator without generating the content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/types/GeneratorKeys.d.ts

@@ -0,0 +1,30 @@
+import type { OasOperation } from '../oas/operation/Operation.js';
+import type { Brand } from './Brand.js';
+import type { Method } from './Method.js';
+import type { RefName } from './RefName.js';
+export type NakedOperationGeneratorKey = `${string}|${string}|${Method}`;
+export type NakedModelGeneratorKey = `${string}|${string}`;
+export type OperationGeneratorKey = Brand<NakedOperationGeneratorKey, 'OperationGeneratorKey'>;
+export type ModelGeneratorKey = Brand<NakedModelGeneratorKey, 'ModelGeneratorKey'>;
+export type GeneratorOnlyKey = Brand<string, 'GeneratorOnlyKey'>;
+export type GeneratorKey = OperationGeneratorKey | ModelGeneratorKey | GeneratorOnlyKey;
+type ToOperationGeneratorKeyArgs = {
+    generatorId: string;
+    path: string;
+    method: Method;
+} | {
+    generatorId: string;
+    operation: OasOperation;
+};
+export declare const toOperationGeneratorKey: ({ generatorId, ...rest }: ToOperationGeneratorKeyArgs) => OperationGeneratorKey;
+type ToModelGeneratorKeyArgs = {
+    generatorId: string;
+    refName: RefName;
+};
+export declare const toModelGeneratorKey: ({ generatorId, refName }: ToModelGeneratorKeyArgs) => ModelGeneratorKey;
+type ToGeneratorOnlyKeyArgs = {
+    generatorId: string;
+};
+export declare const toGeneratorOnlyKey: ({ generatorId }: ToGeneratorOnlyKeyArgs) => GeneratorOnlyKey;
+export {};
+//# sourceMappingURL=GeneratorKeys.d.ts.map

package/script/types/GeneratorKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratorKeys.d.ts","sourceRoot":"","sources":["../../src/types/GeneratorKeys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C,MAAM,MAAM,0BAA0B,GAAG,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAAA;AAExE,MAAM,MAAM,sBAAsB,GAAG,GAAG,MAAM,IAAI,MAAM,EAAE,CAAA;AAE1D,MAAM,MAAM,qBAAqB,GAAG,KAAK,CACvC,0BAA0B,EAC1B,uBAAuB,CACxB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,KAAK,CACnC,sBAAsB,EACtB,mBAAmB,CACpB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;AAEhE,MAAM,MAAM,YAAY,GACpB,qBAAqB,GACrB,iBAAiB,GACjB,gBAAgB,CAAA;AAEpB,KAAK,2BAA2B,GAC5B;IACE,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IACE,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,YAAY,CAAA;CACxB,CAAA;AAEL,eAAO,MAAM,uBAAuB,6BAGjC,2BAA2B,KAAG,qBAMhC,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,mBAAmB,6BAG7B,uBAAuB,KAAG,iBAI5B,CAAA;AAED,KAAK,sBAAsB,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,kBAAkB,oBAE5B,sBAAsB,KAAG,gBAI3B,CAAA"}

package/script/types/GeneratorKeys.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGeneratorOnlyKey = exports.toModelGeneratorKey = exports.toOperationGeneratorKey = void 0;
+const toOperationGeneratorKey = ({ generatorId, ...rest }) => {
+    const { path, method } = 'operation' in rest ? rest.operation : rest;
+    const nakedKey = `${generatorId}|${path}|${method}`;
+    return nakedKey;
+};
+exports.toOperationGeneratorKey = toOperationGeneratorKey;
+const toModelGeneratorKey = ({ generatorId, refName }) => {
+    const nakedKey = `${generatorId}|${refName}`;
+    return nakedKey;
+};
+exports.toModelGeneratorKey = toModelGeneratorKey;
+const toGeneratorOnlyKey = ({ generatorId }) => {
+    const nakedKey = `${generatorId}`;
+    return nakedKey;
+};
+exports.toGeneratorOnlyKey = toGeneratorOnlyKey;

package/script/types/RefName.d.ts

@@ -0,0 +1,3 @@
+import type { Brand } from './Brand.js';
+export type RefName = Brand<string, 'RefName'>;
+//# sourceMappingURL=RefName.d.ts.map

package/script/types/RefName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefName.d.ts","sourceRoot":"","sources":["../../src/types/RefName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC,MAAM,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA"}

package/script/types/RefName.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/types/Settings.d.ts

@@ -0,0 +1,184 @@
+import "../_dnt.polyfills.js";
+import { type Method } from './Method.js';
+import { z } from 'zod';
+export declare const baseSettings: z.ZodType<BaseSettings>;
+export type BaseSettings = {
+    exportPath?: string;
+    selected: boolean;
+    name?: string;
+    importFrom?: string;
+};
+export type BaseSettingsKeyType = 'selected' | 'name' | 'importFrom' | 'exportPath';
+export declare const operationsPluginSettings: z.ZodObject<{
+    id: z.ZodString;
+    exportPath: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    operations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodType<Method, z.ZodTypeDef, Method>, z.ZodType<BaseSettings, z.ZodTypeDef, BaseSettings>>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+}, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+}>;
+export type OperationsPluginSettings = {
+    id: string;
+    exportPath?: string;
+    description?: string;
+    operations?: Record<string, Partial<Record<Method, BaseSettings>>>;
+};
+export declare const modelsPluginSettings: z.ZodObject<{
+    id: z.ZodString;
+    exportPath: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<BaseSettings, z.ZodTypeDef, BaseSettings>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    models?: Record<string, BaseSettings> | undefined;
+}, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    models?: Record<string, BaseSettings> | undefined;
+}>;
+export type ModelsPluginSettings = {
+    id: string;
+    exportPath?: string;
+    description?: string;
+    models?: Record<string, BaseSettings>;
+};
+export declare const pluginSettings: z.ZodUnion<[z.ZodObject<{
+    id: z.ZodString;
+    exportPath: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    operations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodType<Method, z.ZodTypeDef, Method>, z.ZodType<BaseSettings, z.ZodTypeDef, BaseSettings>>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+}, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    exportPath: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<BaseSettings, z.ZodTypeDef, BaseSettings>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    models?: Record<string, BaseSettings> | undefined;
+}, {
+    id: string;
+    description?: string | undefined;
+    exportPath?: string | undefined;
+    models?: Record<string, BaseSettings> | undefined;
+}>]>;
+export type PluginSettings = OperationsPluginSettings | ModelsPluginSettings;
+export declare const clientSettings: z.ZodObject<{
+    basePath: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    generators: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        id: z.ZodString;
+        exportPath: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        operations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodType<Method, z.ZodTypeDef, Method>, z.ZodType<BaseSettings, z.ZodTypeDef, BaseSettings>>>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+    }, {
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        exportPath: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<BaseSettings, z.ZodTypeDef, BaseSettings>>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        models?: Record<string, BaseSettings> | undefined;
+    }, {
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        models?: Record<string, BaseSettings> | undefined;
+    }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    alias?: Record<string, string> | undefined;
+    basePath?: string | undefined;
+    generators?: ({
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+    } | {
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        models?: Record<string, BaseSettings> | undefined;
+    })[] | undefined;
+}, {
+    alias?: Record<string, string> | undefined;
+    basePath?: string | undefined;
+    generators?: ({
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        operations?: Record<string, Partial<Record<Method, BaseSettings>>> | undefined;
+    } | {
+        id: string;
+        description?: string | undefined;
+        exportPath?: string | undefined;
+        models?: Record<string, BaseSettings> | undefined;
+    })[] | undefined;
+}>;
+export type ClientSettings = {
+    basePath?: string;
+    alias?: Record<string, string>;
+    generators?: PluginSettings[];
+};
+export type SkmtcClientConfig = {
+    generatorUrl?: string;
+    serverName?: string;
+    stackName?: string;
+    deploymentId?: string;
+    settings: ClientSettings;
+};
+export declare const skmtcClientConfig: z.ZodType<SkmtcClientConfig>;
+export declare const pluginType: z.ZodEnum<["operation", "model"]>;
+export type PluginType = 'operation' | 'model';
+export declare const skmtcServerConfig: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    generators: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    generators: string[];
+    name?: string | undefined;
+    version?: string | undefined;
+}, {
+    generators: string[];
+    name?: string | undefined;
+    version?: string | undefined;
+}>;
+export type SkmtcServerConfig = {
+    name?: string;
+    version?: string;
+    generators: string[];
+};
+//# sourceMappingURL=Settings.d.ts.map

package/script/types/Settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Settings.d.ts","sourceRoot":"","sources":["../../src/types/Settings.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,MAAM,EAAU,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAK/C,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAC3B,UAAU,GACV,MAAM,GACN,YAAY,GACZ,YAAY,CAAA;AAEhB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;EAKnC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CAAA;CACnE,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACtC,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGzB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,wBAAwB,GAAG,oBAAoB,CAAA;AAE5E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIzB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,UAAU,CAAC,EAAE,cAAc,EAAE,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,cAAc,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAKzD,CAAA;AAEF,eAAO,MAAM,UAAU,mCAAiC,CAAA;AAExD,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,OAAO,CAAA;AAE9C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB,CAAA"}

package/script/types/Settings.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skmtcServerConfig = exports.pluginType = exports.skmtcClientConfig = exports.clientSettings = exports.pluginSettings = exports.modelsPluginSettings = exports.operationsPluginSettings = exports.baseSettings = void 0;
+require("../_dnt.polyfills.js");
+const Method_js_1 = require("./Method.js");
+const zod_1 = require("zod");
+exports.baseSettings = zod_1.z.object({
+    selected: zod_1.z.boolean(),
+    name: zod_1.z.string().optional(),
+    importFrom: zod_1.z.string().optional(),
+    exportPath: zod_1.z.string().optional()
+});
+exports.operationsPluginSettings = zod_1.z.object({
+    id: zod_1.z.string(),
+    exportPath: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    operations: zod_1.z.record(zod_1.z.record(Method_js_1.method, exports.baseSettings)).optional()
+});
+exports.modelsPluginSettings = zod_1.z.object({
+    id: zod_1.z.string(),
+    exportPath: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    models: zod_1.z.record(exports.baseSettings).optional()
+});
+exports.pluginSettings = zod_1.z.union([
+    exports.operationsPluginSettings,
+    exports.modelsPluginSettings
+]);
+exports.clientSettings = zod_1.z.object({
+    basePath: zod_1.z.string().optional(),
+    alias: zod_1.z.record(zod_1.z.string()).optional(),
+    generators: zod_1.z.array(exports.pluginSettings).optional()
+});
+exports.skmtcClientConfig = zod_1.z.object({
+    serverName: zod_1.z.string().optional(),
+    stackName: zod_1.z.string().optional(),
+    deploymentId: zod_1.z.string().optional(),
+    settings: exports.clientSettings
+});
+exports.pluginType = zod_1.z.enum(['operation', 'model']);
+exports.skmtcServerConfig = zod_1.z.object({
+    name: zod_1.z.string().optional(),
+    version: zod_1.z.string().optional(),
+    generators: zod_1.z.array(zod_1.z.string())
+});

package/script/types/TypeSystem.d.ts

@@ -1,73 +1,96 @@
-import type { Identifier } from '../dsl/Identifier.js';
 import type { OasRef } from '../oas/ref/Ref.js';
 import type { OasSchema } from '../oas/schema/Schema.js';
 import type { Modifiers } from './Modifiers.js';
 import type { Stringable } from '../dsl/Stringable.js';
+import type { CoreContext } from '../context/CoreContext.js';
+import type { CustomValue } from './CustomValue.js';
+import type { OasVoid } from '../oas/void/Void.js';
+import type { GeneratorKey } from './GeneratorKeys.js';
 export type TypeSystemValue = TypeSystemArray | TypeSystemIntersection | TypeSystemObject | TypeSystemUnion | TypeSystemString | TypeSystemNumber | TypeSystemInteger | TypeSystemBoolean | TypeSystemUnknown | TypeSystemVoid | TypeSystemRef | TypeSystemNull | TypeSystemCustom;
 export type TypeSystemRef = {
     type: 'ref';
-    destinationPath: string;
-    identifier: Identifier;
-    value: OasSchema | OasRef<'schema'>;
+    name: string;
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemCustom = {
     type: 'custom';
     value: Stringable;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemArray = {
     type: 'array';
     items: TypeSystemValue;
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemNumber = {
     type: 'number';
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemVoid = {
     type: 'void';
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemInteger = {
     type: 'integer';
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemBoolean = {
     type: 'boolean';
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemUnknown = {
     type: 'unknown';
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemNull = {
     type: 'null';
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemIntersection = {
     type: 'intersection';
     members: TypeSystemValue[];
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemRecord = {
     value: TypeSystemValue | 'true';
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemObjectProperties = {
     properties: Record<string, TypeSystemValue>;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemString = {
     type: 'string';
     format: string | undefined;
     enums: string[] | undefined;
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemUnion = {
     type: 'union';
     members: TypeSystemValue[];
     discriminator: string | undefined;
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
 };
 export type TypeSystemObject = {
     type: 'object';
     recordProperties: TypeSystemRecord | null;
     objectProperties: TypeSystemObjectProperties | null;
     modifiers: Modifiers;
+    generatorKey: GeneratorKey;
+};
+export type TypeSystemArgs = {
+    context: CoreContext;
+    destinationPath: string;
+    schema: OasSchema | OasRef<'schema'> | OasVoid | CustomValue;
+    required: boolean | undefined;
+    generatorKey: GeneratorKey;
 };
 //# sourceMappingURL=TypeSystem.d.ts.map