@povio/openapi-codegen-cli 0.3.8 → 0.4.0

package/README.md

@@ -20,21 +20,32 @@ yarn openapi-codegen generate --input http://localhost:3001/docs-json
 
 ## Options
 
-### Generate command
+### Generate command (generates Zod schemas, API definitions and React queries)
 
 ```sh
-  --input <path>                      Path/url to OpenAPI/Swagger document as json/yaml
-  --output <path>                     Output path (default: 'output')
+  --input                             Path/url to OpenAPI/Swagger document as json/yaml
+  --output                            Output path (default: 'output')
   --includeNamespaces                 Include namespaces inside generated files (default: true)
   --splitByTags                       Split output into directories based on tags in OpenAPI operations (default: true)
   --defaultTag                        Default tag name for code shared accross multiple tags (default: 'Common')
   --excludeTags                       Comma separated list of tags excluded from the output
+  --extractEnums                      Enums are extracted as seperate Zod schemas (default: true)
   --removeOperationPrefixEndingWith   Removes prefix that ends with value from operation names (default: 'Controller_')
   --importPath                        Import path (default: 'ts', possible: 'ts' | 'relative' | 'absolute')
   --prettier                          Run prettier command on output after code generation (default: true)
   --verbose                           Show log messages during execution
 ```
 
+### Check command (checks if OpenAPI spec is compliant)
+
+```sh
+  --input                             Path/url to OpenAPI/Swagger document as json/yaml
+  --splitByTags                       Split output into directories based on tags in OpenAPI operations (default: true)
+  --defaultTag                        Default tag name for code shared accross multiple tags (default: 'Common')
+  --excludeTags                       Comma separated list of tags excluded from the output
+  --verbose                           Show log messages during execution
+```
+
 ## Development
 
 ### Test locally

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

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

package/dist/commands/check.d.ts

@@ -0,0 +1,6 @@
+import { GenerateOptions } from "src/generators/types/options";
+export type CheckParams = {
+    excludeTags: string;
+    verbose: boolean;
+} & Pick<GenerateOptions, "input" | "splitByTags" | "defaultTag">;
+export declare function check({ input, excludeTags, verbose, ...params }: CheckParams): Promise<void>;

package/dist/commands/generate.d.ts

@@ -1,8 +1,7 @@
 import { GenerateOptions } from "src/generators/types/options";
 export type GenerateParams = {
-    input: string;
     excludeTags: string;
     prettier: boolean;
     verbose: boolean;
-} & Pick<GenerateOptions, "output" | "includeNamespaces" | "splitByTags" | "defaultTag" | "removeOperationPrefixEndingWith" | "importPath">;
+} & Pick<GenerateOptions, "input" | "output" | "includeNamespaces" | "splitByTags" | "defaultTag" | "removeOperationPrefixEndingWith" | "importPath" | "extractEnums">;
 export declare function generate({ input, excludeTags, prettier, verbose, ...params }: GenerateParams): Promise<void>;

package/dist/generators/checkOpenAPIDoc.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "./types/options";
+export declare function checkOpenAPIDoc(openApiDoc: OpenAPIV3.Document, cliOptions?: Partial<GenerateOptions>): import("./types/validation").ValidationError[];

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

@@ -0,0 +1,2 @@
+import { ValidationErrorType } from "../types/validation";
+export declare const VALIDATION_ERROR_TYPE_TITLE: Record<ValidationErrorType, string>;

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

@@ -1,5 +1,6 @@
 import { Import } from "../types/generate";
 export declare const SCHEMA_SUFFIX = "Schema";
+export declare const ENUM_SUFFIX = "Enum";
 export declare const BODY_SCHEMA_SUFFIX = "Body";
 export declare const PARAM_SCHEMA_SUFFIX = "Param";
 export declare const RESPONSE_SCHEMA_SUFFIX = "Response";

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

@@ -1,18 +1,40 @@
 import { OpenAPIV3 } from "openapi-types";
 import { GenerateOptions } from "../types/options";
-import { getOpenAPISchemaDependencyGraph } from "./openapi/getOpenAPISchemaDependencyGraph";
+import { ValidationError } from "../types/validation";
+import { DependencyGraph } from "./openapi/getOpenAPISchemaDependencyGraph";
 import { ZodSchema } from "./zod/ZodSchema.class";
+interface SchemaData {
+    ref: string;
+    name: string;
+    zodSchemaName: string;
+    tags: string[];
+}
+export interface EnumZodSchemaData {
+    code: string;
+    zodSchemaName?: string;
+    tag?: string;
+    meta: {
+        zodSchemaNameSegments: string[][];
+        tags: string[];
+        schemaRefs: string[];
+    };
+}
 export declare class SchemaResolver {
-    private openApiDoc;
-    private options;
-    private schemaData;
-    private zodSchemaData;
-    private compositeZodSchemaData;
-    readonly dependencyGraph: ReturnType<typeof getOpenAPISchemaDependencyGraph>;
+    readonly openApiDoc: OpenAPIV3.Document;
+    readonly options: GenerateOptions;
+    private readonly schemaData;
+    private readonly zodSchemaData;
+    private readonly compositeZodSchemaData;
+    readonly enumZodSchemaData: EnumZodSchemaData[];
+    readonly dependencyGraph: DependencyGraph;
+    readonly operationsByTag: Record<string, OpenAPIV3.OperationObject[]>;
+    readonly operationNames: string[];
+    readonly validationErrors: ValidationError[];
     private get docSchemas();
     private get schemaRefs();
     constructor(openApiDoc: OpenAPIV3.Document, options: GenerateOptions);
     getSchemaByRef(ref: string): OpenAPIV3.SchemaObject;
+    getSchemaDataByRef(ref: string): SchemaData | undefined;
     getZodSchemaNameByRef(ref: string): string;
     getRefByZodSchemaName(zodSchemaName: string): string | undefined;
     getTagByZodSchemaName(zodSchemaName: string): string;
@@ -22,10 +44,12 @@ export declare class SchemaResolver {
     addZodSchemaForCompositeCode(code: string, zodSchema: ZodSchema, zodSchemaName: string, schema?: OpenAPIV3.SchemaObject): void;
     getCompositeZodSchemaByZodSchemaName(zodSchemaName: string): ZodSchema | undefined;
     getSchemaByCompositeZodSchemaName(compositeZodSchemaName: string): OpenAPIV3.SchemaObject | undefined;
+    getEnumZodSchemaDataByCode(code: string): EnumZodSchemaData | undefined;
+    getEnumZodSchemaNamesReferencedBySchemaRef(schemaRef: string): string[];
     getZodSchemas(): {};
+    getEnumZodSchemas(): {};
     resolveObject<T>(obj: OpenAPIV3.ReferenceObject | T): T;
     isSchemaCircular(ref: string): boolean;
-    private intializeSchemaInfo;
-    private initializeSchemaTags;
-    private getOperationSchemaRefs;
+    private initialize;
 }
+export {};

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

@@ -1,14 +1,12 @@
 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, isUniqueOperationName, tag, options, }: {
+export declare function getEndpointBody({ resolver, operation, operationName, isUniqueOperationName, tag, }: {
     resolver: SchemaResolver;
     operation: OpenAPIV3.OperationObject;
     operationName: string;
     isUniqueOperationName: boolean;
     tag: string;
-    options: GenerateOptions;
 }): {
     endpointParameter: EndpointParameter;
     requestFormat: string;

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

@@ -1,12 +1,10 @@
 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, isUniqueOperationName, tag, options, }: {
+export declare function getEndpointParameter({ resolver, param, operationName, isUniqueOperationName, tag, }: {
     resolver: SchemaResolver;
     param: OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject;
     operationName: string;
     isUniqueOperationName: boolean;
     tag: string;
-    options: GenerateOptions;
 }): EndpointParameter | undefined;

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

@@ -1,9 +1,3 @@
-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[];
+export declare function getEndpointsFromOpenAPIDoc(resolver: SchemaResolver): Endpoint[];

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

@@ -2,10 +2,7 @@ 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;
-}): {
+export declare function getDataFromOpenAPIDoc(openApiDoc: OpenAPIV3.Document, options: GenerateOptions): {
     resolver: SchemaResolver;
     data: GenerateData;
 };

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

@@ -1,7 +1,4 @@
 import { OpenAPIV3 } from "openapi-types";
 import { GenerateMetadata } from "../types/metadata";
 import { GenerateOptions } from "../types/options";
-export declare function getMetadataFromOpenAPIDoc({ openApiDoc, options, }: {
-    openApiDoc: OpenAPIV3.Document;
-    options: GenerateOptions;
-}): Promise<GenerateMetadata>;
+export declare function getMetadataFromOpenAPIDoc(openApiDoc: OpenAPIV3.Document, options: GenerateOptions): Promise<GenerateMetadata>;

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

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

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

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

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

@@ -0,0 +1,4 @@
+import { OpenAPIV3 } from "openapi-types";
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function getSchemaRefObjs(resolver: SchemaResolver, schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined, schemaInfo: string): OpenAPIV3.ReferenceObject[];
+export declare function getDeepSchemaRefObjs(resolver: SchemaResolver, schemaRefs: OpenAPIV3.ReferenceObject[]): string[];

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

@@ -0,0 +1,22 @@
+import { OpenAPIV3 } from "openapi-types";
+export type OnSchemaCallbackData<TData> = {
+    data?: TData;
+} & ({
+    type: "reference";
+    schema: OpenAPIV3.ReferenceObject;
+} | {
+    type: "property" | "additionalProperty";
+    parentSchema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    propertyName: string;
+} | {
+    type: "composite" | "array";
+    parentSchema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+});
+type OnSchemaCallbackType<TData> = (data: OnSchemaCallbackData<TData>) => any;
+export declare function iterateSchema<TData>(schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined, options: {
+    data?: TData;
+    onSchema: OnSchemaCallbackType<TData>;
+}): void;
+export {};

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

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

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

@@ -1,17 +1,16 @@
 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;
+    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 declare function getZodSchema({ schema, resolver, meta: inheritedMeta, tag }: GetZodSchemaParams): ZodSchema;
+export declare function getEnumZodSchemaCode(schema: OpenAPIV3.SchemaObject): string;
 export {};

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

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

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

@@ -1,8 +1,2 @@
-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>;
+export declare function getZodSchemasFromOpenAPIDoc(resolver: SchemaResolver): Record<string, string>;

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { OpenAPIV3 } from "openapi-types";
+import { SchemaResolver } from "../SchemaResolver.class";
+export declare function updateEnumZodSchemaData({ schema, nameSegments, includeSelf, ...params }: {
+    resolver: SchemaResolver;
+    schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined;
+    schemaRef?: string;
+    schemaInfo?: string;
+    tags: string[];
+    nameSegments?: string[];
+    includeSelf?: boolean;
+}): void;
+export declare function resolveEnumZodSchemaNames(resolver: SchemaResolver): void;
+export declare function resolveEnumZodSchemaTags(resolver: SchemaResolver): void;

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

@@ -1,7 +1,2 @@
-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>;
+export declare function wrapCircularZodSchemas(resolver: SchemaResolver, zodSchemas: Record<string, string>): Record<string, string>;

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

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

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

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

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

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

package/dist/generators/generateCodeFromOpenAPIDoc.d.ts

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

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

@@ -0,0 +1 @@
+export declare const getUniqueArray: <T>(...arrs: T[][]) => T[];

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

@@ -1,4 +1,8 @@
 export declare function readHbsTemplateSync(fileName: string): string;
+export declare function getFileName({ output, fileName }: {
+    output: string;
+    fileName: string;
+}): string;
 export declare function writeTsFileSync({ output, fileName, data }: {
     output: string;
     fileName: string;

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

@@ -6,11 +6,7 @@ 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;
-}): {
+export declare function mapEndpointParamsToFunctionParams(resolver: SchemaResolver, endpoint: Endpoint): {
     name: string;
     type: string;
     paramType: "Query" | "Body" | "Header" | "Path";

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

@@ -2,12 +2,11 @@ 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, }: {
+export declare function getModelsImports({ resolver, tag, zodSchemas, zodSchemasAsTypes, }: {
     resolver: SchemaResolver;
     tag: string;
     zodSchemas?: string[];
     zodSchemasAsTypes?: string[];
-    options: GenerateOptions;
 }): Import[];
 export declare function getEndpointsImports({ tag, endpoints, options, }: {
     tag: string;

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

@@ -1,13 +1,5 @@
 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;
+export declare const getImportedZodSchemaName: (resolver: SchemaResolver, zodSchemaName: string) => string;
+export declare const getImportedZodSchemaInferedTypeName: (resolver: SchemaResolver, zodSchemaName: string) => string;

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

@@ -1,8 +1,3 @@
 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 getHbsTemplateDelegate(resolver: SchemaResolver, templateName: string): HandlebarsTemplateDelegate<any>;
 export declare function getHbsPartialTemplateDelegate(templateName: string): HandlebarsTemplateDelegate<any>;

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

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

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

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

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

@@ -24,16 +24,14 @@ export declare function getOperationName({ path, method, operation, options, kee
     options: GenerateOptions;
     keepOperationPrefixWithoutEnding?: boolean;
 }): string;
-export declare function getUniqueOperationName({ path, method, operation, openApiDoc, options, }: {
+export declare function getUniqueOperationName({ path, method, operation, operationsByTag, options, }: {
     path: string;
     method: string;
     operation: OpenAPIV3.OperationObject;
-    openApiDoc: OpenAPIV3.Document;
+    operationsByTag: Record<string, OpenAPIV3.OperationObject[]>;
     options: GenerateOptions;
 }): string;
-export declare function isUniqueOperationNameWithoutSplitByTags(operationName: string, openApiDoc: OpenAPIV3.Document, options: GenerateOptions): boolean;
-export declare function formatTag(tag: string): string;
-export declare function getOperationTag(operation: OpenAPIV3.OperationObject, options: GenerateOptions): string;
+export declare function getUniqueOperationNamesWithoutSplitByTags(openApiDoc: OpenAPIV3.Document, operationsByTag: Record<string, OpenAPIV3.OperationObject[]>, options: GenerateOptions): string[];
 /** @example turns `/media-objects/{id}` into `MediaObjectsById` */
 export declare function pathToVariableName(path: string): string;
 export declare function replaceHyphenatedPath(path: string): string;

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

@@ -5,3 +5,7 @@ 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;
+export declare const getLongestMostCommon: (strs: string[]) => string | undefined;
+export declare const getMostCommonAdjacentCombinationSplit: (strs: string[]) => string | undefined;
+export declare const splitByUppercase: (str: string) => string[];
+export declare const getAdjacentStringCombinations: (strs: string[], ignoreStrs?: string[]) => string[];

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

@@ -0,0 +1,20 @@
+import { OpenAPIV3 } from "openapi-types";
+import { GenerateOptions } from "../types/options";
+export declare function formatTag(tag: string): string;
+export declare function getOperationTag(operation: OpenAPIV3.OperationObject, options: GenerateOptions): string;
+export declare function getOperationsByTag(openApiDoc: OpenAPIV3.Document, options: GenerateOptions): Record<string, {
+    tags?: string[] | undefined;
+    summary?: string | undefined;
+    description?: string | undefined;
+    externalDocs?: OpenAPIV3.ExternalDocumentationObject | undefined;
+    operationId?: string | undefined;
+    parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[] | undefined;
+    requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject | undefined;
+    responses: OpenAPIV3.ResponsesObject;
+    callbacks?: {
+        [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
+    } | undefined;
+    deprecated?: boolean | undefined;
+    security?: OpenAPIV3.SecurityRequirementObject[] | undefined;
+    servers?: OpenAPIV3.ServerObject[] | undefined;
+}[]>;

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

@@ -2,18 +2,15 @@ import { OpenAPIV3 } from "openapi-types";
 import { SchemaResolver } from "../core/SchemaResolver.class";
 import { TsMetaType, TsTypeBase } from "../types/metadata";
 import { PrimitiveType } from "../types/openapi";
-import { GenerateOptions } from "../types/options";
 export declare function primitiveTypeToTsType(type: PrimitiveType): string;
-export declare function getTsTypeBase({ zodSchemaName, schema, resolver, options, }: {
+export declare function getTsTypeBase({ zodSchemaName, schema, resolver, }: {
     zodSchemaName?: string;
     schema?: OpenAPIV3.SchemaObject;
     resolver: SchemaResolver;
-    options: GenerateOptions;
 }): TsTypeBase;
-export declare function getSchemaTsMetaType({ schema, isCircular, parentTypes, resolver, options, }: {
+export declare function getSchemaTsMetaType({ schema, isCircular, parentTypes, resolver, }: {
     schema?: OpenAPIV3.SchemaObject;
     isCircular?: boolean;
     parentTypes: TsTypeBase[];
     resolver: SchemaResolver;
-    options: GenerateOptions;
 }): TsMetaType;

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

@@ -0,0 +1,7 @@
+import { EndpointParameter } from "../types/endpoint";
+import { ValidationError, ValidationErrorType } from "../types/validation";
+export declare function getInvalidSchemaError(schemaInfo: string): ValidationError;
+export declare function getInvalidOperationIdError(operationId: string): ValidationError;
+export declare function getMissingPathParameterError(params: EndpointParameter[], path: string): ValidationError;
+export declare function getNotAllowedInlineEnumError(info: string): ValidationError;
+export declare function groupByType(validationErrors: ValidationError[]): Record<ValidationErrorType, string[]>;

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

@@ -1,7 +1,14 @@
 export declare const getZodSchemaName: (name: string, schemaSuffix: string) => string;
+export declare const getEnumZodSchemaName: (name: string, enumSuffix: string, schemaSuffix: string) => string;
 export declare const isNamedZodSchema: (schema: string) => boolean;
 export declare const getZodSchemaOperationName: (operationName: string, isUniqueOperationName: boolean, tag: string) => string;
 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;
+export declare function getResponseZodSchemaName({ statusCode, operationName, isUniqueOperationName, tag, }: {
+    statusCode: string;
+    operationName: string;
+    isUniqueOperationName: boolean;
+    tag: string;
+}): string;