@povio/openapi-codegen-cli 0.0.10 → 0.0.12

package/dist/commands/generate.command.d.ts

@@ -0,0 +1,2 @@
+import yargs from "yargs";
+export declare const command: yargs.CommandModule;

package/dist/commands/generate.d.ts

@@ -0,0 +1,11 @@
+export type GenerateParams = {
+    input: string;
+    output: string;
+    includeNamespaces: boolean;
+    splitByTags: boolean;
+    defaultTag: string;
+    excludeTags: string;
+    prettier: boolean;
+    verbose: boolean;
+};
+export declare function generate({ input, output, includeNamespaces, splitByTags, defaultTag, excludeTags, prettier, verbose, }: GenerateParams): Promise<void>;

package/dist/generators/const/endpoints.const.d.ts

@@ -0,0 +1,7 @@
+import { Import } from "../types/generate";
+export declare const DEFAULT_HEADERS: {
+    "Content-Type": string;
+    Accept: string;
+};
+export declare const REST_CLIENT_NAME = "AppRestClient";
+export declare const REST_CLIENT_IMPORT: Import;

package/dist/generators/const/openapi.const.d.ts

@@ -0,0 +1,6 @@
+import { OpenAPIV3 } from "openapi-types";
+export declare const COMPLEXITY_THRESHOLD = 2;
+export declare const ALLOWED_PARAM_MEDIA_TYPES: string[];
+export declare const ALLOWED_PATH_IN: string[];
+export declare const ALLOWED_METHODS: OpenAPIV3.HttpMethods[];
+export declare const PRIMITIVE_TYPE_LIST: string[];

package/dist/generators/const/options.const.d.ts

@@ -0,0 +1,2 @@
+import { GenerateOptions } from "../types/options";
+export declare const DEFAULT_GENERATE_OPTIONS: GenerateOptions;

package/dist/generators/const/query.const.d.ts

@@ -0,0 +1,6 @@
+import { Import } from "../types/generate";
+export declare const QUERY_HOOKS: {
+    query: string;
+    mutation: string;
+};
+export declare const QUERY_IMPORT: Import;

package/dist/generators/const/zod.const.d.ts

@@ -0,0 +1,8 @@
+import { Import } from "../types/generate";
+export declare const SCHEMA_SUFFIX = "Schema";
+export declare const BODY_SCHEMA_SUFFIX = "Body";
+export declare const PARAM_SCHEMA_SUFFIX = "Param";
+export declare const RESPONSE_SCHEMA_SUFFIX = "Response";
+export declare const ERROR_RESPONSE_SCHEMA_SUFFIX = "ErrorResponse";
+export declare const VOID_SCHEMA = "z.void()";
+export declare const ZOD_IMPORT: Import;

package/dist/generators/core/SchemaResolver.class.d.ts

@@ -0,0 +1,27 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "../types/options";
+import { getOpenAPISchemaDependencyGraph } from "./openapi/getOpenAPISchemaDependencyGraph";
+import { ZodSchema } from "./zod/ZodSchema.class";
+export declare class SchemaResolver {
+    private openApiDoc;
+    private options;
+    private schemaData;
+    private zodSchemaData;
+    private discriminatorZodSchemaData;
+    readonly dependencyGraph: ReturnType<typeof getOpenAPISchemaDependencyGraph>;
+    private get docSchemas();
+    private get schemaRefs();
+    constructor(openApiDoc: OpenAPIV3.Document, options: GenerateOptions);
+    getSchemaByRef(ref: string): OpenAPIV3.SchemaObject;
+    getZodSchemaNameByRef(ref: string): string;
+    getRefByZodSchemaName(zodSchemaName: string): string | undefined;
+    getTagByZodSchemaName(zodSchemaName: string): string;
+    getCodeByZodSchemaName(name: string): string | undefined;
+    getZodSchemaNamesByDiscriminatorCode(code: string): string[] | undefined;
+    setZodSchema(name: string, code: string, tag: string): void;
+    addZodSchemaForDiscriminatorCode(code: string, zodSchema: ZodSchema, zodSchemaName: string): void;
+    getDiscriminatorZodSchemaByZodSchemaName(zodSchemaName: string): ZodSchema | undefined;
+    getZodSchemas(): {};
+    private intializeSchemaInfo;
+    private initializeSchemaTags;
+}

package/dist/generators/core/endpoints/getEndpointBody.d.ts

@@ -0,0 +1,14 @@
+import { OpenAPIV3 } from "openapi-types";
+import { EndpointParameter } from "src/generators/types/endpoint";
+import { GenerateOptions } from "src/generators/types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function getEndpointBody({ resolver, operation, operationName, tag, options, }: {
+    resolver: SchemaResolver;
+    operation: OpenAPIV3.OperationObject;
+    operationName: string;
+    tag: string;
+    options: GenerateOptions;
+}): {
+    endpointParameter: EndpointParameter;
+    requestFormat: string;
+} | undefined;

package/dist/generators/core/endpoints/getEndpointParameter.d.ts

@@ -0,0 +1,11 @@
+import { OpenAPIV3 } from "openapi-types";
+import { EndpointParameter } from "src/generators/types/endpoint";
+import { GenerateOptions } from "src/generators/types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function getEndpointParameter({ resolver, param, operationName, tag, options, }: {
+    resolver: SchemaResolver;
+    param: OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject;
+    operationName: string;
+    tag: string;
+    options: GenerateOptions;
+}): EndpointParameter | undefined;

package/dist/generators/core/endpoints/getEndpointsFromOpenAPIDoc.d.ts

@@ -0,0 +1,9 @@
+import { OpenAPIV3 } from "openapi-types";
+import { Endpoint } from "../../types/endpoint";
+import { GenerateOptions } from "../../types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function getEndpointsFromOpenAPIDoc({ openApiDoc, resolver, options, }: {
+    openApiDoc: OpenAPIV3.Document;
+    resolver: SchemaResolver;
+    options: GenerateOptions;
+}): Endpoint[];

package/dist/generators/core/getDataFromOpenAPIDoc.d.ts

@@ -0,0 +1,11 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateData } from "../types/generate";
+import { GenerateOptions } from "../types/options";
+import { SchemaResolver } from "./SchemaResolver.class";
+export declare function getDataFromOpenAPIDoc({ openApiDoc, options, }: {
+    openApiDoc: OpenAPIV3.Document;
+    options: GenerateOptions;
+}): {
+    resolver: SchemaResolver;
+    data: GenerateData;
+};

package/dist/generators/core/openapi/getOpenAPISchemaComplexity.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPIV3 } from "openapi-types";
+export declare function getOpenAPISchemaComplexity({ current, schema, }: {
+    current: number;
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined;
+}): number;

package/dist/generators/core/openapi/getOpenAPISchemaDependencyGraph.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPIV3 } from "openapi-types";
+export declare function getOpenAPISchemaDependencyGraph(schemaRef: string[], getSchemaByRef: (ref: string) => OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject): {
+    refsDependencyGraph: Record<string, Set<string>>;
+    deepDependencyGraph: Record<string, Set<string>>;
+};

package/dist/generators/core/openapi/getSchemaRefsDependencyGraph.d.ts

@@ -0,0 +1,11 @@
+import { OpenAPIV3 } from "openapi-types";
+export declare function getSchemaRefsDependencyGraph({ schema, fromRef, getSchemaByRef, visitedRefs, refsDependencyGraph, }: {
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    fromRef: string;
+    getSchemaByRef: (ref: string) => OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    visitedRefs?: Record<string, boolean>;
+    refsDependencyGraph?: Record<string, Set<string>>;
+}): {
+    visitedRefs: Record<string, boolean>;
+    refsDependencyGraph: Record<string, Set<string>>;
+};

package/dist/generators/core/zod/ZodSchema.class.d.ts

@@ -0,0 +1,22 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "src/generators/types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+export type ZodSchemaMetaData = {
+    isRequired?: boolean;
+    name?: string;
+    parent?: ZodSchema;
+    referencedBy?: ZodSchema[];
+};
+export declare class ZodSchema {
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    resolver?: SchemaResolver | undefined;
+    private code?;
+    ref?: string;
+    children: ZodSchema[];
+    meta: ZodSchemaMetaData & Required<Pick<ZodSchemaMetaData, "referencedBy">>;
+    constructor(schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, resolver?: SchemaResolver | undefined, meta?: ZodSchemaMetaData);
+    getCodeString(tag?: string, options?: GenerateOptions): string;
+    get complexity(): number;
+    assign(code: string): this;
+    inherit(parent?: ZodSchema): this;
+}

package/dist/generators/core/zod/getZodChain.d.ts

@@ -0,0 +1,8 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "../../types/options";
+import { ZodSchemaMetaData } from "./ZodSchema.class";
+export declare function getZodChain({ schema, meta, options, }: {
+    schema: OpenAPIV3.SchemaObject;
+    meta?: ZodSchemaMetaData;
+    options: GenerateOptions;
+}): string;

package/dist/generators/core/zod/getZodSchema.d.ts

@@ -0,0 +1,17 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "src/generators/types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+import { ZodSchema, ZodSchemaMetaData } from "./ZodSchema.class";
+type GetZodSchemaParams = {
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    resolver?: SchemaResolver;
+    meta?: ZodSchemaMetaData;
+    tag: string;
+    options: GenerateOptions;
+};
+/**
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#schemaObject
+ * @see https://github.com/colinhacks/zod
+ */
+export declare function getZodSchema({ schema, resolver, meta: inheritedMeta, tag, options }: GetZodSchemaParams): ZodSchema;
+export {};

package/dist/generators/core/zod/getZodSchemaRefs.d.ts

@@ -0,0 +1,5 @@
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function getZodSchemaRefs({ resolver, zodSchemaName }: {
+    resolver: SchemaResolver;
+    zodSchemaName: string;
+}): string[];

package/dist/generators/core/zod/getZodSchemasFromOpenAPIDoc.d.ts

@@ -0,0 +1,8 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "../../types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function getZodSchemasFromOpenAPIDoc({ resolver, openApiDoc, options, }: {
+    resolver: SchemaResolver;
+    openApiDoc: OpenAPIV3.Document;
+    options: GenerateOptions;
+}): Record<string, string>;

package/dist/generators/core/zod/resolveZodSchemaName.d.ts

@@ -0,0 +1,10 @@
+import { GenerateOptions } from "src/generators/types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+import { ZodSchema } from "./ZodSchema.class";
+export declare function resolveZodSchemaName({ zodSchema, fallbackName, resolver, tag, options, }: {
+    zodSchema: ZodSchema;
+    fallbackName?: string;
+    resolver: SchemaResolver;
+    tag: string;
+    options: GenerateOptions;
+}): string;

package/dist/generators/core/zod/sortZodSchemasByTopology.d.ts

@@ -0,0 +1,7 @@
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function sortZodSchemasByTopology({ resolver, zodSchemas, }: {
+    resolver: SchemaResolver;
+    zodSchemas: Record<string, string>;
+}): {
+    [k: string]: string;
+};

package/dist/generators/core/zod/wrapCircularZodSchemas.d.ts

@@ -0,0 +1,7 @@
+import { GenerateOptions } from "../../types/options";
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function wrapCircularZodSchemas({ resolver, zodSchemas, options, }: {
+    resolver: SchemaResolver;
+    zodSchemas: Record<string, string>;
+    options: GenerateOptions;
+}): Record<string, string>;

package/dist/generators/generate/generateEndpoints.d.ts

@@ -0,0 +1,9 @@
+import { SchemaResolver } from "../core/SchemaResolver.class";
+import { GenerateData } from "../types/generate";
+import { GenerateOptions } from "../types/options";
+export declare function generateEndpoints({ resolver, data, tag, options, }: {
+    resolver: SchemaResolver;
+    data: GenerateData;
+    tag?: string;
+    options: GenerateOptions;
+}): string | undefined;

package/dist/generators/generate/generateModels.d.ts

@@ -0,0 +1,9 @@
+import { SchemaResolver } from "../core/SchemaResolver.class";
+import { GenerateData } from "../types/generate";
+import { GenerateOptions } from "../types/options";
+export declare function generateModels({ resolver, data, tag, options, }: {
+    resolver: SchemaResolver;
+    data: GenerateData;
+    tag?: string;
+    options: GenerateOptions;
+}): string | undefined;

package/dist/generators/generate/generateQueries.d.ts

@@ -0,0 +1,9 @@
+import { SchemaResolver } from "../core/SchemaResolver.class";
+import { GenerateData } from "../types/generate";
+import { GenerateOptions } from "../types/options";
+export declare function generateQueries({ resolver, data, tag, options, }: {
+    resolver: SchemaResolver;
+    data: GenerateData;
+    tag?: string;
+    options: GenerateOptions;
+}): string | undefined;

package/dist/generators/generateCodeFromOpenAPIDoc.d.ts

@@ -0,0 +1,6 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "./types/options";
+export declare function generateCodeFromOpenAPIDoc({ openApiDoc, options: cliOptions, }: {
+    openApiDoc: OpenAPIV3.Document;
+    options?: Partial<GenerateOptions>;
+}): void;

package/dist/generators/types/generate.d.ts

@@ -0,0 +1,14 @@
+import { Endpoint } from "./endpoint";
+export type Import = {
+    bindings: string[];
+    from: string;
+};
+export declare enum GenerateType {
+    Models = "models",
+    Endpoints = "endpoints",
+    Queries = "queries"
+}
+export type GenerateData = Map<string, {
+    endpoints: Endpoint[];
+    zodSchemas: Record<string, string>;
+}>;

package/dist/generators/utils/file.utils.d.ts

@@ -0,0 +1,6 @@
+export declare function readHbsTemplateSync(fileName: string): string;
+export declare function writeTsFileSync({ output, fileName, data }: {
+    output: string;
+    fileName: string;
+    data: string;
+}): void;

package/dist/generators/utils/generate/generate.endpoints.utils.d.ts

@@ -0,0 +1,32 @@
+import { OpenAPIV3 } from "openapi-types";
+import { SchemaResolver } from "src/generators/core/SchemaResolver.class";
+import { GenerateOptions } from "src/generators/types/options";
+import { Endpoint } from "../../types/endpoint";
+export declare const getEndpointName: (endpoint: Endpoint) => string;
+export declare function getImportedEndpointName(endpoint: Endpoint, options: GenerateOptions): string;
+export declare const getEndpointPath: (endpoint: Endpoint) => string;
+export declare function getEndpointTag(endpoint: Endpoint, options: GenerateOptions): string;
+export declare function mapEndpointParamsToFunctionParams({ resolver, endpoint, options, }: {
+    resolver: SchemaResolver;
+    endpoint: Endpoint;
+    options: GenerateOptions;
+}): {
+    name: string;
+    type: string;
+    required: boolean;
+}[];
+export declare function getEndpointConfig(endpoint: Endpoint): {
+    headers?: {
+        Accept?: string | undefined;
+        "Content-Type"?: string | undefined;
+    } | undefined;
+    params?: {
+        name: string;
+        value: string;
+        description?: string | undefined;
+        type: "Query" | "Body" | "Header" | "Path";
+        zodSchema: string;
+        parameterObject?: OpenAPIV3.ParameterObject | undefined;
+        bodyObject?: OpenAPIV3.RequestBodyObject | undefined;
+    }[] | undefined;
+};

package/dist/generators/utils/generate/generate.imports.utils.d.ts

@@ -0,0 +1,16 @@
+import { SchemaResolver } from "src/generators/core/SchemaResolver.class";
+import { Endpoint } from "../../types/endpoint";
+import { Import } from "../../types/generate";
+import { GenerateOptions } from "../../types/options";
+export declare function getModelsImports({ resolver, tag, zodSchemas, zodSchemasAsTypes, options, }: {
+    resolver: SchemaResolver;
+    tag: string;
+    zodSchemas?: string[];
+    zodSchemasAsTypes?: string[];
+    options: GenerateOptions;
+}): Import[];
+export declare function getEndpointsImports({ tag, endpoints, options, }: {
+    tag: string;
+    endpoints: Endpoint[];
+    options: GenerateOptions;
+}): Import[];

package/dist/generators/utils/generate/generate.query.utils.d.ts

@@ -0,0 +1,2 @@
+import { Endpoint } from "../../types/endpoint";
+export declare const getQueryName: (endpoint: Endpoint) => string;

package/dist/generators/utils/generate/generate.utils.d.ts

@@ -0,0 +1,13 @@
+import { GenerateType } from "../../types/generate";
+import { GenerateOptions } from "../../types/options";
+export declare function getTagFileName({ type, tag, options, includeTagDir, }: {
+    type: GenerateType;
+    tag: string;
+    includeTagDir?: boolean;
+    options: GenerateOptions;
+}): string;
+export declare const getNamespaceName: ({ type, tag, options, }: {
+    type: GenerateType;
+    tag: string;
+    options: GenerateOptions;
+}) => string;

package/dist/generators/utils/generate/generate.zod.utils.d.ts

@@ -0,0 +1,13 @@
+import { SchemaResolver } from "src/generators/core/SchemaResolver.class";
+import { GenerateOptions } from "src/generators/types/options";
+export declare const getZodSchemaInferedTypeName: (zodSchemaName: string, options: GenerateOptions) => string;
+export declare const getImportedZodSchemaName: ({ resolver, zodSchemaName, options, }: {
+    resolver: SchemaResolver;
+    zodSchemaName: string;
+    options: GenerateOptions;
+}) => string;
+export declare const getImportedZodSchemaInferedTypeName: ({ resolver, zodSchemaName, options, }: {
+    resolver: SchemaResolver;
+    zodSchemaName: string;
+    options: GenerateOptions;
+}) => string;

package/dist/generators/utils/hbs/hbs-template.utils.d.ts

@@ -0,0 +1,8 @@
+import { SchemaResolver } from "src/generators/core/SchemaResolver.class";
+import { GenerateOptions } from "../../types/options";
+export declare function getHbsTemplateDelegate({ resolver, templateName, options, }: {
+    resolver: SchemaResolver;
+    templateName: string;
+    options: GenerateOptions;
+}): HandlebarsTemplateDelegate<any>;
+export declare function getHbsPartialTemplateDelegate(templateName: string): HandlebarsTemplateDelegate<any>;

package/dist/generators/utils/hbs/hbs.common.utils.d.ts

@@ -0,0 +1 @@
+export declare function registerCommonHbsHelpers(): void;

package/dist/generators/utils/hbs/hbs.endpoints.utils.d.ts

@@ -0,0 +1,3 @@
+import { SchemaResolver } from "src/generators/core/SchemaResolver.class";
+import { GenerateOptions } from "../../types/options";
+export declare function registerEndpointsHbsHelpers(resolver: SchemaResolver, options: GenerateOptions): void;

package/dist/generators/utils/hbs/hbs.partials.utils.d.ts

@@ -0,0 +1 @@
+export declare function registerPartialsHbsHelpers(): void;

package/dist/generators/utils/hbs/hbs.query.utils.d.ts

@@ -0,0 +1 @@
+export declare function registerQueryHbsHelpers(): void;

package/dist/generators/utils/hbs/hbs.zod.utils.d.ts

@@ -0,0 +1,3 @@
+import { SchemaResolver } from "src/generators/core/SchemaResolver.class";
+import { GenerateOptions } from "../../types/options";
+export declare function registerZodHbsHelpers(resolver: SchemaResolver, options: GenerateOptions): void;

package/dist/generators/utils/js.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidPropertyName: (str: string) => boolean;
+export declare const invalidVariableNameCharactersToCamel: (str: string) => string;

package/dist/generators/utils/math.utils.d.ts

@@ -0,0 +1 @@
+export declare const sum: (arr: number[]) => number;

package/dist/generators/utils/object.utils.d.ts

@@ -0,0 +1,6 @@
+import { Get } from "type-fest";
+import { HasNestedPath, ObjectLiteral } from "../types/common";
+/** Get a nested property value from a dot-delimited path. */
+export declare function getNested<Path extends string, From extends ObjectLiteral, Return = HasNestedPath<Path> extends 1 ? From[Path] : Get<From, Path>>(obj: From, path: Path): Return;
+/** Pick given properties in object */
+export declare function pick<T extends ObjectLiteral, K extends keyof T>(obj: T, paths: K[]): Pick<T, K>;

package/dist/generators/utils/openapi-schema.utils.d.ts

@@ -0,0 +1,14 @@
+import { OpenAPIV3 } from "openapi-types";
+export declare function isSchemaObject(schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject): schema is OpenAPIV3.SchemaObject;
+export declare function isArraySchemaObject(schema: OpenAPIV3.SchemaObject): schema is OpenAPIV3.ArraySchemaObject;
+export declare function inferRequiredSchema(schema: OpenAPIV3.SchemaObject): {
+    noRequiredOnlyAllof: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+    composedRequiredSchema: {
+        properties: {
+            [propertyName: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+        };
+        type: "object";
+        required: string[];
+    };
+    patchRequiredSchemaInLoop: (prop: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, getSchemaByRef: (ref: string) => OpenAPIV3.SchemaObject) => void;
+};

package/dist/generators/utils/openapi.utils.d.ts

@@ -0,0 +1,26 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ALLOWED_PARAM_MEDIA_TYPES } from "../const/openapi.const";
+import { PrimitiveType, SingleType } from "../types/openapi";
+import { GenerateOptions } from "../types/options";
+export declare const getSchemaRef: (schemaName: string) => string;
+export declare const autocorrectRef: (ref: string) => string;
+export declare const getSchemaNameByRef: (ref: string) => string;
+export declare function isReferenceObject(obj: any): obj is OpenAPIV3.ReferenceObject;
+export declare function normalizeString(text: string): string;
+export declare function wrapWithQuotesIfNeeded(str: string): string;
+export declare function unwrapQuotesIfNeeded(value: string | number): string | number;
+export declare function pathParamToVariableName(name: string): string;
+export declare const isPrimitiveType: (type: SingleType) => type is PrimitiveType;
+export declare function primitiveTypeToTsType(type: PrimitiveType): string;
+export declare function escapeControlCharacters(str: string): string;
+export declare const toBoolean: (value: undefined | string | boolean, defaultValue: boolean) => boolean;
+export declare function isParamMediaTypeAllowed(mediaType: string): mediaType is (typeof ALLOWED_PARAM_MEDIA_TYPES)[number] | `application/${string}json${string}` | `text/${string}`;
+export declare function isMainResponseStatus(status: number): boolean;
+export declare function isErrorStatus(status: number): boolean;
+export declare function isMediaTypeAllowed(mediaType: string): boolean;
+export declare function getOperationName(path: string, method: string, operation: OpenAPIV3.OperationObject): string;
+export declare function formatTag(tag: string): string;
+export declare function getOperationTag(operation: OpenAPIV3.OperationObject, options: GenerateOptions): string;
+/** @example turns `/media-objects/{id}` into `MediaObjectsId` */
+export declare function pathToVariableName(path: string): string;
+export declare function replaceHyphenatedPath(path: string): string;

package/dist/generators/utils/sort.utils.d.ts

@@ -0,0 +1,7 @@
+import { ObjectLiteral } from "../types/common";
+/** @see https://gist.github.com/RubyTuesdayDONO/5006455 */
+export declare function topologicalSort(graph: Record<string, Set<string>>): string[];
+/** Sort object keys using a reference order array, sort keys not in reference order in lasts positions */
+export declare function sortObjKeysFromArray<T extends ObjectLiteral>(obj: T, orderedKeys: Array<keyof T>): {
+    [k: string]: T[keyof T];
+};

package/dist/generators/utils/string.utils.d.ts

@@ -0,0 +1,7 @@
+export declare const capitalize: (str: string) => string;
+export declare const decapitalize: (str: string) => string;
+export declare const kebabToCamel: (str: string) => string;
+export declare const snakeToCamel: (str: string) => string;
+export declare const nonWordCharactersToCamel: (str: string) => string;
+export declare const suffixIfNeeded: (text: string, suffix?: string) => string;
+export declare const removeSuffix: (text: string, suffix: string) => string;

package/dist/generators/utils/zod-schema.utils.d.ts

@@ -0,0 +1,6 @@
+export declare const getZodSchemaName: (name: string, schemaSuffix: string) => string;
+export declare const isNamedZodSchema: (schema: string) => boolean;
+export declare const getBodyZodSchemaName: (operationName: string) => string;
+export declare const getParamZodSchemaName: (operationName: string, paramName: string) => string;
+export declare const getMainResponseZodSchemaName: (operationName: string) => string;
+export declare const getErrorResponseZodSchemaName: (operationName: string, statusCode: string) => string;

package/dist/helpers/chalk.helper.d.ts

@@ -0,0 +1 @@
+export declare const chk: import("chalk").ChalkInstance;

package/dist/helpers/cli.helper.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Print a variable, color it magenta if it's different from the default
+ * @param name
+ * @param value
+ * @param defaultValue
+ */
+export declare function logVariable(name: string, value: any, defaultValue?: string | number): void;
+export declare function logInfo(message: string): void;
+export declare function logVerbose(message: string): void;
+export declare function logNotice(message: string): void;
+export declare function logSuccess(message: string): void;
+export declare function logWarning(message: string): void;
+export declare function logError(error: Error | string, message?: string): void;
+export declare function logBanner(message: string): void;
+/**
+ * Request a ENV variable from the user if not set
+ * @param name
+ * @param value
+ * @param suggested - the value the scripts expects and suggest
+ */
+export declare function promptVar(name: string, value: string, suggested?: string): Promise<string>;
+export declare function confirm(message: string): Promise<boolean>;

package/dist/helpers/version.helper.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Fetch the version from package.json
+ */
+export declare function getVersion(): string | undefined;

package/dist/helpers/yargs.helper.d.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+import type { Options } from "yargs";
+interface IOptionProperties extends Options {
+    envAlias?: string;
+}
+export declare function YargOption(properties: IOptionProperties): (target: object, propertyKey: string) => void;
+export declare function getYargsOption<T>(target: any): Record<keyof T, IOptionProperties>;
+export declare function getBuilder(options: any): (y: any) => Promise<any>;
+export declare function getYargsOptions<T>(target: any): Record<keyof T, Options>;
+export declare function loadYargsConfig<T>(cls: new () => T, _argv: Record<string, unknown>): Promise<T>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { GenerateOptions } from "./generators/types/options";
+export declare function getOpenAPIDocCodegenData({ input, options: genOptions, }: {
+    input: string;
+    options?: Partial<GenerateOptions>;
+}): Promise<{
+    resolver: import("./generators/core/SchemaResolver.class").SchemaResolver;
+    data: import("./generators/types/generate").GenerateData;
+}>;