swaggular 0.3.0 → 0.6.1

package/dist/cli/args.js

@@ -18,6 +18,12 @@ function getParseArgs(argv) {
                 args[k] = true;
             }
             else {
+                // Special handling for --config to allow relative paths
+                if (k === 'config') {
+                    args[k] = next;
+                    i++;
+                    continue;
+                }
                 args[k] = next;
                 i++;
             }

package/dist/cli/variables.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toVariables = toVariables;
+const config_loader_1 = require("../utils/config-loader");
 function toVariables(parsed) {
     const variables = {};
     if (parsed.args.mode) {
@@ -11,11 +12,25 @@ function toVariables(parsed) {
             variables.segmentsToIgnore = parsed.args.segmentsToIgnore.split(',');
         }
     }
+    const configPath = parsed.args.config;
+    const fileConfig = (0, config_loader_1.loadConfig)(configPath);
+    const mergedConfig = { ...fileConfig, ...variables };
     return {
-        input: parsed.args.input || 'swagger.json',
-        output: parsed.args.output || 'results',
+        input: parsed.args.input ||
+            parsed.args.i ||
+            parsed.positional[0] ||
+            mergedConfig.input ||
+            'swagger.json',
+        output: parsed.args.output ||
+            parsed.args.o ||
+            parsed.positional[1] ||
+            mergedConfig.output ||
+            'results',
         noGenerate: parsed.args.noGenerate || false,
-        groupingMode: variables.groupingMode || 'path',
-        segmentsToIgnore: variables.segmentsToIgnore || ['api'],
+        groupingMode: variables.groupingMode || mergedConfig.groupingMode || 'path',
+        segmentsToIgnore: variables.segmentsToIgnore || mergedConfig.segmentsToIgnore || ['api'],
+        // Pass entire config if needed for templates
+        templates: mergedConfig.templates,
+        types: mergedConfig.types,
     };
 }

package/dist/core/data/types-data.js

@@ -0,0 +1 @@
+"use strict";

package/dist/core/state/interface-state.d.ts

@@ -7,12 +7,15 @@ export interface InterfaceStateI {
 declare class InterfaceState implements InterfaceStateI {
     generatedInterfaces: Record<string, InterfaceData>;
     generatedEnums: Record<string, InterfaceData>;
+    typeMappings: Record<string, string>;
     componentsSchemas: Record<string, IJsonSchema>;
     constructor();
     setComponentsSchemas(componentsSchemas: Record<string, IJsonSchema>): void;
     getComponentsSchema(name: string): IJsonSchema | undefined;
     addInterfaces(interfacesData: InterfaceData[]): void;
     getInterface(name: string): InterfaceData | undefined;
+    addTypeMapping(original: string, mapped: string): void;
+    getTypeMapping(original: string): string | undefined;
 }
 export declare const interfaceState: InterfaceState;
 export {};

package/dist/core/state/interface-state.js

@@ -4,6 +4,7 @@ exports.interfaceState = void 0;
 class InterfaceState {
     generatedInterfaces = {};
     generatedEnums = {};
+    typeMappings = {};
     componentsSchemas = {};
     constructor() { }
     setComponentsSchemas(componentsSchemas) {
@@ -20,5 +21,11 @@ class InterfaceState {
     getInterface(name) {
         return this.generatedInterfaces[name] || this.generatedEnums[name];
     }
+    addTypeMapping(original, mapped) {
+        this.typeMappings[original] = mapped;
+    }
+    getTypeMapping(original) {
+        return this.typeMappings[original];
+    }
 }
 exports.interfaceState = new InterfaceState();

package/dist/core/state/swagger-state.d.ts

@@ -8,6 +8,7 @@ export declare class SwaggerState {
     setPathsGroupedByScope(pathsGroupedByScope: GroupedPaths): void;
     getPaths(): OpenAPIV3.PathsObject | undefined;
     getSchemas(): Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject> | undefined;
+    getParameters(): Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject> | undefined;
     getPathsGroupedByScope(): GroupedPaths | undefined;
     getGroupByPath(path: string): import("../../types/grouped-paths").GroupedPath | undefined;
 }

package/dist/core/state/swagger-state.js

@@ -19,6 +19,9 @@ class SwaggerState {
     getSchemas() {
         return this.swagger?.components?.schemas;
     }
+    getParameters() {
+        return this.swagger?.components?.parameters;
+    }
     getPathsGroupedByScope() {
         return this.pathsGroupedByScope;
     }

package/dist/index.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const swagger_parser_1 = require("./parsers/swagger-parser");
+const location_factory_1 = require("./utils/location-factory");
 const generate_interface_1 = require("./renderers/generate-interface");
 const generate_service_1 = require("./renderers/generate-service");
 const args_1 = require("./cli/args");
@@ -18,10 +19,11 @@ async function main() {
             segmentsToIgnore: variables.segmentsToIgnore,
             ignoreVariables: true,
         });
-        (0, generate_interface_1.generateInterfaces)();
+        const locations = (0, location_factory_1.computeLocations)();
+        (0, generate_interface_1.generateInterfaces)(variables);
         (0, generate_service_1.generateServices)();
-        const interfaceFiles = (0, generate_interface_1.generateInterfacesFiles)();
-        const serviceFiles = (0, generate_service_1.generateServiceFiles)();
+        const interfaceFiles = (0, generate_interface_1.generateInterfacesFiles)(locations, variables);
+        const serviceFiles = (0, generate_service_1.generateServiceFiles)(locations, variables.templates);
         if (variables.noGenerate) {
             console.log('Files not generated');
             return;

package/dist/renderers/generate-comments.js

@@ -20,7 +20,7 @@ function generateInterfaceComments(param) {
         comments.push(`maximum: ${param.maximum}`);
     }
     if (comments.length > 0) {
-        return `  /**\n   * ${comments.join('\n   * ')}\n   */`;
+        return `/**\n   * ${comments.join('\n   * ')}\n   */`;
     }
     return '';
 }

package/dist/renderers/generate-interface.d.ts

@@ -1,12 +1,11 @@
 import { OpenAPIV3 } from 'openapi-types';
 import { FileContent } from '../types/file-content';
-import { GroupedPath } from '../types/grouped-paths';
 import { InterfaceData, InterfaceDataProperty } from '../types/interface-data';
+import { SwaggularConfig } from '../types/config';
 export declare function parametersToIProperties(parameters: (OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject)[]): InterfaceDataProperty[];
 export declare function propertiesToIProperties(properties: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>): InterfaceDataProperty[];
-export declare function generateInterfaces(): void;
-export declare function generateWithParameters(): void;
-export declare function computeParametersName(method: string, innerPath: string, groupedPath: GroupedPath): string;
-export declare function generateComponentsSchemas(): void;
-export declare function generateInterfacesFiles(locations?: Record<string, string[]>): FileContent[];
+export declare function generateInterfaces(templatesConfig?: SwaggularConfig): void;
+export declare function generateWithParameters(templatesConfig?: SwaggularConfig): void;
+export declare function generateComponentsSchemas(templatesConfig?: SwaggularConfig): void;
+export declare function generateInterfacesFiles(locations?: Record<string, string[]>, templatesConfig?: SwaggularConfig): FileContent[];
 export declare function generateContent(interfaceData: InterfaceData, deep?: number): string;

package/dist/renderers/generate-interface.js

@@ -4,14 +4,11 @@ exports.parametersToIProperties = parametersToIProperties;
 exports.propertiesToIProperties = propertiesToIProperties;
 exports.generateInterfaces = generateInterfaces;
 exports.generateWithParameters = generateWithParameters;
-exports.computeParametersName = computeParametersName;
 exports.generateComponentsSchemas = generateComponentsSchemas;
 exports.generateInterfacesFiles = generateInterfacesFiles;
 exports.generateContent = generateContent;
 const interface_state_1 = require("../core/state/interface-state");
 const swagger_state_1 = require("../core/state/swagger-state");
-const extends_from_types_1 = require("../templates/types/extends-from-types");
-const generic_types_1 = require("../templates/types/generic-types");
 const build_types_1 = require("../utils/build-types");
 const object_utils_1 = require("../utils/object-utils");
 const path_utils_1 = require("../utils/path-utils");
@@ -23,12 +20,22 @@ function parametersToIProperties(parameters) {
     for (const param of parameters) {
         if ((0, type_guard_1.isReference)(param)) {
             const ref = param.$ref.split('/').pop();
-            properties.push({
-                name: (0, string_utils_1.lowerFirst)(ref),
-                type: ref,
-                optional: false,
-                comments: '',
-            });
+            if (param.$ref.includes('/components/parameters/')) {
+                const parameters = swagger_state_1.swaggerState.getParameters();
+                const parameter = parameters?.[ref];
+                if (parameter && !(0, type_guard_1.isReference)(parameter)) {
+                    if (parameter.in !== 'query')
+                        continue;
+                    const tsType = parameter.schema ? (0, build_types_1.switchTypeJson)(parameter.schema) : 'any';
+                    properties.push({
+                        name: (0, string_utils_1.lowerFirst)(parameter.name),
+                        type: tsType,
+                        optional: !parameter.required,
+                        comments: (0, generate_comments_1.generateInterfaceComments)(parameter.schema),
+                    });
+                    continue;
+                }
+            }
             continue;
         }
         if (param.in !== 'query')
@@ -65,16 +72,52 @@ function propertiesToIProperties(properties) {
     }
     return interfaceDataProperties;
 }
-function generateInterfaces() {
-    generateComponentsSchemas();
-    generateWithParameters();
+function isGenericType(data, genericTypes) {
+    for (const genericType of genericTypes) {
+        if (genericType.properties.length !== data.properties.length)
+            continue;
+        const dataProperties = data.properties.map((p) => p.name);
+        const genericTypeProperties = genericType.properties.map((p) => p.name);
+        if (genericTypeProperties.some((p) => !dataProperties.includes(p)))
+            continue;
+        return true; // Match found
+    }
+    return false;
+}
+function computeExtendsFromType(data, extendsTypes) {
+    for (const extendsFromType of extendsTypes) {
+        const dataPropertiesReq = data.properties.filter((p) => !p.optional).map((p) => p.name);
+        const extendsFromTypePropertiesReq = extendsFromType.properties
+            .filter((p) => !p.optional)
+            .map((p) => p.name);
+        if (extendsFromTypePropertiesReq.some((p) => !dataPropertiesReq.includes(p))) {
+            continue;
+        }
+        if (!extendsFromType.properties.some((ep) => data.properties.some((dp) => dp.name === ep.name))) {
+            continue;
+        }
+        const extensionProperties = extendsFromType.properties.map((p) => p.name.toLowerCase());
+        return {
+            ...data,
+            properties: data.properties.filter((p) => !extensionProperties.includes(p.name.toLowerCase())),
+            imports: [...data.imports, extendsFromType.name],
+            extendsFrom: [...(data.extendsFrom ?? []), extendsFromType.name],
+        };
+    }
+    return data;
 }
-function generateWithParameters() {
+function generateInterfaces(templatesConfig) {
+    generateComponentsSchemas(templatesConfig);
+    generateWithParameters(templatesConfig);
+}
+function generateWithParameters(templatesConfig) {
     const paths = swagger_state_1.swaggerState.getPaths();
     const groupedPaths = swagger_state_1.swaggerState.getPathsGroupedByScope();
     if (!paths || !groupedPaths)
         return;
     const interfacesData = [];
+    const genericTypes = templatesConfig?.types?.generic ?? [];
+    const extendsTypes = templatesConfig?.types?.extendsFrom ?? [];
     for (const groupedPath of Object.values(groupedPaths)) {
         for (const innerPath of groupedPath.paths) {
             const pathInfo = paths[innerPath];
@@ -94,40 +137,31 @@ function generateWithParameters() {
                 const properties = parametersToIProperties(parameters);
                 if (properties.length === 0)
                     continue;
-                const interfaceName = computeParametersName(httpMethod, innerPath, groupedPath);
+                const interfaceName = (0, path_utils_1.computeParametersName)(httpMethod, innerPath, groupedPath);
                 const interData = {
                     name: interfaceName,
                     type: 'interface',
                     imports: properties.filter((p) => !(0, type_guard_1.isNativeType)(p.type)).map((p) => p.type),
                     properties,
                 };
-                const generic = (0, generic_types_1.isGenericType)(interData);
+                const generic = isGenericType(interData, genericTypes);
                 if (generic)
                     continue;
-                const interDataWithExtendsFrom = (0, extends_from_types_1.computeExtendsFromType)(interData);
+                const interDataWithExtendsFrom = computeExtendsFromType(interData, extendsTypes);
                 interfacesData.push(interDataWithExtendsFrom);
             }
         }
     }
     interface_state_1.interfaceState.addInterfaces(interfacesData);
 }
-function computeParametersName(method, innerPath, groupedPath) {
-    const dict = {
-        get: '',
-        post: 'Create',
-        put: 'Update',
-        delete: 'Delete',
-        patch: 'Patch',
-    };
-    const name = dict[method];
-    const extra = (0, string_utils_1.kebabToPascalCase)((0, path_utils_1.removeVariablesFromPath)((0, path_utils_1.getExtraSegments)(innerPath, (0, path_utils_1.createBaseUrl)(groupedPath.baseSegments)).join('')));
-    return name + groupedPath.groupName + (0, string_utils_1.upFirst)(extra) + 'Params';
-}
-function generateComponentsSchemas() {
+function generateComponentsSchemas(templatesConfig) {
     const schemas = swagger_state_1.swaggerState.getSchemas();
     if (!schemas)
         return;
     const interfaces = [];
+    const genericMappings = new Map();
+    const genericTypes = templatesConfig?.types?.generic ?? [];
+    const extendsTypes = templatesConfig?.types?.extendsFrom ?? [];
     for (const [key, value] of Object.entries(schemas)) {
         if ((0, type_guard_1.isReference)(value))
             continue;
@@ -147,6 +181,29 @@ function generateComponentsSchemas() {
                     }),
                 };
                 interfaces.push(interData);
+                continue;
+            }
+            const targetType = (0, build_types_1.switchTypeJson)(value);
+            if (targetType) {
+                const imports = [];
+                const baseType = targetType.replace('[]', '');
+                if (!(0, type_guard_1.isNativeType)(baseType)) {
+                    imports.push(baseType);
+                }
+                interfaces.push({
+                    name: key,
+                    type: 'type',
+                    imports,
+                    properties: [
+                        {
+                            name: '',
+                            type: targetType,
+                            optional: false,
+                            comments: (0, generate_comments_1.generateInterfaceComments)(value),
+                        },
+                    ],
+                });
+                continue;
             }
             continue;
         }
@@ -161,24 +218,56 @@ function generateComponentsSchemas() {
             }),
             properties,
         };
-        const generic = (0, generic_types_1.isGenericType)(interData);
+        const generic = isGenericType(interData, genericTypes);
         if (generic) {
+            const genericType = genericTypes.find((g) => {
+                if (g.properties.length !== interData.properties.length)
+                    return false;
+                const gProps = g.properties.map((p) => p.name);
+                const dProps = interData.properties.map((p) => p.name);
+                return !gProps.some((p) => !dProps.includes(p));
+            });
+            if (genericType) {
+                const genericName = computeGenericType(interData, genericType);
+                genericMappings.set(key, genericName);
+                interface_state_1.interfaceState.addTypeMapping(key, genericName);
+            }
             continue;
         }
-        const interDataWithExtendsFrom = (0, extends_from_types_1.computeExtendsFromType)(interData);
+        const interDataWithExtendsFrom = computeExtendsFromType(interData, extendsTypes);
         interfaces.push(interDataWithExtendsFrom);
     }
+    // Update properties of all interfaces to use generic mappings
+    for (const inter of interfaces) {
+        inter.properties.forEach((p) => {
+            if (genericMappings.has(p.type)) {
+                p.type = genericMappings.get(p.type);
+            }
+            else if (p.type.endsWith('[]')) {
+                const base = p.type.replace('[]', '');
+                if (genericMappings.has(base)) {
+                    p.type = genericMappings.get(base) + '[]';
+                }
+            }
+        });
+    }
     interface_state_1.interfaceState.addInterfaces(interfaces);
 }
-function generateInterfacesFiles(locations) {
+function computeGenericType(newInterface, genericType) {
+    const typeParam = newInterface.name.replace(genericType.name, '');
+    return `${genericType.name}<${typeParam}>`;
+}
+function generateInterfacesFiles(locations, templatesConfig) {
+    const genericTypes = templatesConfig?.types?.generic ?? [];
+    const extendsTypes = templatesConfig?.types?.extendsFrom ?? [];
     const interfacesData = [
-        ...generic_types_1.genericTypesData,
-        ...extends_from_types_1.extendsFromTypes,
+        ...genericTypes,
+        ...extendsTypes,
         ...Array.from(Object.values(interface_state_1.interfaceState.generatedInterfaces)),
     ];
     const filesContent = [];
-    for (const [key, value] of Object.entries(interfacesData)) {
-        const location = [value.type === 'enum' ? 'enums' : 'dtos', ...(locations?.[key] ?? [])];
+    for (const value of interfacesData) {
+        const location = [value.type === 'enum' ? 'enums' : 'dtos', ...(locations?.[value.name] ?? [])];
         const content = generateContent(value, location.length + 1);
         const extraName = value.type === 'enum' ? 'enum' : 'dto';
         filesContent.push({
@@ -200,16 +289,20 @@ function generateContent(interfaceData, deep = 0) {
             .map((p) => p.type.replace('[]', ''));
         const content = `${importsTemplate}\n\nexport interface ${interfaceData.name}${genericTypes.length > 0 ? `<${genericTypes.join(', ')}>` : ''} ${interfaceData.extendsFrom && interfaceData.extendsFrom.length > 0 ? `extends ${interfaceData.extendsFrom.join(', ')}` : ''} {
     ${interfaceData.properties
-            .map((p) => `${p.comments}\n\t${(0, string_utils_1.lowerFirst)(p.name)}${p.optional ? '?' : ''}: ${p.type};`)
+            .map((p) => `${p.comments}\n  ${(0, string_utils_1.lowerFirst)(p.name)}${p.optional ? '?' : ''}: ${p.type};`)
             .join('\n')}
   }`;
         return content;
     }
     if (interfaceData.type === 'enum') {
         const content = `export enum ${interfaceData.name} {
-    ${interfaceData.properties.map((p) => `${p.comments}\n\t${p.name} = '${p.type}',`).join('\n')}
+    ${interfaceData.properties.map((p) => `${p.comments}\n  ${p.name} = '${p.type}',`).join('\n')}
   }`;
         return content;
     }
+    if (interfaceData.type === 'type') {
+        const targetType = interfaceData.properties[0].type;
+        return `${importsTemplate}\n\nexport type ${interfaceData.name} = ${targetType};`;
+    }
     return '';
 }

package/dist/renderers/generate-service.d.ts

@@ -2,9 +2,10 @@ import { OpenAPIV3 } from 'openapi-types';
 import { FileContent } from '../types/file-content';
 import { GroupedPath } from '../types/grouped-paths';
 import { ServiceDataMethod } from '../types/service-data';
+import { SwaggularConfig } from '../types/config';
 /**
  * Pick the paths grouped by scope and generate services for them.
  */
 export declare function generateServices(): void;
-export declare function generateServiceFiles(locations?: Record<string, string[]>): FileContent[];
+export declare function generateServiceFiles(locations?: Record<string, string[]>, templatesConfig?: SwaggularConfig['templates']): FileContent[];
 export declare function buildMethods(groupedPath: GroupedPath, pathData: OpenAPIV3.PathsObject, serviceName: string): ServiceDataMethod[];

package/dist/renderers/generate-service.js

@@ -5,16 +5,15 @@ exports.generateServiceFiles = generateServiceFiles;
 exports.buildMethods = buildMethods;
 const service_state_1 = require("../core/state/service-state");
 const swagger_state_1 = require("../core/state/swagger-state");
-const angular_template_1 = require("../templates/services/angular-template");
 const build_types_1 = require("../utils/build-types");
 const path_utils_1 = require("../utils/path-utils");
 const string_utils_1 = require("../utils/string-utils");
 const type_guard_1 = require("../utils/type-guard");
 const generate_comments_1 = require("./generate-comments");
 const object_utils_1 = require("../utils/object-utils");
-const generate_interface_1 = require("./generate-interface");
-const http_params_handler_1 = require("../templates/services/http-params-handler");
+const path_utils_2 = require("../utils/path-utils");
 const interface_state_1 = require("../core/state/interface-state");
+const template_renderer_1 = require("../utils/template-renderer");
 /**
  * Pick the paths grouped by scope and generate services for them.
  */
@@ -64,24 +63,36 @@ function addTypeToImports(type, imports) {
         imports.add(baseType);
     }
 }
-function generateServiceFiles(locations) {
+function generateServiceFiles(locations, templatesConfig) {
     const services = Object.values(service_state_1.serviceState.services);
     const filesContent = [];
     for (const service of services) {
         const location = ['services', ...(locations?.[service.name] ?? [])];
+        const serviceTemplateConfig = templatesConfig?.service;
+        const templatePath = serviceTemplateConfig?.path || 'templates/angular-service.template';
         const methods = service.methods
             .map((method) => {
-            return buildMethodTemplate(method);
+            return buildMethodTemplate(method, serviceTemplateConfig?.options?.httpParamsHandler);
         })
             .join('\n\n');
+        const allImports = Array.from(new Set([...service.imports])).sort();
+        const hasHttpParams = service.methods.some((m) => !!m.queryParamType);
         const templateParams = {
             name: service.name,
             baseUrl: service.baseUrl,
             methods: methods,
-            imports: service.imports.join(', '),
-            hasHttpParamsHandler: service.methods.some((m) => !!m.queryParamType),
+            imports: allImports.join(', '),
+            modelImports: allImports.length > 0
+                ? `import { ${allImports.join(', ')} } from '${'../'.repeat(location.length)}models';`
+                : '',
+            hasHttpParamsHandler: hasHttpParams,
+            httpParamsHandler: serviceTemplateConfig?.options?.httpParamsHandler,
+            httpParamsHandlerImport: hasHttpParams
+                ? serviceTemplateConfig?.options?.httpParamsHandlerImport
+                : '',
+            extraAngularImports: hasHttpParams && !serviceTemplateConfig?.options?.httpParamsHandler ? ', HttpParams' : '',
         };
-        const content = (0, angular_template_1.angularTemplate)(templateParams);
+        const content = (0, template_renderer_1.renderServiceTemplate)(templatePath, templateParams);
         filesContent.push({
             location: location,
             content,
@@ -107,7 +118,7 @@ function buildMethods(groupedPath, pathData, serviceName) {
             const queryParams = parameters.filter((p) => p.in === 'query');
             let queryParamType;
             if (queryParams.length > 0) {
-                queryParamType = (0, generate_interface_1.computeParametersName)(method, path, groupedPath);
+                queryParamType = (0, path_utils_2.computeParametersName)(method, path, groupedPath);
             }
             const commentParams = parameters.filter((p) => p.in !== 'query');
             if (queryParamType) {
@@ -140,18 +151,7 @@ function pathItemToMethods(pathItem) {
         patch: pathItem.patch,
     });
 }
-/**
- * buildMethodName: High-performance semantic naming algorithm.
- *
- * This engine generates clean, non-redundant, and intuitive method names by
- * analyzing the relationship between the base URL and extra path segments.
- *
- * For Mutation methods (POST, PUT, PATCH, DELETE), it prioritizes using the
- * path segments as the method name itself if they describe an action,
- * avoiding generic "create" or "update" prefixes where possible.
- */
 function buildMethodName(method, path, groupedPath, usedNames, serviceName) {
-    // 1. Core mapping of HTTP verbs to professional action prefixes
     const verbMap = {
         get: 'get',
         post: 'create',
@@ -161,7 +161,6 @@ function buildMethodName(method, path, groupedPath, usedNames, serviceName) {
     };
     const defaultVerb = verbMap[method.toLowerCase()] || method.toLowerCase();
     const segments = (0, path_utils_1.getExtraSegments)(path, groupedPath.baseUrl);
-    // 2. Redundancy Filtering: Remove segments already implied by the service name
     const serviceWords = serviceName.split(/(?=[A-Z])/).map((w) => w.toLowerCase());
     const cleanSegments = segments.filter((seg) => {
         if ((0, path_utils_1.isVariable)(seg))
@@ -169,7 +168,6 @@ function buildMethodName(method, path, groupedPath, usedNames, serviceName) {
         const segWords = seg.split('-').map((w) => w.toLowerCase());
         return !segWords.every((sw) => serviceWords.includes(sw));
     });
-    // 3. Structural Analysis: Identify resources and variable positioning
     const staticBefore = [];
     const variableParts = [];
     const staticAfter = [];
@@ -187,7 +185,6 @@ function buildMethodName(method, path, groupedPath, usedNames, serviceName) {
         }
     }
     const nameParts = [];
-    // 4. Logic specific to data fetching (GET)
     if (method.toLowerCase() === 'get') {
         nameParts.push('get');
         if (staticAfter.length > 0) {
@@ -203,22 +200,18 @@ function buildMethodName(method, path, groupedPath, usedNames, serviceName) {
             nameParts.push('ById');
         }
     }
-    // 5. Logic for state mutation (POST, PUT, PATCH, DELETE)
     else {
         const actionParts = [...staticBefore, ...staticAfter];
         if (actionParts.length > 0) {
-            // If the path contains an action (e.g., /assign, /send-to-user), use it directly.
             nameParts.push((0, string_utils_1.toPascalCase)(actionParts));
         }
         else {
-            // No extra segments, use the default verb prefix (e.g., create, update)
             nameParts.push((0, string_utils_1.upFirst)(defaultVerb));
         }
         if (variableParts.length > 0) {
             nameParts.push('ById');
         }
     }
-    // 6. Pattern-based Refinement: Detect and prioritize standard REST suffixes
     const normalizedPath = path.toLowerCase();
     const suffixes = [
         { pattern: '/all', label: 'All' },
@@ -236,17 +229,13 @@ function buildMethodName(method, path, groupedPath, usedNames, serviceName) {
             break;
         }
     }
-    // 7. Base candidate assembly
     let candidateName = (0, string_utils_1.lowerFirst)(nameParts.join(''));
-    // Simplification for the primary resource GET
     if (candidateName === 'getById' && !usedNames.includes('get')) {
         candidateName = 'get';
     }
-    // Fallback for empty/ambiguous names
     if (candidateName === '' || (candidateName === defaultVerb && segments.length > 0)) {
         candidateName = (0, string_utils_1.lowerFirst)(defaultVerb + (0, string_utils_1.toPascalCase)(segments.map((s) => s.replace(/[{}]/g, ''))));
     }
-    // 8. Multi-strategy Collision Resolution
     let finalName = candidateName;
     let counter = 0;
     while (usedNames.includes(finalName)) {
@@ -271,14 +260,26 @@ function buildParameters(operation, pathParameters) {
     for (const param of allParams) {
         if ((0, type_guard_1.isReference)(param)) {
             const ref = param.$ref.split('/').pop();
-            console.log('🚀 ~ buildParameters ~ ref:', ref);
             const interfaceData = interface_state_1.interfaceState.getInterface(ref);
-            console.log('🚀 ~ buildParameters ~ interfaceData:', interfaceData);
+            let paramType = interface_state_1.interfaceState.getTypeMapping(ref) || ref;
+            let inType = interfaceData?.type !== undefined ? 'query' : 'path';
+            let required = true;
+            if (param.$ref.includes('/components/parameters/')) {
+                const parameters = swagger_state_1.swaggerState.getParameters();
+                const parameter = parameters?.[ref];
+                if (parameter && !(0, type_guard_1.isReference)(parameter)) {
+                    inType = parameter.in;
+                    required = parameter.required ?? false;
+                    if (parameter.schema) {
+                        paramType = (0, build_types_1.switchTypeJson)(parameter.schema);
+                    }
+                }
+            }
             results.push({
                 name: (0, string_utils_1.lowerFirst)(ref),
-                in: interfaceData?.type !== undefined ? 'query' : 'path',
-                required: true,
-                type: ref,
+                in: inType,
+                required,
+                type: paramType,
             });
             continue;
         }
@@ -308,21 +309,22 @@ function buildParameters(operation, pathParameters) {
             type: bodyType,
         });
     }
-    console.log('🚀 ~ buildParameters ~ results:', results);
     return results;
 }
 function buildResponseType(responses) {
     const success = responses['200'] || responses['201'] || responses['204'] || responses['default'];
     if (!success)
         return 'any';
-    if ((0, type_guard_1.isReference)(success))
-        return success.$ref.split('/').pop();
+    if ((0, type_guard_1.isReference)(success)) {
+        const name = success.$ref.split('/').pop();
+        return interface_state_1.interfaceState.getTypeMapping(name) || name;
+    }
     const content = success.content?.['application/json'];
     if (!content || !content.schema)
         return 'any';
     return (0, build_types_1.switchTypeJson)(content.schema);
 }
-function buildMethodTemplate(method) {
+function buildMethodTemplate(method, httpParamsHandlerTemplate) {
     const pathParams = method.parameters.filter((p) => p.in === 'path');
     const bodyParam = method.parameters.find((p) => p.in === 'body');
     const methodArgs = [];
@@ -339,10 +341,8 @@ function buildMethodTemplate(method) {
         .map((s) => ((0, path_utils_1.isVariable)(s) ? `\${${(0, string_utils_1.lowerFirst)(s.replace(/[{}]/g, ''))}}` : s))
         .join('/');
     const url = `\`\${this.baseUrl}${pathStr ? '/' + pathStr : ''}\``;
-    let handler = '';
     const optionsList = [];
     if (method.queryParamType) {
-        handler = `\n\t\t${(0, http_params_handler_1.httpParamsHandler)('queryParams')}`;
         optionsList.push('params');
     }
     if (['Blob', 'File'].includes(method.responseType)) {
@@ -358,8 +358,30 @@ function buildMethodTemplate(method) {
         : ['post', 'put', 'patch'].includes(method.method)
             ? `this.http.${method.method}${genericType}(${url}, {}${options})`
             : `this.http.${method.method}${genericType}(${url}${options})`;
-    return `${method.comments}
-  ${method.name}(${argsString}): Observable<${method.responseType}> {${handler}
-    return ${methodCall};
+    let paramsLogic = '';
+    if (method.queryParamType) {
+        if (httpParamsHandlerTemplate) {
+            paramsLogic = `\n    ${httpParamsHandlerTemplate.replace('${params}', 'queryParams')}`;
+        }
+        else {
+            paramsLogic = `
+    let params = new HttpParams();
+    if (queryParams) {
+      for (const [key, value] of Object.entries(queryParams)) {
+        if (value === undefined || value === null) continue;
+        if (Array.isArray(value)) {
+          value.forEach((v) => (params = params.append(key, v)));
+        } else if (typeof value === 'object' && !(value instanceof Date) && !(value instanceof Blob)) {
+          params = params.set(key, JSON.stringify(value));
+        } else {
+          params = params.set(key, value as any);
+        }
+      }
+    }`;
+        }
+    }
+    return `${method.comments}
+  ${method.name}(${argsString}): Observable<${method.responseType}> {${paramsLogic}
+    return ${methodCall};
   }`;
 }

package/dist/templates/services/angular-template.d.ts

@@ -7,12 +7,8 @@ export interface AngularServiceTemplate {
     methods: string;
     imports: string;
     hasHttpParamsHandler: boolean;
-}
-export interface AngularServiceResult {
-    forTemplate: AngularServiceTemplate[];
-    parametersTypes: Record<string, {
-        method: string;
-        parameterType: string;
-    }>;
+    configImports?: string[];
+    httpParamsHandler?: string;
+    httpParamsHandlerImport?: string;
 }
 export declare const angularTemplate: (params: AngularServiceTemplate) => string;

package/dist/templates/services/angular-template.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.angularTemplate = void 0;
-const http_params_handler_1 = require("./http-params-handler");
 const angularTemplate = (params) => {
+    const configImports = params.configImports
+        ? params.configImports.map((i) => `import { ${i} } from '@angular/core';`).join('\n') // Placeholder logic, actual imports might be more complex
+        : '';
+    // Actually, let's keep it simple. The config imports should probably be raw strings or structured.
+    // For now, let's assume the template receives the RAW import strings from the config if provided,
+    // OR we construct them here.
+    // User wants: "can make it so it can work without any custom template (just the most generic one)"
+    // and "make it so it works with a JSON configuration".
+    const httpParamsHandlerImport = params.httpParamsHandlerImport || '';
     return `
 import { HttpClient } from "@angular/common/http";
 import { Observable } from "rxjs";
 import { inject, Injectable } from '@angular/core';
 import { ${params.imports} } from '../models';
-${params.hasHttpParamsHandler ? (0, http_params_handler_1.httpParamsHandlerImport)() : ''}
+${httpParamsHandlerImport}
 
 @Injectable({
     providedIn: "root"

package/dist/types/config.d.ts

@@ -0,0 +1,22 @@
+import { ServiceTemplateParams } from './template';
+import { InterfaceData } from './interface-data';
+export interface SwaggularConfig {
+    types?: {
+        extendsFrom?: InterfaceData[];
+        generic?: InterfaceData[];
+    };
+    templates?: {
+        service?: {
+            path: string;
+            options?: Partial<ServiceTemplateParams>;
+            transform?: (options: ServiceTemplateParams) => string;
+            content?: string;
+            httpParamsHandler?: string;
+            httpParamsHandlerImport?: string;
+        };
+    };
+    input?: string;
+    output?: string;
+    groupingMode?: 'tags' | 'path';
+    segmentsToIgnore?: string[];
+}

package/dist/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/parsed-args.d.ts

@@ -1,11 +1,14 @@
+import { SwaggularConfig } from './config';
 export type ParsedArgs = {
     args: Record<string, string | boolean>;
     positional: string[];
 };
 export interface ArgsVariables {
-    groupingMode: 'tags' | 'path';
-    segmentsToIgnore: string[];
     input: string;
     output: string;
     noGenerate: boolean;
+    groupingMode: 'tags' | 'path';
+    segmentsToIgnore: string[];
+    templates?: SwaggularConfig['templates'];
+    types?: SwaggularConfig['types'];
 }

package/dist/types/template.d.ts

@@ -0,0 +1,11 @@
+export interface ServiceTemplateParams {
+    name: string;
+    baseUrl: string;
+    methods: string;
+    imports: string;
+    hasHttpParamsHandler: boolean;
+    httpParamsHandler?: string;
+    httpParamsHandlerImport?: string;
+    modelImports?: string;
+    extraAngularImports?: string;
+}

package/dist/types/template.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/build-types.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildTypes = buildTypes;
 exports.switchTypeJson = switchTypeJson;
+const interface_state_1 = require("../core/state/interface-state");
 function buildTypes(masterSchema, defaultType = 'any') {
     if (!masterSchema)
         return defaultType;
@@ -18,12 +19,8 @@ function buildTypes(masterSchema, defaultType = 'any') {
         return defaultType;
     const ref = schema?.['$ref'];
     if (ref) {
-        const iface = ref.split('/').pop();
-        const isPagedResultDto = iface.endsWith('PagedResultDto');
-        if (isPagedResultDto) {
-            return `PagedResultDto<${iface.replace('PagedResultDto', '')}>`;
-        }
-        return iface;
+        const name = ref.split('/').pop();
+        return interface_state_1.interfaceState.getTypeMapping(name) || name;
     }
     return switchTypeJson(schema);
 }
@@ -34,12 +31,8 @@ function switchTypeJson(schema) {
     const type = schema?.['type'];
     const format = schema?.['format'];
     if (ref) {
-        const iface = ref.split('/').pop();
-        const isPagedResultDto = iface.endsWith('PagedResultDto');
-        if (isPagedResultDto) {
-            return `PagedResultDto<${iface.replace('PagedResultDto', '')}>`;
-        }
-        return iface;
+        const name = ref.split('/').pop();
+        return interface_state_1.interfaceState.getTypeMapping(name) || name;
     }
     if (type === 'object') {
         return 'any';

package/dist/utils/config-loader.d.ts

@@ -0,0 +1,2 @@
+import { SwaggularConfig } from '../types/config';
+export declare function loadConfig(configPath?: string): SwaggularConfig;

package/dist/utils/config-loader.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function loadConfig(configPath) {
+    const defaultConfigPath = 'swaggular.config.json';
+    const resolvedPath = path.resolve(configPath || defaultConfigPath);
+    if (fs.existsSync(resolvedPath)) {
+        try {
+            const fileContent = fs.readFileSync(resolvedPath, 'utf-8');
+            return JSON.parse(fileContent);
+        }
+        catch (error) {
+            console.error(`Error parsing config file at ${resolvedPath}:`, error);
+            return {};
+        }
+    }
+    return {};
+}

package/dist/utils/location-factory.d.ts

@@ -0,0 +1 @@
+export declare function computeLocations(): Record<string, string[]>;

package/dist/utils/location-factory.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeLocations = computeLocations;
+const swagger_state_1 = require("../core/state/swagger-state");
+const string_utils_1 = require("./string-utils");
+const path_utils_1 = require("./path-utils");
+function computeLocations() {
+    const swagger = swagger_state_1.swaggerState.getSwagger();
+    const groupedPaths = swagger_state_1.swaggerState.getPathsGroupedByScope();
+    const locations = {};
+    if (!swagger || !swagger.paths) {
+        return locations;
+    }
+    const processSchema = (dtoName, location) => {
+        if (locations[dtoName])
+            return;
+        if (isEnum(dtoName))
+            return;
+        locations[dtoName] = location;
+        const schemas = swagger_state_1.swaggerState.getSchemas();
+        if (!schemas || !schemas[dtoName])
+            return;
+        const schema = schemas[dtoName];
+        const refs = getReferences(schema);
+        for (const ref of refs) {
+            const childName = ref.split('/').pop();
+            if (childName) {
+                processSchema(childName, location);
+            }
+        }
+    };
+    if (groupedPaths) {
+        for (const [groupName, group] of Object.entries(groupedPaths)) {
+            if (group.baseSegments && group.baseSegments.length > 0) {
+                const folder = (0, string_utils_1.toKebabCase)(group.baseSegments[0]);
+                if (!locations[groupName]) {
+                    locations[groupName] = [folder];
+                }
+            }
+        }
+    }
+    // 1. Map Generated Parameter Interfaces
+    if (groupedPaths) {
+        for (const groupedPath of Object.values(groupedPaths)) {
+            for (const innerPath of groupedPath.paths) {
+                const pathInfo = swagger.paths[innerPath];
+                if (!pathInfo)
+                    continue;
+                const methods = ['get', 'post', 'put', 'delete', 'patch'];
+                for (const method of methods) {
+                    const operation = pathInfo[method];
+                    if (!operation)
+                        continue;
+                    // Check if parameters exist (similar condition to generate-interface)
+                    if (operation.parameters && operation.parameters.length > 0) {
+                        const interfaceName = (0, path_utils_1.computeParametersName)(method, innerPath, groupedPath);
+                        if (operation.tags && operation.tags.length > 0) {
+                            const tag = operation.tags[0];
+                            const folder = (0, string_utils_1.toKebabCase)(tag);
+                            if (!locations[interfaceName]) {
+                                locations[interfaceName] = [folder];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 2. Map DTOs and Services
+    for (const pathItem of Object.values(swagger.paths)) {
+        if (!pathItem)
+            continue;
+        const operations = [
+            pathItem.get,
+            pathItem.put,
+            pathItem.post,
+            pathItem.delete,
+            pathItem.options,
+            pathItem.head,
+            pathItem.patch,
+            pathItem.trace,
+        ];
+        for (const operation of operations) {
+            if (!operation || !operation.tags || operation.tags.length === 0) {
+                continue;
+            }
+            const tag = operation.tags[0];
+            const folder = (0, string_utils_1.toKebabCase)(tag);
+            const location = [folder];
+            // Map Service (Tag) to location
+            if (!locations[tag]) {
+                locations[tag] = location;
+            }
+            // Map DTOs used in this operation
+            const refs = getReferences(operation);
+            for (const ref of refs) {
+                const dtoName = ref.split('/').pop();
+                if (dtoName) {
+                    processSchema(dtoName, location);
+                }
+            }
+        }
+    }
+    return locations;
+}
+function isEnum(name) {
+    const schemas = swagger_state_1.swaggerState.getSchemas();
+    if (!schemas)
+        return false;
+    const schema = schemas[name];
+    if (!schema)
+        return false;
+    if ('$ref' in schema)
+        return false;
+    return !!schema.enum;
+}
+function getReferences(obj) {
+    const refs = [];
+    if (!obj || typeof obj !== 'object') {
+        return refs;
+    }
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            refs.push(...getReferences(item));
+        }
+        return refs;
+    }
+    for (const key of Object.keys(obj)) {
+        if (key === '$ref' && typeof obj[key] === 'string') {
+            refs.push(obj[key]);
+        }
+        else {
+            refs.push(...getReferences(obj[key]));
+        }
+    }
+    return refs;
+}

package/dist/utils/path-utils.d.ts

@@ -1,6 +1,8 @@
+import { GroupedPath } from '../types/grouped-paths';
 export declare function isVariable(segment: string): boolean;
 export declare function getExtraSegments(fullPath: string, baseUrl: string): string[];
 export declare function removeVariablesFromPath(path: string): string;
 export declare function createBaseUrl(baseSegments: string[]): string;
 export declare function findCommonBaseUrl(paths: string[]): string;
 export declare function standarizedPath(path: string): string;
+export declare function computeParametersName(method: string, innerPath: string, groupedPath: GroupedPath): string;

package/dist/utils/path-utils.js

@@ -6,6 +6,8 @@ exports.removeVariablesFromPath = removeVariablesFromPath;
 exports.createBaseUrl = createBaseUrl;
 exports.findCommonBaseUrl = findCommonBaseUrl;
 exports.standarizedPath = standarizedPath;
+exports.computeParametersName = computeParametersName;
+const string_utils_1 = require("./string-utils");
 function isVariable(segment) {
     return /^\{.+\}$/.test(segment);
 }
@@ -63,3 +65,21 @@ function standarizedPath(path) {
     const filtered = splitted.filter((p) => p !== '').map((p) => p.toLowerCase());
     return filtered.join('/');
 }
+function computeParametersName(method, innerPath, groupedPath) {
+    const dict = {
+        get: '',
+        post: 'Create',
+        put: 'Update',
+        delete: 'Delete',
+        patch: 'Patch',
+    };
+    const name = dict[method];
+    const extra = (0, string_utils_1.kebabToPascalCase)(removeVariablesFromPath(getExtraSegments(innerPath, createBaseUrl(groupedPath.baseSegments)).join('')));
+    // Avoid duplication if extra starts with groupName
+    let suffix = extra;
+    const groupName = groupedPath.groupName;
+    if (suffix.startsWith(groupName)) {
+        suffix = suffix.substring(groupName.length);
+    }
+    return name + groupName + (0, string_utils_1.upFirst)(suffix) + 'Params';
+}

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

@@ -1,9 +1,4 @@
 export declare function kebabToCamelCase(str: string): string;
-/**
- *
- * @param str :
- * @returns
- */
 export declare function kebabToPascalCase(str: string): string;
 export declare function removeAllWhitespace(text: string): string;
 export declare function lowerFirst(str: string): string;

package/dist/utils/string-utils.js

@@ -11,11 +11,6 @@ exports.toPascalCase = toPascalCase;
 function kebabToCamelCase(str) {
     return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
 }
-/**
- *
- * @param str :
- * @returns
- */
 function kebabToPascalCase(str) {
     const camel = str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
     return camel.charAt(0).toUpperCase() + camel.slice(1);

package/dist/utils/template-renderer.d.ts

@@ -0,0 +1,2 @@
+import { ServiceTemplateParams } from '../types/template';
+export declare function renderServiceTemplate(templatePath: string, params: ServiceTemplateParams): string;

package/dist/utils/template-renderer.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderServiceTemplate = renderServiceTemplate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function renderServiceTemplate(templatePath, params) {
+    // 1. Read the template file
+    const absolutePath = path.resolve(templatePath);
+    let templateContent;
+    try {
+        if (fs.existsSync(absolutePath)) {
+            templateContent = fs.readFileSync(absolutePath, 'utf-8');
+        }
+        else {
+            console.error(`Template file not found at ${absolutePath}`);
+            return '';
+        }
+    }
+    catch (err) {
+        console.error(`Error reading template file at ${absolutePath}`, err);
+        return '';
+    }
+    // 2. Perform replacements
+    // Simple mustache-like replacement: {{variable}}
+    // We can use a regex or simple replaceAll if available (Node 15+) or split/join.
+    let result = templateContent;
+    // Replace known params
+    result = result.replace(/{{name}}/g, params.name);
+    result = result.replace(/{{baseUrl}}/g, params.baseUrl);
+    result = result.replace(/{{methods}}/g, params.methods);
+    result = result.replace(/{{modelImports}}/g, params.modelImports || '');
+    result = result.replace(/{{imports}}/g, params.imports);
+    // Handle conditional logic for httpParamsHandlerImport
+    result = result.replace(/{{httpParamsHandlerImport}}/g, params.httpParamsHandlerImport || '');
+    result = result.replace(/{{extraAngularImports}}/g, params.extraAngularImports || '');
+    // Cleanup excessive newlines (3 or more, potentially with spaces) to just 2
+    result = result.replace(/(\r?\n\s*){3,}/g, '\n\n');
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggular",
-  "version": "0.3.0",
+  "version": "0.6.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {