@himenon/openapi-typescript-code-generator/dist/api.d.ts

OpenAPI Code Generator using TypeScript AST.

import ts from 'typescript';
import { i as index$4, O as Options, C as ConverterContext } from './ConverterContext-BojqruZC.js';
import { I as IntermediateCode, D as Document, P as Params, O as OpenApi } from './CodeGenerator-BT1x2VUP.js';
import { L as Logger } from './Validator-BDeib3uY.js';
import 'json-schema';

type CreateFunction = (context: Pick<ts.TransformationContext, "factory">) => ts.Statement[];

declare const stringToStatements: (code: string) => ts.Statement[];
declare const convertIntermediateCodes: (intermediateCodes: IntermediateCode[]) => ts.Statement[];

declare const utils_convertIntermediateCodes: typeof convertIntermediateCodes;
declare const utils_stringToStatements: typeof stringToStatements;
declare namespace utils {
  export { utils_convertIntermediateCodes as convertIntermediateCodes, utils_stringToStatements as stringToStatements };
}

type TransformerFactory<T extends ts.Node> = ts.TransformerFactory<T>;
declare const convertAstToTypeScriptCode: (sourceFile: ts.SourceFile) => string;
declare const generate: (createFunction: CreateFunction) => string;

type index$3_CreateFunction = CreateFunction;
type index$3_TransformerFactory<T extends ts.Node> = TransformerFactory<T>;
declare const index$3_convertAstToTypeScriptCode: typeof convertAstToTypeScriptCode;
declare const index$3_generate: typeof generate;
declare namespace index$3 {
  export { type index$3_CreateFunction as CreateFunction, index$4 as Factory, type index$3_TransformerFactory as TransformerFactory, utils as Utils, index$3_convertAstToTypeScriptCode as convertAstToTypeScriptCode, index$3_generate as generate };
}

declare const generateLeading: (schema: Document) => string;

declare const Comment_generateLeading: typeof generateLeading;
declare namespace Comment {
  export { Comment_generateLeading as generateLeading };
}

declare class Parser {
    private entryPoint;
    private readonly rootSchema;
    private currentPoint;
    private convertContext;
    private store;
    private factory;
    constructor(entryPoint: string, rootSchema: Document, noReferenceOpenApiSchema: Document, convertOption?: Options);
    private initialize;
    getCodeGeneratorParamsArray(allowOperationIds?: string[]): Params[];
    getOpenApiTypeDefinitionStatements(): ts.Statement[];
    getAdditionalTypeStatements(): ts.Statement[];
}

declare const index$2_Comment: typeof Comment;
type index$2_Parser = Parser;
declare const index$2_Parser: typeof Parser;
declare namespace index$2 {
  export { index$2_Comment as Comment, ConverterContext as ConvertContext, index$2_Parser as Parser };
}

declare class FileSystem {
    private static FRAGMENT;
    private static internalLoadJsonOrYaml;
    static existSync(entryPoint: string): boolean;
    static loadJsonOrYaml(entryPoint: string): any;
}

type ObjectLike = {
    [key: string]: any;
};
declare const resolve: (entryPoint: string, currentPoint: string, rootSchema: Document) => Document;

type index$1_ObjectLike = ObjectLike;
declare const index$1_OpenApi: typeof OpenApi;
declare const index$1_resolve: typeof resolve;
declare namespace index$1 {
  export { type index$1_ObjectLike as ObjectLike, index$1_OpenApi as OpenApi, index$1_resolve as resolve };
}

declare const validate: (openapiDoc: Document, logger?: Logger) => void;

declare const index_validate: typeof validate;
declare namespace index {
  export { index_validate as validate };
}

export { FileSystem, index$2 as OpenApiTools, index$1 as ResolveReference, index$3 as TsGenerator, index as Validator };