@skmtc/core 0.0.226 → 0.0.228

package/script/types/prettierConfig.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettierConfigType = void 0;
+const zod_1 = require("zod");
+exports.prettierConfigType = zod_1.z.object({
+    printWidth: zod_1.z.number().optional(),
+    tabWidth: zod_1.z.number().optional(),
+    useTabs: zod_1.z.boolean().optional(),
+    semi: zod_1.z.boolean().optional(),
+    singleQuote: zod_1.z.boolean().optional(),
+    quoteProps: zod_1.z
+        .union([
+        zod_1.z.literal('as-needed'),
+        zod_1.z.literal('consistent'),
+        zod_1.z.literal('preserve')
+    ])
+        .optional(),
+    jsxSingleQuote: zod_1.z.boolean().optional(),
+    trailingComma: zod_1.z
+        .union([zod_1.z.literal('none'), zod_1.z.literal('es5'), zod_1.z.literal('all')])
+        .optional(),
+    bracketSameLine: zod_1.z.boolean().optional(),
+    bracketSpacing: zod_1.z.boolean().optional(),
+    jsxBracketSameLine: zod_1.z.boolean().optional(),
+    arrowParens: zod_1.z.union([zod_1.z.literal('avoid'), zod_1.z.literal('always')]).optional(),
+    rangeStart: zod_1.z.number().optional(),
+    rangeEnd: zod_1.z.number().optional(),
+    requirePragma: zod_1.z.boolean().optional(),
+    insertPragma: zod_1.z.boolean().optional(),
+    proseWrap: zod_1.z
+        .union([zod_1.z.literal('always'), zod_1.z.literal('never'), zod_1.z.literal('preserve')])
+        .optional(),
+    htmlWhitespaceSensitivity: zod_1.z
+        .union([zod_1.z.literal('css'), zod_1.z.literal('strict'), zod_1.z.literal('ignore')])
+        .optional(),
+    vueIndentScriptAndStyle: zod_1.z.boolean().optional(),
+    endOfLine: zod_1.z
+        .union([
+        zod_1.z.literal('auto'),
+        zod_1.z.literal('lf'),
+        zod_1.z.literal('crlf'),
+        zod_1.z.literal('cr')
+    ])
+        .optional(),
+    embeddedLanguageFormatting: zod_1.z
+        .union([zod_1.z.literal('auto'), zod_1.z.literal('off')])
+        .optional(),
+    singleAttributePerLine: zod_1.z.boolean().optional()
+});

package/script/typescript/EntityType.d.ts

@@ -0,0 +1,6 @@
+export declare class EntityType {
+    type: 'value' | 'type';
+    constructor(type: 'value' | 'type');
+    toString(): string;
+}
+//# sourceMappingURL=EntityType.d.ts.map

package/script/typescript/EntityType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityType.d.ts","sourceRoot":"","sources":["../../src/typescript/EntityType.ts"],"names":[],"mappings":"AAEA,qBAAa,UAAU;IACrB,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;gBACV,IAAI,EAAE,OAAO,GAAG,MAAM;IAIlC,QAAQ,IAAI,MAAM;CAMnB"}

package/script/typescript/EntityType.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityType = void 0;
+const ts_pattern_1 = require("ts-pattern");
+class EntityType {
+    constructor(type) {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.type = type;
+    }
+    toString() {
+        return (0, ts_pattern_1.match)(this.type)
+            .with('value', () => 'const')
+            .with('type', () => 'type')
+            .exhaustive();
+    }
+}
+exports.EntityType = EntityType;

package/script/typescript/FunctionParameter.d.ts

@@ -0,0 +1,36 @@
+import type { Identifier } from '../dsl/Identifier.js';
+import type { TypeSystemObject, TypeSystemValue, TypeSystemVoid } from '../types/TypeSystem.js';
+type CreateArgs = {
+    name?: string;
+    identifier: Identifier;
+    value: TypeSystemValue;
+    destructure: boolean;
+    required?: boolean;
+};
+type ParameterProperties = VoidParameter | DestructuredParameter | RegularParameter;
+type VoidParameter = {
+    type: 'void';
+    value: TypeSystemVoid;
+};
+type DestructuredParameter = {
+    type: 'destructured';
+    identifier: Identifier;
+    value: TypeSystemObject;
+};
+type RegularParameter = {
+    type: 'regular';
+    name: string;
+    identifier: Identifier;
+    value: TypeSystemValue;
+    required: boolean;
+};
+export declare class FunctionParameter {
+    properties: ParameterProperties;
+    constructor(args: CreateArgs);
+    toDestructured(): FunctionParameter;
+    toPropertyList(): string[];
+    toInbound(): string;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=FunctionParameter.d.ts.map

package/script/typescript/FunctionParameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionParameter.d.ts","sourceRoot":"","sources":["../../src/typescript/FunctionParameter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,cAAc,EACf,MAAM,wBAAwB,CAAA;AAG/B,KAAK,UAAU,GAAG;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,eAAe,CAAA;IACtB,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,mBAAmB,GACpB,aAAa,GACb,qBAAqB,GACrB,gBAAgB,CAAA;AAEpB,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,cAAc,CAAA;CACtB,CAAA;AACD,KAAK,qBAAqB,GAAG;IAC3B,IAAI,EAAE,cAAc,CAAA;IACpB,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,gBAAgB,CAAA;CACxB,CAAA;AACD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,eAAe,CAAA;IACtB,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,qBAAa,iBAAiB;IAC5B,UAAU,EAAE,mBAAmB,CAAA;gBAEnB,IAAI,EAAE,UAAU;IA0B5B,cAAc,IAAI,iBAAiB;IAiBnC,cAAc,IAAI,MAAM,EAAE;IAc1B,SAAS,IAAI,MAAM;IAkBnB,QAAQ,IAAI,MAAM;CAiBnB"}

package/script/typescript/FunctionParameter.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionParameter = void 0;
+const ts_pattern_1 = require("ts-pattern");
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+class FunctionParameter {
+    constructor(args) {
+        Object.defineProperty(this, "properties", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.properties = (0, ts_pattern_1.match)(args)
+            .with({ value: { type: 'void' } }, ({ value }) => ({
+            type: 'void',
+            value
+        }))
+            .with({ value: { type: 'object' }, destructure: true }, ({ value, identifier }) => ({
+            type: 'destructured',
+            identifier,
+            value
+        }))
+            .with({ name: ts_pattern_1.P.string }, ({ identifier, value, name, required }) => ({
+            type: 'regular',
+            identifier,
+            name,
+            value,
+            required: required ?? false
+        }))
+            .otherwise(() => {
+            throw new Error('Invalid parameter');
+        });
+    }
+    toDestructured() {
+        if (this.properties.type === 'void') {
+            return this;
+        }
+        (0, tiny_invariant_1.default)(this.properties.value.type === 'object', 'Only object types can be destructured');
+        return new FunctionParameter({
+            identifier: this.properties.identifier,
+            value: this.properties.value,
+            destructure: true
+        });
+    }
+    toPropertyList() {
+        return (0, ts_pattern_1.match)(this.properties)
+            .with({ type: 'void' }, () => [])
+            .with({ type: 'regular' }, ({ name }) => [`${name}`])
+            .with({ type: 'destructured' }, ({ value }) => {
+            return toPropertyNames(value).map(name => name === `'If-Match'` ? `'If-Match': IfMatch` : name);
+        })
+            .otherwise(() => {
+            throw new Error('Invalid parameter');
+        });
+    }
+    toInbound() {
+        return (0, ts_pattern_1.match)(this.properties)
+            .with({ type: 'void' }, () => '')
+            .with({ type: 'regular' }, ({ name }) => {
+            return `${name}`;
+        })
+            .with({ type: 'destructured' }, ({ value }) => {
+            const propertyNames = toPropertyNames(value).map(name => name === `'If-Match'` ? `'If-Match': IfMatch` : name);
+            return `{${propertyNames.join(', ')}}`;
+        })
+            .otherwise(() => {
+            throw new Error('Invalid parameter');
+        });
+    }
+    toString() {
+        return (0, ts_pattern_1.match)(this.properties)
+            .with({ type: 'void' }, () => '')
+            .with({ type: 'regular' }, ({ name, identifier, required }) => {
+            return `${name}${required ? '' : '?'}: ${identifier}`;
+        })
+            .with({ type: 'destructured' }, ({ identifier, value }) => {
+            const propertyNames = toPropertyNames(value).map(name => name === `'If-Match'` ? `'If-Match': IfMatch` : name);
+            return `{${propertyNames.join(', ')}}: ${identifier}`;
+        })
+            .otherwise(() => {
+            throw new Error('Invalid parameter');
+        });
+    }
+}
+exports.FunctionParameter = FunctionParameter;
+const toPropertyNames = (value) => {
+    (0, tiny_invariant_1.default)(value.objectProperties, 'Only object types can be destructured');
+    return Object.keys(value.objectProperties.properties);
+};

package/script/typescript/ReactRouterPathParams.d.ts

@@ -0,0 +1,20 @@
+import { ValueBase } from '../dsl/ValueBase.js';
+import type { CoreContext } from '../context/CoreContext.js';
+import type { OasOperation } from '../oas/operation/Operation.js';
+import type { GeneratorKey } from '../types/GeneratorKeys.js';
+type CreateArgs = {
+    context: CoreContext;
+    generatorKey: GeneratorKey;
+    operation: OasOperation;
+    destinationPath: string;
+};
+export declare class ReactRouterPathParams extends ValueBase {
+    getParams: string;
+    assertParams: string;
+    passProps: string;
+    names: string[];
+    constructor({ context, operation, generatorKey, destinationPath }: CreateArgs);
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=ReactRouterPathParams.d.ts.map

package/script/typescript/ReactRouterPathParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactRouterPathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/ReactRouterPathParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,WAAW,CAAA;IACpB,YAAY,EAAE,YAAY,CAAA;IAC1B,SAAS,EAAE,YAAY,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,SAAS,EAAE,MAAM,CAAK;IAEtB,YAAY,EAAE,MAAM,CAAK;IAEzB,SAAS,EAAE,MAAM,CAAK;IAEtB,KAAK,EAAE,MAAM,EAAE,CAAA;gBAEH,EACV,OAAO,EACP,SAAS,EACT,YAAY,EACZ,eAAe,EAChB,EAAE,UAAU;IAwBb,QAAQ,IAAI,MAAM;CAGnB"}

package/script/typescript/ReactRouterPathParams.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactRouterPathParams = void 0;
+const ValueBase_js_1 = require("../dsl/ValueBase.js");
+class ReactRouterPathParams extends ValueBase_js_1.ValueBase {
+    constructor({ context, operation, generatorKey, destinationPath }) {
+        super({ context, generatorKey });
+        Object.defineProperty(this, "getParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "assertParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "passProps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "names", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const names = operation.toParams(['path']).map(param => param.name);
+        this.names = names;
+        if (names.length > 0) {
+            this.getParams = `const { ${names.join(', ')} } = useParams()`;
+            this.assertParams = names
+                .map(param => `invariant(${param}, 'Expected ${param} to be defined')`)
+                .join('\n');
+            this.passProps = names.map(param => `${param}={${param}}`).join(' ');
+            this.register({
+                imports: {
+                    'react-router-dom': ['useParams'],
+                    'npm:tiny-invariant@1.3.3': [{ default: 'invariant' }]
+                },
+                destinationPath
+            });
+        }
+    }
+    toString() {
+        return ``;
+    }
+}
+exports.ReactRouterPathParams = ReactRouterPathParams;

package/script/typescript/identifiers.d.ts

@@ -0,0 +1,3 @@
+export declare const handleKey: (key: string) => string;
+export declare const handlePropertyName: (name: string, parent: string) => string;
+//# sourceMappingURL=identifiers.d.ts.map

package/script/typescript/identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../../src/typescript/identifiers.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS,QAAS,MAAM,KAAG,MAEvC,CAAA;AAED,eAAO,MAAM,kBAAkB,SAAU,MAAM,UAAU,MAAM,KAAG,MAEjE,CAAA"}

package/script/typescript/identifiers.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePropertyName = exports.handleKey = void 0;
+const helper_validator_identifier_1 = require("@babel/helper-validator-identifier");
+const handleKey = (key) => {
+    return (0, helper_validator_identifier_1.isIdentifierName)(key) ? key : `'${key}'`;
+};
+exports.handleKey = handleKey;
+const handlePropertyName = (name, parent) => {
+    return (0, helper_validator_identifier_1.isIdentifierName)(name) ? `${parent}.${name}` : `${parent}['${name}']`;
+};
+exports.handlePropertyName = handlePropertyName;

package/script/typescript/keyValues.d.ts

@@ -0,0 +1,3 @@
+import type { Stringable } from '../dsl/Stringable.js';
+export declare const keyValues: (properties: Record<string, Stringable>) => string;
+//# sourceMappingURL=keyValues.d.ts.map

package/script/typescript/keyValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyValues.d.ts","sourceRoot":"","sources":["../../src/typescript/keyValues.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGtD,eAAO,MAAM,SAAS,eAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,KAAG,MAUlE,CAAA"}

package/script/typescript/keyValues.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyValues = void 0;
+const constants_js_1 = require("../dsl/constants.js");
+// Filter out properties with falsy or EMPTY values and return as joined string
+const keyValues = (properties) => {
+    const filteredEntries = Object.entries(properties)
+        .map(([key, value]) => {
+        const renderedValue = value?.toString() || constants_js_1.EMPTY;
+        return renderedValue === constants_js_1.EMPTY ? constants_js_1.EMPTY : `${key}: ${renderedValue}`;
+    })
+        .filter(row => row !== constants_js_1.EMPTY);
+    return filteredEntries.length ? `{${filteredEntries.join(',\n')}}` : constants_js_1.EMPTY;
+};
+exports.keyValues = keyValues;

package/script/typescript/toDestructuredObject.d.ts

@@ -0,0 +1,3 @@
+import type { TypeSystemValue } from '../types/TypeSystem.js';
+export declare const toDestructuredObject: (value: TypeSystemValue) => string;
+//# sourceMappingURL=toDestructuredObject.d.ts.map

package/script/typescript/toDestructuredObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toDestructuredObject.d.ts","sourceRoot":"","sources":["../../src/typescript/toDestructuredObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D,eAAO,MAAM,oBAAoB,UAAW,eAAe,KAAG,MAsB7D,CAAA"}

package/script/typescript/toDestructuredObject.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDestructuredObject = void 0;
+const toDestructuredObject = (value) => {
+    if (value.type === 'void') {
+        return '';
+    }
+    if (value.type !== 'object' || !value.objectProperties) {
+        throw new Error('Only object types can be destructured');
+    }
+    if (value.recordProperties) {
+        throw new Error('Objects with record properties cannot be destructured, yet');
+    }
+    if (!value.objectProperties.properties) {
+        throw new Error('Cannot destructure an object without properties');
+    }
+    const propertyNames = Object.keys(value.objectProperties.properties);
+    return `{${propertyNames.join(', ')}}`;
+};
+exports.toDestructuredObject = toDestructuredObject;

package/script/typescript/toOperationArg.d.ts

@@ -0,0 +1,21 @@
+import type { CoreContext } from '../context/CoreContext.js';
+import type { OasOperation } from '../oas/operation/Operation.js';
+import { OasObject } from '../oas/object/Object.js';
+import { OasVoid } from '../oas/void/Void.js';
+import type { OasSchema } from '../oas/schema/Schema.js';
+import type { OasRef } from '../oas/ref/Ref.js';
+import type { CustomValue } from '../types/CustomValue.js';
+type InsertProperty = {
+    name: string;
+    schema: OasSchema | OasRef<'schema'> | CustomValue;
+    required?: boolean;
+};
+type ToOperationArgArgs = {
+    context: CoreContext;
+    operation: OasOperation;
+    insertProperties?: InsertProperty[];
+    removeProperties?: string[];
+};
+export declare const toOperationArg: ({ context, operation, insertProperties, removeProperties }: ToOperationArgArgs) => OasObject | OasVoid;
+export {};
+//# sourceMappingURL=toOperationArg.d.ts.map

package/script/typescript/toOperationArg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toOperationArg.d.ts","sourceRoot":"","sources":["../../src/typescript/toOperationArg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAE7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAE1D,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAA;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,kBAAkB,GAAG;IACxB,OAAO,EAAE,WAAW,CAAA;IACpB,SAAS,EAAE,YAAY,CAAA;IACvB,gBAAgB,CAAC,EAAE,cAAc,EAAE,CAAA;IACnC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,eAAO,MAAM,cAAc,+DAKxB,kBAAkB,KAAG,SAAS,GAAG,OAenC,CAAA"}

package/script/typescript/toOperationArg.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOperationArg = void 0;
+const Object_js_1 = require("../oas/object/Object.js");
+const Void_js_1 = require("../oas/void/Void.js");
+const isEmpty_js_1 = __importDefault(require("lodash-es/isEmpty.js"));
+const toOperationArg = ({ context, operation, insertProperties = [], removeProperties = [] }) => {
+    const { properties, required } = toOperationArgProperties({
+        operation,
+        insertProperties,
+        removeProperties
+    });
+    const schema = (0, isEmpty_js_1.default)(properties)
+        ? Void_js_1.OasVoid.empty(context)
+        : Object_js_1.OasObject.fromFields({
+            fields: { required, properties },
+            context
+        });
+    return schema;
+};
+exports.toOperationArg = toOperationArg;
+const toOperationArgProperties = ({ operation, insertProperties: ip = [], removeProperties = [] }) => {
+    const body = operation.requestBody?.resolve().toSchema('application/json');
+    const insertProperties = body
+        ? ip.concat({
+            name: 'body',
+            schema: body,
+            required: true
+        })
+        : ip;
+    const parameters = operation.parameters ?? [];
+    const resolved = parameters.map(parameter => parameter.resolve());
+    // map property schemas by name
+    const properties = resolved
+        .map((parameter) => [
+        parameter.name,
+        parameter.toSchema()
+    ])
+        .filter((property) => {
+        if (!property[1]) {
+            throw new Error('Property is undefined');
+        }
+        return Boolean(property[1]);
+    })
+        .concat(insertProperties.map(({ name, schema }) => [name, schema]))
+        .filter(([name]) => !removeProperties.includes(name));
+    const insertRequired = insertProperties
+        .filter(({ required }) => required)
+        .map(({ name }) => name);
+    // create list of required properties
+    const required = resolved
+        .filter(({ required }) => required)
+        .map(({ name }) => name)
+        .concat(insertRequired)
+        .filter(([name]) => !removeProperties.includes(name));
+    return {
+        properties: Object.fromEntries(properties),
+        required
+    };
+};

package/script/typescript/toOperationResponse.d.ts

@@ -0,0 +1,16 @@
+import type { CoreContext } from '../context/CoreContext.js';
+import { Definition } from '../dsl/Definition.js';
+import type { OasOperation } from '../oas/operation/Operation.js';
+import type { TypeSystemCreator } from '../dsl/ModelCreator.js';
+import type { Identifier } from '../dsl/Identifier.js';
+import type { GeneratedValue } from '../types/GeneratedValue.js';
+type ToOperationResponseArgs<V extends GeneratedValue> = {
+    context: CoreContext;
+    operation: OasOperation;
+    destinationPath: string;
+    typeSystemCreator: TypeSystemCreator<V>;
+    toIdentifier: (name: string) => Identifier;
+};
+export declare const toOperationResponse: <V extends GeneratedValue>({ context, operation, destinationPath, typeSystemCreator, toIdentifier }: ToOperationResponseArgs<V>) => Definition;
+export {};
+//# sourceMappingURL=toOperationResponse.d.ts.map

package/script/typescript/toOperationResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toOperationResponse.d.ts","sourceRoot":"","sources":["../../src/typescript/toOperationResponse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAGjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAEhE,KAAK,uBAAuB,CAAC,CAAC,SAAS,cAAc,IAAI;IACvD,OAAO,EAAE,WAAW,CAAA;IACpB,SAAS,EAAE,YAAY,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAA;IACvC,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAA;CAC3C,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,cAAc,4EAMzD,uBAAuB,CAAC,CAAC,CAAC,KAAG,UAe/B,CAAA"}

package/script/typescript/toOperationResponse.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOperationResponse = void 0;
+const Definition_js_1 = require("../dsl/Definition.js");
+const Void_js_1 = require("../oas/void/Void.js");
+const naming_js_1 = require("../helpers/naming.js");
+const toOperationResponse = ({ context, operation, destinationPath, typeSystemCreator, toIdentifier }) => {
+    const successResponse = operation.toSuccessResponse()?.resolve();
+    const value = typeSystemCreator.create({
+        context,
+        schema: successResponse?.toSchema() ?? Void_js_1.OasVoid.empty(context),
+        destinationPath
+    });
+    return new Definition_js_1.Definition({
+        context,
+        identifier: toIdentifier((0, naming_js_1.toResponseName)(operation)),
+        value,
+        description: successResponse?.description
+    });
+};
+exports.toOperationResponse = toOperationResponse;

package/script/typescript/toPathTemplate.d.ts

@@ -0,0 +1,2 @@
+export declare const toPathTemplate: (path: string, queryArg?: string) => string;
+//# sourceMappingURL=toPathTemplate.d.ts.map

package/script/typescript/toPathTemplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPathTemplate.d.ts","sourceRoot":"","sources":["../../src/typescript/toPathTemplate.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,SAAU,MAAM,aAAa,MAAM,KAAG,MAKhE,CAAA"}

package/script/typescript/toPathTemplate.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPathTemplate = void 0;
+const toPathTemplate = (path, queryArg) => {
+    return `${path.replaceAll(/{([^}]*)}/g, queryArg ? '${' + queryArg + '.$1}' : '${$1}')}`;
+};
+exports.toPathTemplate = toPathTemplate;

package/script/typescript/withDescription.d.ts

@@ -0,0 +1,4 @@
+import type { Stringable } from '../dsl/Stringable.js';
+import type { Modifiers } from '../types/Modifiers.js';
+export declare const withDescription: (value: Stringable, { description }: Modifiers) => string;
+//# sourceMappingURL=withDescription.d.ts.map

package/script/typescript/withDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDescription.d.ts","sourceRoot":"","sources":["../../src/typescript/withDescription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEtD,eAAO,MAAM,eAAe,UACnB,UAAU,mBACA,SAAS,KACzB,MAEF,CAAA"}

package/script/typescript/withDescription.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withDescription = void 0;
+const withDescription = (value, { description }) => {
+    return description ? `/** ${description} */\n${value}` : `${value}`;
+};
+exports.withDescription = withDescription;