@mittwald/api-code-generator 0.0.0-development-04b7288-20240610 → 0.0.0-development-74e1fd1-20240611

package/dist/esm/generation/refs/splitRefNamespaces.test.js

@@ -0,0 +1,10 @@
+import { splitRefNamespaces } from "./splitRefNamespaces.js";
+test.each([
+    ["#/foo/bar", ["foo", "bar"]],
+    ["foo", ["foo"]],
+    ["#/", []],
+])("splitRefNamespaces works for test %#", (input, expected) => {
+    const result = splitRefNamespaces(input);
+    expect(result).toEqual(expect.arrayContaining(expected));
+    expect(result.length).toEqual(expected.length);
+});

package/dist/esm/generation/tsNamespaceName.js

@@ -0,0 +1,2 @@
+import { tsTypeName } from "./tsTypeName.js";
+export const tsNamespaceName = (...parts) => parts.map(tsTypeName).join(".");

package/dist/esm/generation/tsTypeName.js

@@ -0,0 +1,6 @@
+import { toSafeString } from "json-schema-to-typescript/dist/src/utils.js";
+export const tsTypeName = (name) => {
+    const nameStartsWithNumber = /^\d/.test(name);
+    const almostSafeString = nameStartsWithNumber ? `$${name}` : name;
+    return toSafeString(almostSafeString);
+};

package/dist/esm/generation/tsTypeName.test.js

@@ -0,0 +1,12 @@
+import { tsTypeName } from "./tsTypeName.js";
+test.each([
+    ["123Foo_Bar", "$123Foo_Bar"],
+    ["123-foo-bar", "$123FooBar"],
+    ["1-foo-2-3-bar", "$1Foo23Bar"],
+    ["Foo_Bar", "Foo_Bar"],
+    ["fooBar", "FooBar"],
+    ["foo-bar", "FooBar"],
+])("tsTypeName works for test %#", (input, expected) => {
+    const result = tsTypeName(input);
+    expect(result).toEqual(expected);
+});

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export * from "./loading/UniversalContentLoader.js";
+export * from "./loading/UniversalFileLoader.js";
+export * from "./openapi/OpenApiSpec.js";
+export * from "./generation/model/CodeGenerationModel.js";
+export * from "./generation/prepareTypeScriptOutput.js";
+export * from "./loading/UniversalFileLoader.js";
+export * from "./lib/writeIfChangedAsync.js";

package/dist/esm/lib/makeError.js

@@ -0,0 +1,7 @@
+import VError from "verror";
+import { getProperty } from "dot-prop";
+export const makeError = (error) => error instanceof Error
+    ? error
+    : new VError({
+        name: getProperty(error, "name") ?? "Error",
+    }, getProperty(error, "message") ?? "");

package/dist/esm/lib/relativePath.js

@@ -0,0 +1,3 @@
+import * as url from "url";
+import * as path from "path";
+export const relativePath = (meta, ...paths) => path.join(url.fileURLToPath(new URL(".", meta.url)), ...paths);

package/dist/esm/lib/writeIfChangedAsync.js

@@ -0,0 +1,8 @@
+import jetpack from "fs-jetpack";
+export const writeIfChangedAsync = async (filename, content) => {
+    const existing = await jetpack.readAsync(filename);
+    if (existing === content) {
+        return;
+    }
+    await jetpack.writeAsync(filename, content);
+};

package/dist/esm/loading/UniversalContentLoader.js

@@ -0,0 +1,65 @@
+import { load } from "js-yaml";
+import { parseAsync } from "yieldable-json";
+import VError from "verror";
+import { makeError } from "../lib/makeError.js";
+export class UniversalContentLoader {
+    fileLoader;
+    constructor(fileLoader) {
+        this.fileLoader = fileLoader;
+    }
+    async load() {
+        try {
+            const format = UniversalContentLoader.detectSourceFormat(this.fileLoader.source);
+            const fileContent = await this.fileLoader.load();
+            switch (format) {
+                case "yaml":
+                    return await UniversalContentLoader.parseYaml(fileContent);
+                case "json":
+                    return await UniversalContentLoader.parseJson(fileContent);
+                default:
+                    return await UniversalContentLoader.tryParseUnknown(fileContent);
+            }
+        }
+        catch (error) {
+            throw new VError({
+                cause: makeError(error),
+                name: "ContentLoaderError",
+            }, "Failed loading content");
+        }
+    }
+    static detectSourceFormat(source) {
+        return source.endsWith(".json")
+            ? "json"
+            : source.endsWith(".yaml")
+                ? "yaml"
+                : source.endsWith(".yml")
+                    ? "yaml"
+                    : undefined;
+    }
+    static async tryParseUnknown(content) {
+        try {
+            return await UniversalContentLoader.parseJson(content);
+        }
+        catch (error) {
+            try {
+                return await UniversalContentLoader.parseYaml(content);
+            }
+            catch (error) {
+                throw new Error("Content is not of supported format JSON/YAML.");
+            }
+        }
+    }
+    static async parseYaml(yaml) {
+        return load(yaml);
+    }
+    static parseJson(json) {
+        return new Promise((res, rej) => parseAsync(json, (err, data) => {
+            if (err) {
+                rej(err);
+            }
+            else {
+                res(data);
+            }
+        }));
+    }
+}

package/dist/esm/loading/UniversalContentLoader.test.js

@@ -0,0 +1,40 @@
+import { UniversalContentLoader } from "./UniversalContentLoader.js";
+class TestFileLoader {
+    source;
+    content;
+    constructor(source, content) {
+        this.source = source;
+        this.content = content;
+    }
+    load() {
+        return Promise.resolve(this.content);
+    }
+}
+describe(".load()", () => {
+    test("Throws parser-error error when trying to parse known content", async () => {
+        const fileLoader = new TestFileLoader("test.json", "{some invalid");
+        const contentLoader = new UniversalContentLoader(fileLoader);
+        expect(() => contentLoader.load()).rejects.toThrow("Failed loading content: Bad object");
+    });
+    test("Throws 'Not supported format' error when trying to parse unknown content", async () => {
+        const fileLoader = new TestFileLoader("test.foo", "{some invalid");
+        const contentLoader = new UniversalContentLoader(fileLoader);
+        expect(() => contentLoader.load()).rejects.toThrow("Failed loading content: Content is not of supported format JSON/YAML.");
+    });
+    test("Can load JSON file content", async () => {
+        const fileLoader = new TestFileLoader("test.json", '{"foo": "bar"}');
+        const contentLoader = new UniversalContentLoader(fileLoader);
+        const content = await contentLoader.load();
+        expect(content).toMatchObject({
+            foo: "bar",
+        });
+    });
+    test("Can load unknown JSON file content", async () => {
+        const fileLoader = new TestFileLoader("unknown", '{"foo": "bar"}');
+        const contentLoader = new UniversalContentLoader(fileLoader);
+        const content = await contentLoader.load();
+        expect(content).toMatchObject({
+            foo: "bar",
+        });
+    });
+});

package/dist/esm/loading/UniversalFileLoader.js

@@ -0,0 +1,42 @@
+import axios from "axios";
+import jetpack from "fs-jetpack";
+import VError from "verror";
+import { makeError } from "../lib/makeError.js";
+import getStdin from "get-stdin";
+export class UniversalFileLoader {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    load() {
+        try {
+            if (this.source.startsWith("http")) {
+                return UniversalFileLoader.loadFromUrl(this.source);
+            }
+            if (this.source === "/dev/stdin" || this.source === "-") {
+                return UniversalFileLoader.loadFromStdin();
+            }
+            return UniversalFileLoader.loadFromFile(this.source);
+        }
+        catch (error) {
+            throw new VError({ cause: makeError(error), name: "FileLoaderError" }, "Failed loading file from %s", this.source);
+        }
+    }
+    static loadFromStdin() {
+        return getStdin();
+    }
+    static async loadFromUrl(url) {
+        const response = await axios.get(url, {
+            responseType: "text",
+            validateStatus: (status) => status === 200,
+        });
+        return response.data;
+    }
+    static async loadFromFile(filename) {
+        const file = await jetpack.readAsync(filename);
+        if (file === undefined) {
+            throw new Error(`File not found: ${filename}`);
+        }
+        return file;
+    }
+}

package/dist/esm/loading/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/openapi/OpenAPISchemaValidationError.js

@@ -0,0 +1,17 @@
+import { dump } from "js-yaml";
+export class OpenAPISchemaValidationError extends Error {
+    constructor(errors) {
+        const mergedMessage = OpenAPISchemaValidationError.mergeErrorMessage(errors);
+        super(`OpenAPI is invalid: ${mergedMessage}`);
+        Object.setPrototypeOf(this, OpenAPISchemaValidationError.prototype);
+        this.name = "OpenAPISchemaValidationError";
+    }
+    static mergeErrorMessage(errors) {
+        return errors
+            .map((error, index) => `
+#${index + 1}
+${dump(error)}
+`)
+            .join("");
+    }
+}

package/dist/esm/openapi/OpenApiSpec.js

@@ -0,0 +1,44 @@
+import { OpenAPISchemaValidationError } from "./OpenAPISchemaValidationError.js";
+import VError from "verror";
+import { makeError } from "../lib/makeError.js";
+import OpenAPISchemaValidator from "openapi-schema-validator";
+import { convert } from "swagger2openapi";
+import { ux } from "@oclif/core";
+const validator = new OpenAPISchemaValidator.default({
+    version: 3,
+});
+export class OpenApiSpec {
+    document;
+    constructor(document) {
+        this.document = document;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static async convertToOpenApi(doc) {
+        const version = doc.openapi ?? doc.swagger;
+        if (version.startsWith("3")) {
+            return doc;
+        }
+        ux.action.start("Converting doc to OpenAPI v3");
+        const spec = await convert(doc, {
+            patch: true,
+        });
+        ux.action.stop();
+        return spec.openapi;
+    }
+    static async parse(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    doc, opts = {}) {
+        try {
+            const { skipValidation = false } = opts;
+            doc = await OpenApiSpec.convertToOpenApi(doc);
+            const validationResult = await validator.validate(doc);
+            if (validationResult.errors.length > 0 && !skipValidation) {
+                throw new OpenAPISchemaValidationError(validationResult.errors);
+            }
+            return new OpenApiSpec(doc);
+        }
+        catch (error) {
+            throw new VError({ cause: makeError(error), name: "OpenAPIParserError" }, "Failed parsing OpenAPISpec");
+        }
+    }
+}

package/dist/types/commands/generate/index.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "@oclif/core";
+export default class Generate extends Command {
+    static description: string;
+    static flags: {
+        skipValidation: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        optionalHeader: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static args: {
+        input: import("@oclif/core/lib/interfaces/parser.js").Arg<string, {
+            exists?: boolean | undefined;
+        }>;
+        output: import("@oclif/core/lib/interfaces/parser.js").Arg<string, {
+            exists?: boolean | undefined;
+        }>;
+    };
+    run(): Promise<void>;
+}

package/dist/types/commands/validate/index.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "@oclif/core";
+export default class Validate extends Command {
+    static description: string;
+    static args: {
+        input: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/types/generation/asyncStringJoin.d.ts

@@ -0,0 +1 @@
+export declare const asyncStringJoin: <T>(items: T[], contentGenerator: (item: T) => string | Promise<string>, separator?: string) => Promise<string>;

package/dist/types/generation/asyncStringJoin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/generation/compileJsonSchema.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema, Options } from "json-schema-to-typescript";
+export declare const compileJsonSchema: (schema: JSONSchema, name: string, options?: Partial<Options>) => Promise<string>;

package/dist/types/generation/format.d.ts

@@ -0,0 +1 @@
+export declare const format: (ts: string) => Promise<string>;

package/dist/types/generation/model/CodeGenerationModel.d.ts

@@ -0,0 +1,19 @@
+import { Name } from "./global/Name.js";
+import { Components } from "./components/Components.js";
+import { Paths } from "./paths/Paths.js";
+import { Tag } from "./tags/Tag.js";
+import { OpenAPIV3 } from "openapi-types";
+export interface TypeCompilationOptions {
+    optionalHeaders?: string[];
+    rootNamespace: string;
+}
+export declare class CodeGenerationModel {
+    readonly rootNamespace: Name;
+    readonly paths: Paths;
+    readonly components: Components;
+    readonly tags: Tag[];
+    readonly doc: OpenAPIV3.Document;
+    private constructor();
+    static fromDoc(rootNamespace: string, doc: OpenAPIV3.Document): CodeGenerationModel;
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/components/Components.d.ts

@@ -0,0 +1,24 @@
+import { CodeGenerationModel, TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { Name } from "../global/Name.js";
+import { Schemas } from "./Schemas.js";
+import { Parameters } from "./Parameters.js";
+import { RequestBodies } from "./RequestBodies.js";
+import { Responses } from "./Responses.js";
+import { SecuritySchemes } from "./SecuritySchemes.js";
+import { OpenAPIV3 } from "openapi-types";
+export type ComponentTypeName = keyof OpenAPIV3.ComponentsObject;
+export type ComponentType<T extends ComponentTypeName> = Required<OpenAPIV3.ComponentsObject>[T][string];
+export type ResolvedComponentType<T extends ComponentTypeName> = Exclude<ComponentType<T>, OpenAPIV3.ReferenceObject>;
+export declare class Components {
+    static readonly ns = "Components";
+    name: Name;
+    schemas: Schemas;
+    securitySchemes: SecuritySchemes;
+    parameters: Parameters;
+    requestBodies: RequestBodies;
+    responses: Responses;
+    model: CodeGenerationModel;
+    constructor(model: CodeGenerationModel);
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+    resolveRef<T extends ComponentTypeName>(componentType: T, obj: ComponentType<T>): ResolvedComponentType<T>;
+}

package/dist/types/generation/model/components/Parameters.d.ts

@@ -0,0 +1,11 @@
+import { Name } from "../global/Name.js";
+import { Components, ComponentType } from "./Components.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+export declare class Parameters {
+    static readonly ns = "Parameters";
+    readonly components: Components;
+    readonly name: Name;
+    readonly parameters: Record<string, ComponentType<"parameters">>;
+    constructor(components: Components, parametersObject: Record<string, ComponentType<"parameters">>);
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/components/RequestBodies.d.ts

@@ -0,0 +1,13 @@
+import { JSONSchema } from "../global/JSONSchema.js";
+import { Name } from "../global/Name.js";
+import { Components } from "./Components.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class RequestBodies {
+    static readonly ns = "RequestBodies";
+    readonly schemas: JSONSchema[];
+    readonly components: Components;
+    readonly name: Name;
+    constructor(components: Components, schemas: OpenAPIV3.ComponentsObject["requestBodies"]);
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/components/Response.d.ts

@@ -0,0 +1,12 @@
+import { Name } from "../global/Name.js";
+import { ResponseContent } from "./ResponseContent.js";
+import { Responses } from "./Responses.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class Response {
+    readonly name: Name;
+    readonly responses: Responses;
+    readonly contents: ResponseContent[];
+    constructor(name: Name, responses: Responses, mediaTypesDoc: Record<string, OpenAPIV3.MediaTypeObject>);
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/components/ResponseContent.d.ts

@@ -0,0 +1,10 @@
+import { JSONSchema as JSONSchemaType } from "json-schema-to-typescript";
+import { Name } from "../global/Name.js";
+import { Response } from "./Response.js";
+import { JSONSchema } from "../global/JSONSchema.js";
+export declare class ResponseContent {
+    readonly mediaType: Name;
+    readonly schema: JSONSchema;
+    readonly response: Response;
+    constructor(response: Response, mediaType: string, schema: JSONSchemaType);
+}

package/dist/types/generation/model/components/Responses.d.ts

@@ -0,0 +1,13 @@
+import { Name } from "../global/Name.js";
+import { Components } from "./Components.js";
+import { Response } from "./Response.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class Responses {
+    static readonly ns = "Responses";
+    readonly responses: Response[];
+    readonly components: Components;
+    readonly name: Name;
+    constructor(components: Components, responses?: OpenAPIV3.ComponentsObject["responses"]);
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/components/Schemas.d.ts

@@ -0,0 +1,13 @@
+import { JSONSchema } from "../global/JSONSchema.js";
+import { Name } from "../global/Name.js";
+import { Components } from "./Components.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class Schemas {
+    static readonly ns = "Schemas";
+    readonly schemas: JSONSchema[];
+    readonly components: Components;
+    readonly name: Name;
+    constructor(components: Components, schemas: OpenAPIV3.ComponentsObject["schemas"]);
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/components/SecurityScheme.d.ts

@@ -0,0 +1,10 @@
+import { OpenAPIV3 } from "openapi-types";
+import { Name } from "../global/Name.js";
+import { SecuritySchemes } from "./SecuritySchemes.js";
+import { JSONSchema } from "../global/JSONSchema.js";
+export declare class SecurityScheme {
+    readonly in: string;
+    readonly name: Name;
+    readonly jsonSchema: JSONSchema;
+    constructor(schemes: SecuritySchemes, name: string, doc: OpenAPIV3.ApiKeySecurityScheme);
+}

package/dist/types/generation/model/components/SecuritySchemes.d.ts

@@ -0,0 +1,14 @@
+import { Name } from "../global/Name.js";
+import { Components } from "./Components.js";
+import { OpenAPIV3 } from "openapi-types";
+import { SecurityScheme } from "./SecurityScheme.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+export declare class SecuritySchemes {
+    static readonly ns = "SecuritySchemes";
+    readonly schemes: SecurityScheme[];
+    readonly components: Components;
+    readonly name: Name;
+    constructor(components: Components, doc?: OpenAPIV3.ComponentsObject["securitySchemes"]);
+    requireScheme(name: string): SecurityScheme;
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/global/JSONSchema.d.ts

@@ -0,0 +1,13 @@
+import { JSONSchema as JSONSchemaObject } from "json-schema-to-typescript";
+import { Name } from "./Name.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+export declare class JSONSchema {
+    readonly schemaObject: JSONSchemaObject;
+    readonly name: Name;
+    constructor(name: Name, data?: JSONSchemaObject);
+    compile(opts: TypeCompilationOptions): Promise<string>;
+    clone(): JSONSchema;
+    cloneWithOptionalProperties(optionalProperties: string[]): JSONSchema;
+    private setOptionalPropertiesInSchema;
+    asCustomTypeRef(): JSONSchemaObject;
+}

package/dist/types/generation/model/global/Name.d.ts

@@ -0,0 +1,8 @@
+export declare class Name {
+    readonly raw: string;
+    readonly tsType: string;
+    readonly tsVar: string;
+    readonly parent?: Name;
+    constructor(raw: string, parent?: Name);
+    get tsTypeWithNamespace(): string;
+}

package/dist/types/generation/model/global/Name.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/generation/model/paths/Path.d.ts

@@ -0,0 +1,13 @@
+import { Operation } from "./operation/Operation.js";
+import { Name } from "../global/Name.js";
+import { Paths } from "./Paths.js";
+import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class Path {
+    readonly paths: Paths;
+    readonly name: Name;
+    readonly operations: Operation[];
+    private constructor();
+    static fromDoc(paths: Paths, name: string, operationsDoc: OpenAPIV3.PathItemObject): Path;
+    compileTypes(options: TypeCompilationOptions): Promise<string>;
+}

package/dist/types/generation/model/paths/Paths.d.ts

@@ -0,0 +1,25 @@
+import { Name } from "../global/Name.js";
+import { CodeGenerationModel, TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { Path } from "./Path.js";
+import { Operation } from "./operation/Operation.js";
+import { Tag } from "../tags/Tag.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class Paths {
+    static readonly ns = "Paths";
+    readonly paths: Path[];
+    readonly model: CodeGenerationModel;
+    readonly name: Name;
+    constructor(model: CodeGenerationModel, paths: OpenAPIV3.PathsObject);
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+    compileOperationTypes(): Promise<string>;
+    compileDescriptors(): string;
+    getFlattenedOperations(httpMethod?: string): Operation[];
+    getGroupedOperationsByTag(httpMethod?: string): Array<[Tag, Operation[]]>;
+    private compileClientMethodsOfTag;
+    compileClient(): string;
+    private compileReactClientApiName;
+    private compileReactClientApiBuilderOfTag;
+    private compileReactClientPropertyInitializer;
+    private compileReactClientProperties;
+    compileReactClient(): string;
+}

package/dist/types/generation/model/paths/operation/Operation.d.ts

@@ -0,0 +1,24 @@
+import { RequestParameters } from "./RequestParameters.js";
+import { Path } from "../Path.js";
+import { Name } from "../../global/Name.js";
+import { Responses } from "./responses/Responses.js";
+import { Tag } from "../../tags/Tag.js";
+import { TypeCompilationOptions } from "../../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class Operation {
+    readonly path: Path;
+    readonly id: Name;
+    readonly httpMethod: Name;
+    readonly parameters: RequestParameters;
+    readonly responses: Responses;
+    readonly summary?: string;
+    readonly tags: Tag[];
+    private constructor();
+    static fromDoc(path: Path, httpMethod: string, doc: OpenAPIV3.OperationObject): Operation;
+    compileTypes(options: TypeCompilationOptions): Promise<string>;
+    compileDescriptor(): string;
+    compileRequestResponseTypes(): string;
+    private getMethodName;
+    compileClientMethod(tag: Tag): string;
+    compileReactClientMethod(tag: Tag): string;
+}

package/dist/types/generation/model/paths/operation/RequestParameters.d.ts

@@ -0,0 +1,17 @@
+import { JSONSchema } from "../../global/JSONSchema.js";
+import { Operation } from "./Operation.js";
+import { TypeCompilationOptions } from "../../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+export declare class RequestParameters {
+    static readonly ns = "Parameters";
+    readonly path?: JSONSchema;
+    readonly query?: JSONSchema;
+    readonly header?: JSONSchema;
+    readonly body?: JSONSchema;
+    readonly operation: Operation;
+    private constructor();
+    private static constructParametersSchema;
+    static fromDoc(operation: Operation, doc: OpenAPIV3.OperationObject): RequestParameters;
+    compileTypes(opts: TypeCompilationOptions): Promise<string>;
+    compileDescriptorRequestType(): string;
+}

package/dist/types/generation/model/paths/operation/responses/Response.d.ts

@@ -0,0 +1,16 @@
+import { Name } from "../../../global/Name.js";
+import { ResponseContentTypes } from "./ResponseContentTypes.js";
+import { Responses } from "./Responses.js";
+import { TypeCompilationOptions } from "../../../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
+import { ValueOf } from "type-fest";
+type DocType = ValueOf<OpenAPIV3.ResponsesObject>;
+export declare class Response {
+    readonly responses: Responses;
+    readonly contentTypes: ResponseContentTypes;
+    readonly httpStatus: Name;
+    private constructor();
+    static fromDoc(responses: Responses, httpStatus: Name, doc: DocType): Response;
+    compileContentTypes(opts: TypeCompilationOptions): Promise<string>;
+}
+export {};

package/dist/types/generation/model/paths/operation/responses/ResponseContent.d.ts

@@ -0,0 +1,12 @@
+import { JSONSchema as JSONSchemaType } from "json-schema-to-typescript";
+import { JSONSchema } from "../../../global/JSONSchema.js";
+import { Name } from "../../../global/Name.js";
+import { ResponseContentTypes } from "./ResponseContentTypes.js";
+export declare class ResponseContent {
+    readonly mediaType: Name;
+    readonly schema: JSONSchema;
+    readonly contentTypes: ResponseContentTypes;
+    constructor(contentTypes: ResponseContentTypes, mediaType: string, schema?: JSONSchemaType);
+    static buildEmpty(contentTypes: ResponseContentTypes): ResponseContent;
+    compileDescriptorsResponseContentType(): string;
+}