@bluefly/openstandardagents 0.5.1 → 0.5.4

package/dist/services/codegen/generators/openapi-zod.generator.js

@@ -1,482 +0,0 @@
-/**
- * OpenAPI → Zod Generator
- *
- * DRY, SOLID, ZOD, OPENAPI-FIRST
- *
- * Generates Zod schemas from OpenAPI 3.1 specs in openapi/ directory.
- * This is the SINGLE SOURCE OF TRUTH - OpenAPI specs drive everything.
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { injectable } from 'inversify';
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import { getVersion, getApiVersion } from '../../../utils/version.js';
-import { safeParseYAML } from '../../../utils/yaml-parser.js';
-let OpenAPIZodGenerator = class OpenAPIZodGenerator {
-    name = 'openapi-zod';
-    openapiDir = path.join(process.cwd(), 'openapi');
-    outputDir = path.join(process.cwd(), 'src/types/generated/openapi');
-    /**
-     * Generate Zod schemas from all OpenAPI specs
-     */
-    async generate(dryRun) {
-        const result = {
-            generator: this.name,
-            filesUpdated: 0,
-            filesCreated: 0,
-            errors: [],
-        };
-        const version = getVersion();
-        const apiVersion = getApiVersion();
-        // Find all OpenAPI YAML files
-        const openapiFiles = await this.findOpenAPIFiles();
-        if (openapiFiles.length === 0) {
-            result.errors.push('No OpenAPI files found in openapi/ directory');
-            return result;
-        }
-        // Ensure output directory exists
-        if (!dryRun && !fs.existsSync(this.outputDir)) {
-            fs.mkdirSync(this.outputDir, { recursive: true });
-        }
-        // Generate Zod from shared schemas first (must be done before individual files)
-        const sharedSchemasPath = path.join(this.openapiDir, 'schemas/common');
-        if (fs.existsSync(sharedSchemasPath)) {
-            const sharedResult = await this.generateFromSharedSchemas(sharedSchemasPath, version, apiVersion, dryRun);
-            result.filesCreated += sharedResult.filesCreated;
-            result.filesUpdated += sharedResult.filesUpdated;
-            result.errors.push(...sharedResult.errors);
-        }
-        // Generate Zod from each OpenAPI spec
-        for (const file of openapiFiles) {
-            try {
-                const fileResult = await this.generateFromFile(file, version, apiVersion, dryRun);
-                result.filesCreated += fileResult.filesCreated;
-                result.filesUpdated += fileResult.filesUpdated;
-                if (fileResult.errors.length > 0) {
-                    result.errors.push(`${file}: ${fileResult.errors.join(', ')}`);
-                }
-            }
-            catch (error) {
-                result.errors.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        return result;
-    }
-    /**
-     * Find all OpenAPI YAML files
-     */
-    async findOpenAPIFiles() {
-        const patterns = [
-            'openapi/**/*.openapi.yaml',
-            'openapi/**/*.openapi.yml',
-            'openapi/**/*.yaml',
-            'openapi/**/*.yml',
-        ];
-        const excludePatterns = [
-            '**/schemas/**',
-            '**/node_modules/**',
-            '**/dist/**',
-        ];
-        const allFiles = [];
-        for (const pattern of patterns) {
-            const files = await glob(pattern, {
-                ignore: excludePatterns,
-                cwd: process.cwd(),
-                absolute: true,
-            });
-            allFiles.push(...files);
-        }
-        return [...new Set(allFiles)].sort();
-    }
-    /**
-     * Generate Zod from shared schema files
-     */
-    async generateFromSharedSchemas(schemasDir, version, apiVersion, dryRun) {
-        const result = {
-            generator: this.name,
-            filesUpdated: 0,
-            filesCreated: 0,
-            errors: [],
-        };
-        const schemaFiles = await glob('*.yaml', {
-            cwd: schemasDir,
-            absolute: true,
-        });
-        const allSchemas = {};
-        for (const file of schemaFiles) {
-            try {
-                const content = fs.readFileSync(file, 'utf8');
-                const spec = safeParseYAML(content);
-                if (spec.components?.schemas) {
-                    Object.assign(allSchemas, spec.components.schemas);
-                }
-            }
-            catch (error) {
-                result.errors.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        if (Object.keys(allSchemas).length > 0) {
-            const outputPath = path.join(this.outputDir, 'common-schemas.zod.ts');
-            const content = this.generateZodFile(allSchemas, 'Common Shared Schemas', version, apiVersion, undefined, dryRun);
-            if (!dryRun) {
-                fs.writeFileSync(outputPath, content, 'utf8');
-                result.filesCreated = 1;
-            }
-            else {
-                result.filesCreated = 1;
-            }
-        }
-        return result;
-    }
-    /**
-     * Generate Zod from a single OpenAPI file
-     */
-    async generateFromFile(filePath, version, apiVersion, dryRun) {
-        const result = {
-            generator: this.name,
-            filesUpdated: 0,
-            filesCreated: 0,
-            errors: [],
-        };
-        try {
-            const content = fs.readFileSync(filePath, 'utf8');
-            const spec = safeParseYAML(content);
-            if (!spec.components?.schemas ||
-                Object.keys(spec.components.schemas).length === 0) {
-                return result;
-            }
-            const fileName = path.basename(filePath, path.extname(filePath));
-            const outputPath = path.join(this.outputDir, `${fileName}.zod.ts`);
-            const zodContent = this.generateZodFile(spec.components.schemas, spec.info?.title || fileName, version, apiVersion, filePath, dryRun);
-            if (!dryRun) {
-                const exists = fs.existsSync(outputPath);
-                fs.writeFileSync(outputPath, zodContent, 'utf8');
-                if (exists) {
-                    result.filesUpdated = 1;
-                }
-                else {
-                    result.filesCreated = 1;
-                }
-            }
-            else {
-                result.filesCreated = 1;
-            }
-        }
-        catch (error) {
-            result.errors.push(error instanceof Error ? error.message : String(error));
-        }
-        return result;
-    }
-    /**
-     * Generate Zod file content from schemas
-     */
-    generateZodFile(schemas, title, version, apiVersion, sourceFile, dryRun = false) {
-        const lines = [];
-        const refs = new Map();
-        // Convert absolute path to relative path from project root
-        const relativeSourceFile = sourceFile
-            ? path.relative(process.cwd(), sourceFile)
-            : 'shared schemas';
-        // Header
-        lines.push('/**');
-        lines.push(` * ${title} - Zod Schemas`);
-        lines.push(' *');
-        lines.push(' * AUTO-GENERATED - DO NOT EDIT');
-        lines.push(` * Generated from: ${relativeSourceFile}`);
-        lines.push(` * OSSA Version: ${version}`);
-        lines.push(` * API Version: ${apiVersion}`);
-        lines.push(` * Generated on: ${new Date().toISOString()}`);
-        lines.push(' *');
-        lines.push(' * Regenerate with: ossa generate zod');
-        lines.push(' */');
-        lines.push('');
-        lines.push("import { z } from 'zod';");
-        // Import common schemas if this is not the common schemas file itself
-        if (sourceFile && !sourceFile.includes('schemas/common')) {
-            const commonSchemasPath = path.join(this.outputDir, 'common-schemas.zod.ts');
-            // Always import in generated files (common schemas generated first)
-            lines.push("import * as CommonSchemas from './common-schemas.zod';");
-        }
-        lines.push('');
-        // First pass: collect schema names
-        for (const name of Object.keys(schemas)) {
-            refs.set(name, this.toSchemaName(name));
-        }
-        // Second pass: generate schemas
-        lines.push('// ============================================================================');
-        lines.push('// Component Schemas');
-        lines.push('// ============================================================================');
-        lines.push('');
-        for (const [name, schema] of Object.entries(schemas)) {
-            const schemaName = this.toSchemaName(name);
-            const typeName = this.toTypeName(name);
-            if (schema.description) {
-                lines.push('/**');
-                lines.push(` * ${schema.description.split('\n').join('\n * ')}`);
-                lines.push(' */');
-            }
-            const zodSchema = this.toZodSchema(schema, name, refs, new Set());
-            lines.push(`export const ${schemaName} = ${zodSchema};`);
-            lines.push('');
-            lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Convert OpenAPI schema to Zod schema
-     */
-    toZodSchema(schema, schemaName, refs, visited) {
-        // Handle $ref
-        if (schema.$ref) {
-            const refName = this.resolveRef(schema.$ref);
-            if (refs.has(refName)) {
-                return refs.get(refName);
-            }
-            // External ref to shared schemas
-            if (schema.$ref.includes('../schemas/common/') ||
-                schema.$ref.includes('schemas/common/')) {
-                const parts = schema.$ref.split('#/components/schemas/');
-                if (parts.length > 1) {
-                    const refSchema = parts[1];
-                    return `CommonSchemas.${this.toSchemaName(refSchema)}`;
-                }
-            }
-            // Local ref within same file
-            if (schema.$ref.startsWith('#/components/schemas/')) {
-                const localRef = schema.$ref.replace('#/components/schemas/', '');
-                if (refs.has(localRef)) {
-                    return refs.get(localRef);
-                }
-            }
-            return 'z.unknown()';
-        }
-        // Prevent circular references
-        if (visited.has(schemaName)) {
-            return 'z.unknown()';
-        }
-        visited.add(schemaName);
-        // Handle allOf
-        if (schema.allOf && schema.allOf.length > 0) {
-            const schemas = schema.allOf.map((s, i) => this.toZodSchema(s, `${schemaName}AllOf${i}`, refs, new Set(visited)));
-            if (schemas.length === 2) {
-                return `z.intersection(${schemas[0]}, ${schemas[1]})`;
-            }
-            return schemas.reduce((acc, s) => `z.intersection(${acc}, ${s})`);
-        }
-        // Handle oneOf/anyOf
-        if (schema.oneOf || schema.anyOf) {
-            const unionSchemas = (schema.oneOf || schema.anyOf || []).map((s, i) => this.toZodSchema(s, `${schemaName}Union${i}`, refs, new Set(visited)));
-            return `z.union([${unionSchemas.join(', ')}])`;
-        }
-        let zodSchema = '';
-        // Handle const
-        if (schema.const !== undefined) {
-            return `z.literal(${JSON.stringify(schema.const)})`;
-        }
-        // Handle enum
-        if (schema.enum && schema.enum.length > 0) {
-            const enumValues = schema.enum.map((v) => JSON.stringify(v)).join(', ');
-            zodSchema = `z.enum([${enumValues}])`;
-        }
-        else {
-            // Map OpenAPI types to Zod
-            switch (schema.type) {
-                case 'string':
-                    zodSchema = this.generateStringSchema(schema);
-                    break;
-                case 'number':
-                case 'integer':
-                    zodSchema = this.generateNumberSchema(schema);
-                    break;
-                case 'boolean':
-                    zodSchema = 'z.boolean()';
-                    break;
-                case 'array':
-                    zodSchema = this.generateArraySchema(schema, schemaName, refs, visited);
-                    break;
-                case 'object':
-                    zodSchema = this.generateObjectSchema(schema, schemaName, refs, visited);
-                    break;
-                default:
-                    // Implicit object from properties
-                    if (schema.properties) {
-                        zodSchema = this.generateObjectSchema(schema, schemaName, refs, visited);
-                    }
-                    else {
-                        zodSchema = 'z.unknown()';
-                    }
-            }
-        }
-        // Apply nullable
-        if (schema.nullable) {
-            zodSchema = `${zodSchema}.nullable()`;
-        }
-        visited.delete(schemaName);
-        return zodSchema;
-    }
-    /**
-     * Generate string schema
-     */
-    generateStringSchema(schema) {
-        let zodSchema = 'z.string()';
-        // Format validators
-        switch (schema.format) {
-            case 'uuid':
-                zodSchema = 'z.string().uuid()';
-                break;
-            case 'email':
-                zodSchema = 'z.string().email()';
-                break;
-            case 'date-time':
-                zodSchema = 'z.string().datetime()';
-                break;
-            case 'date':
-                zodSchema = 'z.string().date()';
-                break;
-            case 'uri':
-                zodSchema = 'z.string().url()';
-                break;
-            case 'ipv4':
-            case 'ipv6':
-                zodSchema = 'z.string().ip()';
-                break;
-        }
-        // Constraints
-        if (schema.minLength !== undefined) {
-            zodSchema += `.min(${schema.minLength})`;
-        }
-        if (schema.maxLength !== undefined) {
-            zodSchema += `.max(${schema.maxLength})`;
-        }
-        if (schema.pattern) {
-            const escapedPattern = schema.pattern.replace(/\//g, '\\/');
-            zodSchema += `.regex(/${escapedPattern}/)`;
-        }
-        return zodSchema;
-    }
-    /**
-     * Generate number schema
-     */
-    generateNumberSchema(schema) {
-        const isInt = schema.type === 'integer';
-        let zodSchema = isInt ? 'z.number().int()' : 'z.number()';
-        if (schema.minimum !== undefined) {
-            zodSchema += `.min(${schema.minimum})`;
-        }
-        if (schema.maximum !== undefined) {
-            zodSchema += `.max(${schema.maximum})`;
-        }
-        return zodSchema;
-    }
-    /**
-     * Generate array schema
-     */
-    generateArraySchema(schema, schemaName, refs, visited) {
-        if (schema.items) {
-            const itemSchema = this.toZodSchema(schema.items, `${schemaName}Item`, refs, new Set(visited));
-            return `z.array(${itemSchema})`;
-        }
-        return 'z.array(z.unknown())';
-    }
-    /**
-     * Generate object schema
-     */
-    generateObjectSchema(schema, schemaName, refs, visited) {
-        if (!schema.properties) {
-            if (schema.additionalProperties === false) {
-                return 'z.object({}).strict()';
-            }
-            if (schema.additionalProperties === true) {
-                return 'z.record(z.string(), z.unknown())';
-            }
-            if (typeof schema.additionalProperties === 'object') {
-                const valueSchema = this.toZodSchema(schema.additionalProperties, `${schemaName}Value`, refs, new Set(visited));
-                return `z.record(z.string(), ${valueSchema})`;
-            }
-            return 'z.record(z.string(), z.unknown())';
-        }
-        const props = [];
-        for (const [key, propSchema] of Object.entries(schema.properties)) {
-            const isRequired = schema.required?.includes(key) ?? false;
-            const propZod = this.toZodSchema(propSchema, `${schemaName}${this.capitalize(key)}`, refs, new Set(visited));
-            if (isRequired) {
-                props.push(`  ${key}: ${propZod}`);
-            }
-            else {
-                props.push(`  ${key}: ${propZod}.optional()`);
-            }
-        }
-        let objectSchema = `z.object({\n${props.join(',\n')}\n})`;
-        // Handle additionalProperties
-        if (schema.additionalProperties === false) {
-            objectSchema += '.strict()';
-        }
-        else if (typeof schema.additionalProperties === 'object') {
-            const valueSchema = this.toZodSchema(schema.additionalProperties, `${schemaName}Additional`, refs, new Set(visited));
-            objectSchema += `.passthrough().catchall(${valueSchema})`;
-        }
-        return objectSchema;
-    }
-    /**
-     * Resolve $ref to schema name
-     */
-    resolveRef(ref) {
-        if (ref.startsWith('#/components/schemas/')) {
-            return ref.replace('#/components/schemas/', '');
-        }
-        if (ref.includes('#/components/schemas/')) {
-            return ref.split('#/components/schemas/')[1];
-        }
-        return ref;
-    }
-    /**
-     * Convert schema name to Zod schema variable name
-     */
-    toSchemaName(name) {
-        return `${name.charAt(0).toLowerCase() + name.slice(1)}Schema`;
-    }
-    /**
-     * Convert schema name to TypeScript type name
-     */
-    toTypeName(name) {
-        return name;
-    }
-    /**
-     * Capitalize first letter
-     */
-    capitalize(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }
-    /**
-     * List target files
-     */
-    async listTargetFiles() {
-        const files = await this.findOpenAPIFiles();
-        const outputFiles = [];
-        for (const file of files) {
-            const fileName = path.basename(file, path.extname(file));
-            outputFiles.push(path.join(this.outputDir, `${fileName}.zod.ts`));
-        }
-        // Add common schemas
-        outputFiles.push(path.join(this.outputDir, 'common-schemas.zod.ts'));
-        return outputFiles;
-    }
-    /**
-     * Check for drift
-     */
-    async checkDrift() {
-        return [];
-    }
-};
-OpenAPIZodGenerator = __decorate([
-    injectable()
-], OpenAPIZodGenerator);
-export { OpenAPIZodGenerator };
-//# sourceMappingURL=openapi-zod.generator.js.map

package/dist/services/codegen/generators/openapi.generator.d.ts

@@ -1,46 +0,0 @@
-/**
- * OpenAPI Generator - Sync versions in OpenAPI specs
- *
- * Updates:
- * - info.version in all openapi/*.yaml files
- * - Schema URLs to use correct domain
- *
- * Domain Configuration:
- * - OSSA_DOMAIN env var (default: openstandardagents.org)
- * - Local dev: ossa.orb.local
- */
-import type { Generator, GenerateResult, DriftReport } from '../codegen.service.js';
-export declare class OpenAPIGenerator implements Generator {
-    name: string;
-    private readonly patterns;
-    private readonly excludePatterns;
-    /**
-     * Generate: Update versions in OpenAPI specs
-     */
-    generate(dryRun: boolean): Promise<GenerateResult>;
-    /**
-     * List target files
-     */
-    listTargetFiles(): Promise<string[]>;
-    /**
-     * Check for version drift
-     */
-    checkDrift(version: string, apiVersion: string): Promise<DriftReport['filesWithOldVersion']>;
-    /**
-     * Update a single OpenAPI spec
-     */
-    private updateOpenAPISpec;
-    /**
-     * Get configured domain
-     */
-    private getDomain;
-    /**
-     * Find old OSSA version patterns (not API versions)
-     *
-     * Note: OpenAPI specs have their own info.version (e.g., 1.2.0)
-     * which is the API version, NOT the OSSA schema version.
-     * We only check for ossa/vX.X.X patterns.
-     */
-    private findOldVersions;
-}
-//# sourceMappingURL=openapi.generator.d.ts.map

package/dist/services/codegen/generators/openapi.generator.js

@@ -1,157 +0,0 @@
-/**
- * OpenAPI Generator - Sync versions in OpenAPI specs
- *
- * Updates:
- * - info.version in all openapi/*.yaml files
- * - Schema URLs to use correct domain
- *
- * Domain Configuration:
- * - OSSA_DOMAIN env var (default: openstandardagents.org)
- * - Local dev: ossa.orb.local
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { injectable } from 'inversify';
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import { getVersion, getApiVersion } from '../../../utils/version.js';
-// Domain configuration
-const OSSA_DOMAIN = process.env.OSSA_DOMAIN || 'openstandardagents.org';
-const OSSA_LOCAL_DOMAIN = 'ossa.orb.local';
-let OpenAPIGenerator = class OpenAPIGenerator {
-    name = 'openapi';
-    patterns = ['openapi/**/*.yaml', 'openapi/**/*.yml'];
-    excludePatterns = ['node_modules/**', 'dist/**'];
-    /**
-     * Generate: Update versions in OpenAPI specs
-     */
-    async generate(dryRun) {
-        const result = {
-            generator: this.name,
-            filesUpdated: 0,
-            filesCreated: 0,
-            errors: [],
-        };
-        const files = await this.listTargetFiles();
-        const version = getVersion();
-        const apiVersion = getApiVersion();
-        for (const file of files) {
-            try {
-                const updated = await this.updateOpenAPISpec(file, version, apiVersion, dryRun);
-                if (updated) {
-                    result.filesUpdated++;
-                }
-            }
-            catch (error) {
-                result.errors.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        return result;
-    }
-    /**
-     * List target files
-     */
-    async listTargetFiles() {
-        const allFiles = [];
-        for (const pattern of this.patterns) {
-            const files = await glob(pattern, {
-                ignore: this.excludePatterns,
-                cwd: process.cwd(),
-                absolute: true,
-            });
-            allFiles.push(...files);
-        }
-        return [...new Set(allFiles)].sort();
-    }
-    /**
-     * Check for version drift
-     */
-    async checkDrift(version, apiVersion) {
-        const drift = [];
-        const files = await this.listTargetFiles();
-        for (const file of files) {
-            try {
-                const content = fs.readFileSync(file, 'utf8');
-                const oldVersions = this.findOldVersions(content, version);
-                if (oldVersions.length > 0) {
-                    drift.push({
-                        path: path.relative(process.cwd(), file),
-                        foundVersion: oldVersions[0],
-                    });
-                }
-            }
-            catch {
-                // Skip
-            }
-        }
-        return drift;
-    }
-    /**
-     * Update a single OpenAPI spec
-     */
-    async updateOpenAPISpec(filePath, version, apiVersion, dryRun) {
-        const content = fs.readFileSync(filePath, 'utf8');
-        let updated = content;
-        // Update info.version
-        updated = updated.replace(/(info:\s*\n(?:[^\n]*\n)*?\s*version:\s*)(['"]?)[\d.]+(-[\w.]+)?(['"]?)/m, `$1$2${version}$4`);
-        // Update ossa/vX.X.X patterns
-        updated = updated.replace(/ossa\/v\d+\.\d+\.\d+/g, apiVersion);
-        // Update schema URLs - use configured domain
-        const domain = this.getDomain();
-        updated = updated.replace(/https?:\/\/[a-z.-]+\/schemas\/v[\d.]+/g, `https://${domain}/schemas/v${version}`);
-        if (updated === content) {
-            return false;
-        }
-        if (!dryRun) {
-            fs.writeFileSync(filePath, updated, 'utf8');
-        }
-        return true;
-    }
-    /**
-     * Get configured domain
-     */
-    getDomain() {
-        // Allow override via environment
-        if (process.env.OSSA_LOCAL === 'true') {
-            return OSSA_LOCAL_DOMAIN;
-        }
-        return OSSA_DOMAIN;
-    }
-    /**
-     * Find old OSSA version patterns (not API versions)
-     *
-     * Note: OpenAPI specs have their own info.version (e.g., 1.2.0)
-     * which is the API version, NOT the OSSA schema version.
-     * We only check for ossa/vX.X.X patterns.
-     */
-    findOldVersions(content, currentVersion) {
-        const versions = [];
-        const apiVersion = `ossa/v${currentVersion}`;
-        // Only find ossa/vX.X.X patterns (OSSA schema version)
-        const ossaVersionMatches = content.matchAll(/ossa\/v(\d+\.\d+\.\d+)/g);
-        for (const match of ossaVersionMatches) {
-            const foundVersion = `ossa/v${match[1]}`;
-            if (foundVersion !== apiVersion) {
-                versions.push(foundVersion);
-            }
-        }
-        // Find schema URL versions
-        const schemaUrlMatches = content.matchAll(/schemas\/v(\d+\.\d+\.\d+)/g);
-        for (const match of schemaUrlMatches) {
-            if (match[1] !== currentVersion) {
-                versions.push(`schemas/v${match[1]}`);
-            }
-        }
-        return [...new Set(versions)];
-    }
-};
-OpenAPIGenerator = __decorate([
-    injectable()
-], OpenAPIGenerator);
-export { OpenAPIGenerator };
-//# sourceMappingURL=openapi.generator.js.map