@opra/cli 1.0.0-alpha.11 → 1.0.0-alpha.13

package/esm/ts-generator/processors/process-data-types.js

@@ -3,108 +3,119 @@ import path from 'path';
 import { CodeBlock } from '../../code-block.js';
 import { wrapJSDocString } from '../utils/string-utils.js';
 const internalTypeNames = ['any', 'boolean', 'bigint', 'number', 'null', 'string', 'object'];
-export async function processDataType(dataType) {
+export async function processDataType(dataType, currentFile, intent) {
     const doc = dataType.node.getDocument();
     if (doc.id !== this._document?.id) {
         const { generator } = await this.processDocument(doc);
-        return await generator.processDataType(dataType);
+        return await generator.processDataType(dataType, currentFile, intent);
     }
     const typeName = dataType.name;
-    if (typeName && internalTypeNames.includes(typeName))
-        return;
-    if (!typeName)
-        throw new TypeError(`DataType has no name`);
-    let file = this._filesMap.get(dataType);
-    if (file)
-        return file;
-    if (dataType instanceof SimpleType)
-        file = this.addFile(path.join(this._documentRoot, '/simple-types.ts'), true);
-    else {
-        if (dataType instanceof EnumType)
+    if (typeName) {
+        if (internalTypeNames.includes(typeName))
+            return { kind: 'internal', typeName: dataType.name };
+        let file = this._filesMap.get(dataType);
+        if (file) {
+            if (currentFile)
+                currentFile.addImport(file.filename, [typeName]);
+            return { kind: 'named', file, typeName: dataType.name };
+        }
+        if (dataType instanceof SimpleType)
+            file = this.addFile(path.join(this._documentRoot, '/simple-types.ts'), true);
+        else if (dataType instanceof EnumType)
             file = this.addFile(path.join(this._typesRoot, 'enums', typeName + '.ts'));
         else
             file = this.addFile(path.join(this._typesRoot, 'types', typeName + '.ts'));
-    }
-    this._filesMap.set(dataType, file);
-    file = this._filesMap.get(dataType);
-    if (file.exportTypes.includes(typeName))
-        return file;
-    file.exportTypes.push(typeName);
-    const typesIndexTs = this.addFile(path.join(this._typesRoot, 'index.ts'), true);
-    const indexTs = this.addFile('/index.ts', true);
-    indexTs.addExport(typesIndexTs.filename);
-    const codeBlock = (file.code['type_' + typeName] = new CodeBlock());
-    codeBlock.head = `/**\n * ${typeName}`;
-    if (dataType.description)
-        codeBlock.head += `\n * ${wrapJSDocString(dataType.description || '')}`;
-    codeBlock.head += `
+        this._filesMap.set(dataType, file);
+        if (file.exportTypes.includes(typeName)) {
+            if (currentFile)
+                currentFile.addImport(file.filename, [typeName]);
+            return { kind: 'named', file, typeName: dataType.name };
+        }
+        file.exportTypes.push(typeName);
+        const typesIndexTs = this.addFile(path.join(this._typesRoot, 'index.ts'), true);
+        const indexTs = this.addFile('/index.ts', true);
+        indexTs.addExport(typesIndexTs.filename);
+        const codeBlock = (file.code['type_' + typeName] = new CodeBlock());
+        codeBlock.head = `/**\n * ${wrapJSDocString(dataType.description || '')}\n *`;
+        codeBlock.head += `
  * @url ${path.posix.join(doc.url || this.serviceUrl, '$schema', '#types/' + typeName)}
  */
 export `;
-    if (dataType instanceof EnumType)
-        codeBlock.typeDef = await this.generateEnumTypeDefinition(dataType, 'scope');
-    else if (dataType instanceof ComplexType) {
-        codeBlock.typeDef = await this.generateComplexTypeDefinition(dataType, file, 'scope');
+        codeBlock.typeDef = (await this.generateTypeDefinition(file, dataType, 'root')) + '\n\n';
+        typesIndexTs.addExport(file.filename);
+        if (currentFile)
+            currentFile.addImport(file.filename, [typeName]);
+        return { kind: 'named', file, typeName };
+    }
+    if (!currentFile)
+        throw new TypeError(`You must provide currentFile to generate data type`);
+    const code = await this.generateTypeDefinition(currentFile, dataType, intent);
+    return { kind: 'embedded', code };
+}
+/**
+ *
+ */
+export async function generateTypeDefinition(currentFile, dataType, intent) {
+    if (intent === 'root' && !dataType.name) {
+        throw new TypeError(`Name required to generate data type code to root intent`);
+    }
+    if (dataType instanceof EnumType) {
+        return await this.generateEnumTypeDefinition(currentFile, dataType, intent);
+    }
+    if (dataType instanceof ComplexType) {
+        return await this.generateComplexTypeDefinition(currentFile, dataType, intent);
     }
-    else if (dataType instanceof SimpleType) {
-        codeBlock.typeDef = await this.generateSimpleTypeDefinition(dataType, 'scope');
+    if (dataType instanceof SimpleType) {
+        return await this.generateSimpleTypeDefinition(currentFile, dataType, intent);
     }
-    else if (dataType instanceof MappedType) {
-        codeBlock.typeDef = await this.generateMappedTypeDefinition(dataType, file, 'scope');
+    if (dataType instanceof MappedType) {
+        return await this.generateMappedTypeDefinition(currentFile, dataType, intent);
     }
-    else if (dataType instanceof MixinType) {
-        codeBlock.typeDef = await this.generateMixinTypeDefinition(dataType, file, 'scope');
+    if (dataType instanceof MixinType) {
+        return await this.generateMixinTypeDefinition(currentFile, dataType, intent);
     }
-    else
-        throw new TypeError(`${dataType.kind} data type (${typeName}) can not be directly exported`);
-    typesIndexTs.addExport(file.filename);
-    return file;
+    /* istanbul ignore next */
+    throw new TypeError(`${dataType.kind} data types can not be directly exported`);
 }
 /**
  *
  */
-export async function generateEnumTypeDefinition(dataType, intent) {
-    if (intent === 'field') {
-        return ('(' +
-            Object.keys(dataType.attributes)
-                .map(t => `'${t}'`)
-                .join(' | ') +
-            ')');
-    }
-    if (intent !== 'scope')
-        throw new TypeError(`Can't generate EnumType for "${intent}" intent`);
-    if (!dataType.name)
-        throw new TypeError(`Name required to generate EnumType for "${intent}" intent`);
-    let out = `enum ${dataType.name} {\n\t`;
-    for (const [value, info] of Object.entries(dataType.attributes)) {
-        // Print JSDoc
-        let jsDoc = '';
-        if (dataType.attributes[value].description)
-            jsDoc += ` * ${dataType.attributes[value].description}\n`;
-        if (jsDoc)
-            out += `/**\n${jsDoc} */\n`;
-        out +=
-            `${info.alias || value} = ` + (typeof value === 'number' ? value : "'" + String(value).replace("'", "\\'") + "'");
-        out += ',\n\n';
+export async function generateEnumTypeDefinition(currentFile, dataType, intent) {
+    if (intent === 'root') {
+        let out = `enum ${dataType.name} {\n\t`;
+        for (const [value, info] of Object.entries(dataType.attributes)) {
+            // Print JSDoc
+            let jsDoc = '';
+            if (dataType.attributes[value].description)
+                jsDoc += ` * ${dataType.attributes[value].description}\n`;
+            if (jsDoc)
+                out += `/**\n${jsDoc} */\n`;
+            out +=
+                `${info.alias || value} = ` +
+                    (typeof value === 'number' ? value : "'" + String(value).replace("'", "\\'") + "'");
+            out += ',\n\n';
+        }
+        return out + '\b}';
     }
-    return out + '\b}';
+    return ('(' +
+        Object.keys(dataType.attributes)
+            .map(t => `'${t}'`)
+            .join(' | ') +
+        ')');
 }
 /**
  *
  */
-export async function generateComplexTypeDefinition(dataType, file, intent) {
-    if (intent === 'scope' && !dataType.name) {
-        throw new TypeError(`Name required to generate ComplexType for "${intent}" intent`);
-    }
-    let out = intent === 'scope' ? `interface ${dataType.name} ` : '';
+export async function generateComplexTypeDefinition(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `interface ${dataType.name} ` : '';
     const ownFields = [...dataType.fields.values()].filter(f => f.origin === dataType);
     if (dataType.base) {
-        const base = await this.resolveTypeNameOrDef(dataType.base, file, 'extends');
-        const omitBaseFields = dataType.base ? ownFields.filter(f => dataType.base.fields.has(f.name)) : [];
-        const baseDef = omitBaseFields.length
-            ? `Omit<${base}, ${omitBaseFields.map(x => "'" + x.name + "'").join(' | ')}>`
-            : `${base}`;
-        if (intent === 'scope')
+        const base = await this.processDataType(dataType.base, currentFile, 'extends');
+        let baseDef = base.kind === 'embedded' ? base.code : base.typeName;
+        const omitBaseFields = ownFields.filter(f => dataType.base.fields.has(f.name));
+        if (omitBaseFields.length)
+            baseDef = `Omit<${baseDef}, ${omitBaseFields.map(x => "'" + x.name + "'").join(' | ')}>`;
+        if (intent === 'root')
             out += `extends ${baseDef} `;
         else {
             out += baseDef;
@@ -143,7 +154,8 @@ export async function generateComplexTypeDefinition(dataType, file, intent) {
             out += `${t === 'number' || t === 'boolean' || t === 'bigint' ? field.fixed : "'" + field.fixed + "'"}\n`;
         }
         else {
-            out += (await this.resolveTypeNameOrDef(field.type, file, 'field')) + `${field.isArray ? '[]' : ''};\n`;
+            const x = await this.processDataType(field.type, currentFile);
+            out += (x.kind === 'embedded' ? x.code : x.typeName) + `${field.isArray ? '[]' : ''};\n`;
         }
     }
     if (dataType.additionalFields)
@@ -153,27 +165,37 @@ export async function generateComplexTypeDefinition(dataType, file, intent) {
 /**
  *
  */
-export async function generateSimpleTypeDefinition(dataType, intent) {
-    if (intent === 'scope' && !dataType.name) {
-        throw new TypeError(`Name required to generate SimpleType for "${intent}" intent`);
-    }
-    let out = intent === 'scope' ? `type ${dataType.name} = ` : '';
+export async function generateSimpleTypeDefinition(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `type ${dataType.name} = ` : '';
     out += dataType.nameMappings.js || 'any';
-    return intent === 'scope' ? out + ';' : out;
+    return intent === 'root' ? out + ';' : out;
 }
 /**
  *
  */
-export async function generateMixinTypeDefinition(dataType, file, intent) {
-    return (await Promise.all(dataType.types.map(t => this.resolveTypeNameOrDef(t, file, intent))))
-        .map(t => (t.includes('|') ? '(' + t + ')' : t))
-        .join(intent === 'extends' ? ', ' : ' & ');
+export async function generateMixinTypeDefinition(currentFile, dataType, intent) {
+    const outArray = [];
+    for (const t of dataType.types) {
+        const x = await this.processDataType(t, currentFile);
+        if (x.kind === 'embedded') {
+            outArray.push(x.code.includes('|') ? '(' + x.code + ')' : x.code);
+        }
+        else
+            outArray.push(x.typeName);
+    }
+    if (intent === 'root')
+        return `type ${dataType.name} = ${outArray.join(' & ')}`;
+    if (intent === 'extends')
+        return outArray.join(', ');
+    return outArray.join(' & ');
 }
 /**
  *
  */
-export async function generateMappedTypeDefinition(dataType, file, intent) {
-    const typeDef = await this.resolveTypeNameOrDef(dataType.base, file, intent);
+export async function generateMappedTypeDefinition(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `type ${dataType.name} = ` : '';
+    const base = await this.processDataType(dataType.base, currentFile);
+    const typeDef = base.kind === 'embedded' ? base.code : base.typeName;
     const pick = dataType.pick?.length ? dataType.pick : undefined;
     const omit = !pick && dataType.omit?.length ? dataType.omit : undefined;
     const partial = dataType.partial === true || (Array.isArray(dataType.partial) && dataType.partial.length > 0)
@@ -184,18 +206,17 @@ export async function generateMappedTypeDefinition(dataType, file, intent) {
         : undefined;
     if (!(pick || omit || partial || required))
         return typeDef;
-    let out = '';
     if (partial === true)
         out += 'Partial<';
     else if (partial) {
         out += 'PartialSome<';
-        file.addExport('ts-gems', ['PartialSome']);
+        currentFile.addExport('ts-gems', ['PartialSome']);
     }
     if (required === true)
         out += 'Partial<';
     else if (required) {
         out += 'RequiredSome<';
-        file.addExport('ts-gems', ['RequiredSome']);
+        currentFile.addExport('ts-gems', ['RequiredSome']);
     }
     if (pick)
         out += 'Pick<';
@@ -224,28 +245,3 @@ export async function generateMappedTypeDefinition(dataType, file, intent) {
     }
     return out;
 }
-/**
- *
- */
-export async function resolveTypeNameOrDef(dataType, file, intent) {
-    if (dataType.name && !dataType.embedded) {
-        if (internalTypeNames.includes(dataType.name))
-            return dataType.name;
-        const f = await this.processDataType(dataType);
-        if (!f)
-            return '';
-        file.addImport(f.filename, [dataType.name], true);
-        return dataType.name;
-    }
-    if (dataType instanceof SimpleType)
-        return this.generateSimpleTypeDefinition(dataType, intent);
-    if (dataType instanceof EnumType)
-        return this.generateEnumTypeDefinition(dataType, intent);
-    if (dataType instanceof MixinType)
-        return this.generateMixinTypeDefinition(dataType, file, intent);
-    if (dataType instanceof MappedType)
-        return this.generateMappedTypeDefinition(dataType, file, intent);
-    if (dataType instanceof ComplexType)
-        return this.generateComplexTypeDefinition(dataType, file, intent);
-    return '';
-}

package/esm/ts-generator/processors/process-http-controller.js

@@ -86,8 +86,13 @@ export async function processHttpController(controller) {
         }
         let argIndex = 0;
         for (const prm of pathParams) {
-            const type = locateNamedType(prm.type);
-            const typeName = type ? await this.resolveTypeNameOrDef(type, file, 'field') : 'any';
+            let typeName;
+            if (prm.type) {
+                const xt = await this.processDataType(prm.type, file);
+                typeName = xt.kind === 'embedded' ? xt.code : xt.typeName;
+            }
+            else
+                typeName = `any`;
             if (argIndex++ > 0)
                 operationBlock.head += ', ';
             operationBlock.head += `${prm.name}: ${typeName}`;
@@ -99,8 +104,10 @@ export async function processHttpController(controller) {
             let typeArr = [];
             for (const content of operation.requestBody.content) {
                 if (content.type) {
-                    const typeName = await this.resolveTypeNameOrDef(content.type, file, 'field');
+                    const xt = await this.processDataType(content.type, file);
+                    const typeName = xt.kind === 'embedded' ? xt.code : xt.typeName;
                     typeArr.push(typeName);
+                    continue;
                 }
                 typeArr = [];
                 break;
@@ -127,18 +134,15 @@ export async function processHttpController(controller) {
                 operationBlock.head += ', ';
             operationBlock.head += '\n\t$params' + (isHeadersRequired || isQueryRequired ? '' : '?') + ': {\n\t';
             for (const prm of queryParams) {
-                const type = locateNamedType(prm.type);
                 operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
                 operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
-                if (type?.name) {
-                    const typeFile = await this.processDataType(type);
-                    if (typeFile) {
-                        file.addImport(typeFile.filename, [type.name]);
-                        operationBlock.head += `${type.name};\n`;
-                        continue;
-                    }
+                if (prm.type) {
+                    const xt = await this.processDataType(prm.type, file);
+                    const typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    operationBlock.head += `${typeDef};\n`;
                 }
-                operationBlock.head += `${type?.name || 'any'};\n`;
+                else
+                    operationBlock.head += `any;\n`;
             }
             operationBlock.head += '\b}\b';
         }
@@ -148,30 +152,39 @@ export async function processHttpController(controller) {
                 operationBlock.head += ', \n';
             operationBlock.head += '\t$headers' + (isHeadersRequired ? '' : '?') + ': {\n\t';
             for (const prm of headerParams) {
-                const type = locateNamedType(prm.type);
                 operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
                 operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
-                if (type?.name) {
-                    const typeFile = await this.processDataType(type);
-                    if (typeFile) {
-                        file.addImport(typeFile.filename, [type.name]);
-                        operationBlock.head += `${type.name};\n`;
-                        continue;
-                    }
+                if (prm.type) {
+                    const xt = await this.processDataType(prm.type, file);
+                    const typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    operationBlock.head += `${typeDef};\n`;
                 }
-                operationBlock.head += `${type?.name || 'any'};\n`;
+                else
+                    operationBlock.head += `any;\n`;
             }
             operationBlock.head += '\b}\b';
         }
+        /* Determine return type */
+        // let returnType = '';
+        // for (const resp of operation.responses) {
+        //   if (resp.type) {
+        //     const typeFile = await this.processDataType(resp.type);
+        //     // if (typeFile) {
+        //     //   file.addImport(typeFile.filename, [resp.type.name!]);
+        //     //   operationBlock.head += `${type.name};\n`;
+        //     //   continue;
+        //     // }
+        //   }
+        // }
         operationBlock.head += `\n): HttpRequestObservable<any>{`;
         operationBlock.body = `\n\t`;
         operationBlock.body +=
             `const url = this._prepareUrl('${operation.getFullUrl()}', {` + pathParams.map(p => p.name).join(', ') + '});';
         operationBlock.body +=
-            `\nreturn this[kClient].request(url, {` +
-                (hasBody ? ' body: $body,' : '') +
-                (queryParams.length ? ' params: $params as any,' : '') +
-                (headerParams.length ? ' headers: $headers as any,' : '') +
+            `\nreturn this[kClient].request(url, { method: '${operation.method}'` +
+                (hasBody ? ', body: $body' : '') +
+                (queryParams.length ? ', params: $params as any' : '') +
+                (headerParams.length ? ', headers: $headers as any' : '') +
                 '});';
         operationBlock.tail = `\b\n};\n`;
     }

package/esm/ts-generator/ts-generator.js

@@ -4,11 +4,11 @@ import path from 'node:path';
 import process from 'node:process';
 import chalk from 'chalk';
 import { FileWriter } from '../file-writer.js';
-import { cleanDirectory } from './processors/clean-directory.js';
-import { generateComplexTypeDefinition, generateEnumTypeDefinition, generateMappedTypeDefinition, generateMixinTypeDefinition, generateSimpleTypeDefinition, processDataType, resolveTypeNameOrDef, } from './processors/process-data-types.js';
-import { processDocument } from './processors/process-document.js';
-import { processHttpApi } from './processors/process-http-api.js';
-import { processHttpController } from './processors/process-http-controller.js';
+import { cleanDirectory } from './generators/clean-directory.js';
+import { _generateComplexTypeCode, _generateEnumTypeCode, _generateMappedTypeCode, _generateMixinTypeCode, _generateSimpleTypeCode, _generateTypeCode, generateDataType, } from './generators/generate-data-type.js';
+import { generateDocument } from './generators/generate-document.js';
+import { generateHttpApi } from './generators/generate-http-api.js';
+import { generateHttpController } from './generators/generate-http-controller.js';
 import { TsFile } from './ts-file.js';
 /**
  * @class TsGenerator
@@ -45,7 +45,7 @@ export class TsGenerator extends EventEmitter {
             this.emit('log', chalk.cyan('Removing old files..'));
             this.cleanDirectory(this.outDir);
             this._apiPath = '/api';
-            await this.processDocument();
+            await this.generateDocument();
             const { importExt } = this.options;
             // Write files
             for (const file of Object.values(this._files)) {
@@ -90,14 +90,14 @@ export class TsGenerator extends EventEmitter {
 }
 (() => {
     TsGenerator.prototype.cleanDirectory = cleanDirectory;
-    TsGenerator.prototype.processDocument = processDocument;
-    TsGenerator.prototype.processDataType = processDataType;
-    TsGenerator.prototype.processHttpApi = processHttpApi;
-    TsGenerator.prototype.processHttpController = processHttpController;
-    TsGenerator.prototype.generateEnumTypeDefinition = generateEnumTypeDefinition;
-    TsGenerator.prototype.generateComplexTypeDefinition = generateComplexTypeDefinition;
-    TsGenerator.prototype.generateSimpleTypeDefinition = generateSimpleTypeDefinition;
-    TsGenerator.prototype.generateMappedTypeDefinition = generateMappedTypeDefinition;
-    TsGenerator.prototype.generateMixinTypeDefinition = generateMixinTypeDefinition;
-    TsGenerator.prototype.resolveTypeNameOrDef = resolveTypeNameOrDef;
+    TsGenerator.prototype.generateDocument = generateDocument;
+    TsGenerator.prototype.generateDataType = generateDataType;
+    TsGenerator.prototype._generateTypeCode = _generateTypeCode;
+    TsGenerator.prototype._generateEnumTypeCode = _generateEnumTypeCode;
+    TsGenerator.prototype._generateComplexTypeCode = _generateComplexTypeCode;
+    TsGenerator.prototype._generateSimpleTypeCode = _generateSimpleTypeCode;
+    TsGenerator.prototype._generateMappedTypeCode = _generateMappedTypeCode;
+    TsGenerator.prototype._generateMixinTypeCode = _generateMixinTypeCode;
+    TsGenerator.prototype.generateHttpApi = generateHttpApi;
+    TsGenerator.prototype.generateHttpController = generateHttpController;
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/cli",
-  "version": "1.0.0-alpha.11",
+  "version": "1.0.0-alpha.13",
   "description": "Opra CLI tools",
   "author": "Panates",
   "license": "MIT",
@@ -31,8 +31,9 @@
     "clean:cover": "rimraf ../../coverage/client"
   },
   "dependencies": {
-    "@opra/client": "^1.0.0-alpha.11",
-    "@opra/common": "^1.0.0-alpha.11",
+    "@browsery/type-is": "^1.6.18-r3",
+    "@opra/client": "^1.0.0-alpha.13",
+    "@opra/common": "^1.0.0-alpha.13",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "js-string-escape": "^1.0.1",

package/types/ts-generator/generators/clean-directory.d.ts

@@ -0,0 +1,2 @@
+import type { TsGenerator } from '../ts-generator';
+export declare function cleanDirectory(this: TsGenerator, dirname: string): void;

package/types/ts-generator/generators/generate-data-type.d.ts

@@ -0,0 +1,41 @@
+import { ComplexType, DataType, EnumType, MappedType, MixinType, SimpleType } from '@opra/common';
+import { TsFile } from '../ts-file.js';
+import type { TsGenerator } from '../ts-generator';
+type Intent = 'root' | 'extends' | 'typeDef';
+export type generateDataTypeResult = {
+    kind: 'internal';
+    typeName: string;
+} | {
+    kind: 'named';
+    typeName: string;
+    file: TsFile;
+} | {
+    kind: 'embedded';
+    code: string;
+};
+export declare function generateDataType(this: TsGenerator, dataType: DataType, intent: Intent, currentFile?: TsFile): Promise<generateDataTypeResult>;
+/**
+ *
+ */
+export declare function _generateTypeCode(this: TsGenerator, currentFile: TsFile, dataType: DataType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateEnumTypeCode(this: TsGenerator, currentFile: TsFile, dataType: EnumType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateComplexTypeCode(this: TsGenerator, currentFile: TsFile, dataType: ComplexType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateSimpleTypeCode(this: TsGenerator, currentFile: TsFile, dataType: SimpleType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateMixinTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MixinType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateMappedTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MappedType, intent?: Intent): Promise<string>;
+export {};

package/types/ts-generator/generators/generate-document.d.ts

@@ -0,0 +1,8 @@
+import { ApiDocument } from '@opra/common';
+import type { TsGenerator } from '../ts-generator';
+export declare function generateDocument(this: TsGenerator, document?: string | ApiDocument, options?: {
+    typesOnly?: boolean;
+}): Promise<{
+    document: ApiDocument;
+    generator: TsGenerator;
+}>;

package/types/ts-generator/generators/generate-http-api.d.ts

@@ -0,0 +1,3 @@
+import { HttpApi } from '@opra/common';
+import type { TsGenerator } from '../ts-generator';
+export declare function generateHttpApi(this: TsGenerator, api: HttpApi): Promise<import("../ts-file.js").TsFile>;

package/types/ts-generator/generators/generate-http-controller.d.ts

@@ -0,0 +1,3 @@
+import { HttpController } from '@opra/common';
+import type { TsGenerator } from '../ts-generator';
+export declare function generateHttpController(this: TsGenerator, controller: HttpController): Promise<import("../ts-file.js").TsFile>;

package/types/ts-generator/processors/process-data-types.d.ts

@@ -1,30 +1,41 @@
 import { ComplexType, DataType, EnumType, MappedType, MixinType, SimpleType } from '@opra/common';
 import { TsFile } from '../ts-file.js';
 import type { TsGenerator } from '../ts-generator';
-type Intent = 'scope' | 'extends' | 'field';
-export declare function processDataType(this: TsGenerator, dataType: DataType): Promise<TsFile | undefined>;
+type Intent = 'root' | 'extends' | 'property';
+export type ProcessDataTypeResult = {
+    kind: 'internal';
+    typeName: string;
+} | {
+    kind: 'named';
+    typeName: string;
+    file: TsFile;
+} | {
+    kind: 'embedded';
+    code: string;
+};
+export declare function processDataType(this: TsGenerator, dataType: DataType, currentFile?: TsFile, intent?: Intent): Promise<ProcessDataTypeResult>;
 /**
  *
  */
-export declare function generateEnumTypeDefinition(this: TsGenerator, dataType: EnumType, intent: Intent): Promise<string>;
+export declare function generateTypeDefinition(this: TsGenerator, currentFile: TsFile, dataType: DataType, intent?: Intent): Promise<string>;
 /**
  *
  */
-export declare function generateComplexTypeDefinition(this: TsGenerator, dataType: ComplexType, file: TsFile, intent: Intent): Promise<string>;
+export declare function generateEnumTypeDefinition(this: TsGenerator, currentFile: TsFile, dataType: EnumType, intent?: Intent): Promise<string>;
 /**
  *
  */
-export declare function generateSimpleTypeDefinition(this: TsGenerator, dataType: SimpleType, intent: Intent): Promise<string>;
+export declare function generateComplexTypeDefinition(this: TsGenerator, currentFile: TsFile, dataType: ComplexType, intent?: Intent): Promise<string>;
 /**
  *
  */
-export declare function generateMixinTypeDefinition(this: TsGenerator, dataType: MixinType, file: TsFile, intent: Intent): Promise<string>;
+export declare function generateSimpleTypeDefinition(this: TsGenerator, currentFile: TsFile, dataType: SimpleType, intent?: Intent): Promise<string>;
 /**
  *
  */
-export declare function generateMappedTypeDefinition(this: TsGenerator, dataType: MappedType, file: TsFile, intent: Intent): Promise<string>;
+export declare function generateMixinTypeDefinition(this: TsGenerator, currentFile: TsFile, dataType: MixinType, intent?: Intent): Promise<string>;
 /**
  *
  */
-export declare function resolveTypeNameOrDef(this: TsGenerator, dataType: DataType, file: TsFile, intent: Intent): Promise<string>;
+export declare function generateMappedTypeDefinition(this: TsGenerator, currentFile: TsFile, dataType: MappedType, intent?: Intent): Promise<string>;
 export {};