@0kmpo/openapi-clean-arch-generator 1.3.10

package/src/utils/config.ts

@@ -0,0 +1,118 @@
+import fs from 'fs-extra';
+import { logInfo, logError } from './logger';
+import type { GenerationConfig, TagConfig } from '../types';
+import type { SwaggerAnalysis } from '../types';
+import type { TagSummary } from '../types';
+import type { ApiKeyInfo } from './environment-finder';
+
+/**
+ * Loads and validates a GenerationConfig from a JSON file.
+ */
+export function loadConfig(filePath: string): GenerationConfig {
+  if (!fs.existsSync(filePath)) {
+    logError(`Configuration file not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const raw = fs.readFileSync(filePath, 'utf8');
+  let config: GenerationConfig;
+
+  try {
+    config = JSON.parse(raw) as GenerationConfig;
+  } catch {
+    logError(`Invalid JSON in configuration file: ${filePath}`);
+    process.exit(1);
+  }
+
+  if (!config.tags || typeof config.tags !== 'object') {
+    logError('Configuration file must contain a "tags" object');
+    process.exit(1);
+  }
+
+  for (const [tag, tagConfig] of Object.entries(config.tags)) {
+    if (!tagConfig.baseUrl || typeof tagConfig.baseUrl !== 'string') {
+      logError(`Tag "${tag}" must have a "baseUrl" string`);
+      process.exit(1);
+    }
+    if (!Array.isArray(tagConfig.endpoints) || tagConfig.endpoints.length === 0) {
+      logError(`Tag "${tag}" must have a non-empty "endpoints" array`);
+      process.exit(1);
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Builds a default GenerationConfig from a swagger analysis, including all tags
+ * and all endpoints. Useful for --init-config to scaffold a config template.
+ */
+export function generateDefaultConfig(
+  analysis: SwaggerAnalysis,
+  tagSummaries: TagSummary[],
+  cliOptions: {
+    input: string;
+    output: string;
+    templates?: string;
+    skipLint?: boolean;
+    skipInstall?: boolean;
+  },
+  apiKeys: ApiKeyInfo[]
+): GenerationConfig {
+  const tags: Record<string, TagConfig> = {};
+
+  for (const summary of tagSummaries) {
+    const matchingKey = apiKeys.find((k) =>
+      k.key.toLowerCase().includes(summary.tag.toLowerCase())
+    );
+
+    tags[summary.tag] = {
+      baseUrl: matchingKey?.key || 'apiUrl',
+      endpoints: summary.operations.map((op) => op.nickname)
+    };
+  }
+
+  const config: GenerationConfig = {
+    input: cliOptions.input,
+    output: cliOptions.output,
+    skipLint: cliOptions.skipLint ?? false,
+    skipInstall: cliOptions.skipInstall ?? false,
+    tags
+  };
+
+  if (cliOptions.templates) {
+    config.templates = cliOptions.templates;
+  }
+
+  return config;
+}
+
+/**
+ * Writes a GenerationConfig to a JSON file.
+ */
+export function writeConfig(config: GenerationConfig, filePath: string): void {
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  logInfo(`Configuration file written to: ${filePath}`);
+}
+
+/**
+ * Derives the selectionFilter (tag → endpoint nicknames) from a GenerationConfig.
+ */
+export function deriveSelectionFilter(config: GenerationConfig): Record<string, string[]> {
+  const filter: Record<string, string[]> = {};
+  for (const [tag, tagConfig] of Object.entries(config.tags)) {
+    filter[tag] = [...tagConfig.endpoints];
+  }
+  return filter;
+}
+
+/**
+ * Derives the tagApiKeyMap (tag → baseUrl key) from a GenerationConfig.
+ */
+export function deriveTagApiKeyMap(config: GenerationConfig): Record<string, string> {
+  const map: Record<string, string> = {};
+  for (const [tag, tagConfig] of Object.entries(config.tags)) {
+    map[tag] = tagConfig.baseUrl;
+  }
+  return map;
+}

package/src/utils/environment-finder.ts

@@ -0,0 +1,53 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export interface ApiKeyInfo {
+  key: string;
+  url?: string;
+}
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.angular', 'coverage', '.cache']);
+
+/**
+ * Recursively searches for an `environment.ts` file starting from `dir`,
+ * up to `maxDepth` directory levels deep.
+ */
+export function findEnvironmentFile(dir: string, maxDepth = 8, currentDepth = 0): string | null {
+  if (currentDepth > maxDepth) return null;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isFile() && entry.name === 'environment.ts') {
+        return fullPath;
+      }
+      if (entry.isDirectory()) {
+        const found = findEnvironmentFile(fullPath, maxDepth, currentDepth + 1);
+        if (found) return found;
+      }
+    }
+  } catch {
+    //bypass errors
+  }
+  return null;
+}
+
+/**
+ * Parses environment.ts content and returns all top-level keys that contain "api"
+ * (case-insensitive), along with their `url` value if present.
+ */
+export function parseApiKeys(content: string): ApiKeyInfo[] {
+  const result: ApiKeyInfo[] = [];
+  const keyRegex = /^ {2}(\w*[Aa][Pp][Ii]\w*)\s*:/gm;
+  let match: RegExpExecArray | null;
+
+  while ((match = keyRegex.exec(content)) !== null) {
+    const key = match[1];
+    const afterKey = content.slice(match.index);
+    const urlMatch = afterKey.match(/url:\s*['"`]([^'"`\n]+)['"`]/);
+    result.push({ key, url: urlMatch?.[1] });
+  }
+
+  return result;
+}

package/src/utils/filesystem.ts

@@ -0,0 +1,31 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { logSuccess, logInfo } from './logger';
+
+/** Creates the required Clean Architecture directory structure (idempotent). */
+export function createDirectoryStructure(baseDir: string): void {
+  const dirs = [
+    path.join(baseDir, 'data/dtos'),
+    path.join(baseDir, 'data/repositories'),
+    path.join(baseDir, 'data/mappers'),
+    path.join(baseDir, 'domain/repositories'),
+    path.join(baseDir, 'domain/use-cases'),
+    path.join(baseDir, 'di/repositories'),
+    path.join(baseDir, 'di/use-cases'),
+    path.join(baseDir, 'entities/models')
+  ];
+
+  dirs.forEach((dir) => {
+    fs.ensureDirSync(dir);
+  });
+
+  logSuccess('Directory structure created');
+}
+
+/** Removes a temporary directory and all its contents. */
+export function cleanup(tempDir: string): void {
+  if (fs.existsSync(tempDir)) {
+    fs.removeSync(tempDir);
+    logInfo('Temporary files removed');
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,60 @@
+import fs from 'fs-extra';
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m'
+} as const;
+
+type Color = keyof typeof colors;
+
+let _logFilePath: string | null = null;
+
+/** Initialises the generation log file, overwriting any previous run. */
+export function initGenerationLog(filePath: string): void {
+  _logFilePath = filePath;
+  fs.writeFileSync(filePath, `Generation log — ${new Date().toISOString()}\n${'='.repeat(60)}\n`);
+}
+
+/** Writes a detailed entry to the generation log file (not to console). */
+export function logDetail(category: string, message: string): void {
+  if (!_logFilePath) return;
+  const line = `[${new Date().toISOString()}] [${category.toUpperCase().padEnd(8)}] ${message}\n`;
+  fs.appendFileSync(_logFilePath, line);
+}
+
+/** Prints a console message with the given ANSI colour. */
+export function log(message: string, color: Color = 'reset'): void {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+/** Prints a success message (green). */
+export function logSuccess(message: string): void {
+  log(`✅ ${message}`, 'green');
+}
+
+/** Prints an informational message (blue). */
+export function logInfo(message: string): void {
+  log(`ℹ️  ${message}`, 'blue');
+}
+
+/** Prints a warning message (yellow). */
+export function logWarning(message: string): void {
+  log(`⚠️  ${message}`, 'yellow');
+}
+
+/** Prints an error message (red). */
+export function logError(message: string): void {
+  log(`❌ ${message}`, 'red');
+}
+
+/** Prints a step/stage header (cyan). */
+export function logStep(message: string): void {
+  log(`\n🚀 ${message}`, 'cyan');
+}
+
+export { colors };

package/src/utils/mock-value-resolver.ts

@@ -0,0 +1,70 @@
+/**
+ * Resolves a TypeScript literal string to use as a mock value for a single schema property.
+ *
+ * Priority chain:
+ *   $ref mock call → array $ref mock call → enum[0] → example → format fallback → type default
+ *
+ * @param propName  Property name (used for format heuristics such as "email").
+ * @param prop      Raw OpenAPI property definition.
+ * @param context   'dto' generates `mockFooDto()`, 'model' generates `mockFooModel()`.
+ */
+export function resolveMockValue(
+  propName: string,
+  prop: {
+    type?: string;
+    format?: string;
+    example?: unknown;
+    enum?: unknown[];
+    $ref?: string;
+    items?: { $ref?: string; type?: string };
+  },
+  context: 'dto' | 'model' = 'dto'
+): string {
+  const suffix = context === 'dto' ? 'Dto' : 'Model';
+
+  // 1. Direct $ref → call the referenced mock factory
+  if (prop.$ref) {
+    const refName = prop.$ref.split('/').pop()!;
+    return `mock${refName}${suffix}()`;
+  }
+
+  // 2. Array of $ref → wrap referenced mock in an array
+  if (prop.type === 'array' && prop.items?.$ref) {
+    const refName = prop.items.$ref.split('/').pop()!;
+    return `[mock${refName}${suffix}()]`;
+  }
+
+  // 3. Array of primitives
+  if (prop.type === 'array') return '[]';
+
+  // 4. Enum → first declared value
+  if (prop.enum?.length) {
+    const first = prop.enum[0];
+    return typeof first === 'string' ? `'${first}'` : String(first);
+  }
+
+  // 5. Example value from the swagger spec (highest fidelity)
+  if (prop.example !== undefined) return formatLiteral(prop.example);
+
+  // 6. Format-aware fallbacks (when no example is provided)
+  if (prop.format === 'date-time') return `'2024-01-01T00:00:00.000Z'`;
+  if (prop.format === 'date') return `'2024-01-01'`;
+  if (prop.format === 'uuid') return `'00000000-0000-0000-0000-000000000000'`;
+  if (prop.format === 'uri') return `'https://example.com'`;
+  if (prop.format === 'email' || propName.toLowerCase().includes('email'))
+    return `'user@example.com'`;
+
+  // 7. Type defaults
+  if (prop.type === 'string') return `'value'`;
+  if (prop.type === 'integer' || prop.type === 'number') return `0`;
+  if (prop.type === 'boolean') return `false`;
+
+  return 'undefined';
+}
+
+function formatLiteral(value: unknown): string {
+  if (typeof value === 'string') return `'${value}'`;
+  if (typeof value === 'number') return `${value}`;
+  if (typeof value === 'boolean') return `${value}`;
+  return `'${String(value)}'`;
+}

package/src/utils/name-formatter.ts

@@ -0,0 +1,12 @@
+/**
+ * Converts a PascalCase name to camelCase by lowercasing the first character.
+ * Used to derive class filenames and variable names from schema/tag names.
+ *
+ * @example
+ * toCamelCase('ProductResponse') // 'productResponse'
+ * toCamelCase('UserSchema')      // 'userSchema'
+ */
+export function toCamelCase(name: string): string {
+  if (!name) return name;
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}

package/src/utils/openapi-generator.ts

@@ -0,0 +1,24 @@
+import { execSync } from 'child_process';
+import { logStep, logSuccess, logError } from './logger';
+
+/** Checks whether `openapi-generator-cli` is available on the PATH. */
+export function checkOpenApiGenerator(): boolean {
+  try {
+    execSync('openapi-generator-cli version', { stdio: 'ignore' });
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+/** Installs `@openapitools/openapi-generator-cli` globally via npm. */
+export function installOpenApiGenerator(): void {
+  logStep('Installing @openapitools/openapi-generator-cli...');
+  try {
+    execSync('npm install -g @openapitools/openapi-generator-cli', { stdio: 'inherit' });
+    logSuccess('OpenAPI Generator CLI installed successfully');
+  } catch (_error) {
+    logError('Error installing OpenAPI Generator CLI');
+    process.exit(1);
+  }
+}

package/src/utils/prompt.ts

@@ -0,0 +1,183 @@
+import prompts from 'prompts';
+import { ApiKeyInfo } from './environment-finder';
+import { colors } from './logger';
+import type { TagSummary, SelectionFilter } from '../types';
+
+function clearScreen(): void {
+  process.stdout.write('\x1Bc');
+}
+
+function printHeader(current?: number, total?: number): void {
+  const stepText =
+    current !== undefined && total !== undefined
+      ? `   [${colors.cyan}${current}${colors.reset} de ${colors.cyan}${total}${colors.reset}]`
+      : '';
+  console.log(`\n  ${colors.bright}🔑  Configuración de URLs base${colors.reset}${stepText}`);
+  console.log(`  ${'─'.repeat(54)}\n`);
+}
+
+function printSummary(tags: string[], result: Record<string, string>): void {
+  clearScreen();
+  console.log(`\n  ${colors.bright}✅  Configuración completada${colors.reset}`);
+  console.log(`  ${'─'.repeat(54)}\n`);
+  tags.forEach((tag) => {
+    console.log(`  ${colors.bright}${tag}${colors.reset}`);
+    console.log(`  ${colors.cyan}environment.${result[tag]}.url${colors.reset}\n`);
+  });
+  console.log(`  ${'─'.repeat(54)}\n`);
+}
+
+/**
+ * Interactively asks the user which tags and endpoints to generate.
+ * Returns a SelectionFilter map of tag → selected operation nicknames.
+ */
+export async function askSelectionFilter(tagSummaries: TagSummary[]): Promise<SelectionFilter> {
+  if (tagSummaries.length === 0) return {};
+
+  clearScreen();
+  console.log(`\n  ${colors.bright}📋  Selección de tags y endpoints${colors.reset}`);
+  console.log(`  ${'─'.repeat(54)}\n`);
+
+  // Step 1: select tags
+  const tagResponse = await prompts({
+    type: 'multiselect',
+    name: 'tags',
+    message: 'Tags a generar',
+    choices: tagSummaries.map((t) => ({
+      title: `${colors.bright}${t.tag}${colors.reset}  ${colors.cyan}(${t.operations.length} endpoint${t.operations.length !== 1 ? 's' : ''})${colors.reset}`,
+      value: t.tag,
+      selected: true
+    })),
+    min: 1,
+    hint: 'Espacio para marcar/desmarcar, Enter para confirmar'
+  });
+
+  if (!tagResponse.tags?.length) process.exit(0);
+
+  const selectedTags: string[] = tagResponse.tags;
+  const filter: SelectionFilter = {};
+
+  // Step 2: for each selected tag, select endpoints
+  for (let i = 0; i < selectedTags.length; i++) {
+    const tag = selectedTags[i];
+    const summary = tagSummaries.find((t) => t.tag === tag)!;
+
+    clearScreen();
+    console.log(
+      `\n  ${colors.bright}📋  Endpoints a generar${colors.reset}   [${colors.cyan}${i + 1}${colors.reset} de ${colors.cyan}${selectedTags.length}${colors.reset}]`
+    );
+    console.log(`  ${'─'.repeat(54)}\n`);
+
+    const opResponse = await prompts({
+      type: 'multiselect',
+      name: 'ops',
+      message: `Tag  ${colors.bright}${tag}${colors.reset}`,
+      choices: summary.operations.map((op) => ({
+        title:
+          `${colors.bright}${op.method.padEnd(6)}${colors.reset} ${op.path}` +
+          (op.summary ? `  ${colors.cyan}${op.summary}${colors.reset}` : ''),
+        value: op.nickname,
+        selected: true
+      })),
+      min: 1,
+      hint: 'Espacio para marcar/desmarcar, Enter para confirmar'
+    });
+
+    if (!opResponse.ops?.length) process.exit(0);
+
+    filter[tag] = opResponse.ops;
+  }
+
+  return filter;
+}
+
+/**
+ * Interactively asks the user which environment API key to use for each tag,
+ * using arrow-key selection. The last option always allows typing manually.
+ * Returns a map of tag → environment key (e.g. { "SupplyingMaintenances": "suppliyingMaintenancesApi" }).
+ */
+export async function askApiKeysForTags(
+  tags: string[],
+  apiKeys: ApiKeyInfo[]
+): Promise<Record<string, string>> {
+  if (tags.length === 0) return {};
+
+  clearScreen();
+  printHeader();
+
+  const modeResponse = await prompts({
+    type: 'select',
+    name: 'mode',
+    message: 'URL base para los repositorios',
+    choices: [
+      { title: `${colors.bright}La misma para todos${colors.reset}`, value: 'all' },
+      { title: `${colors.bright}Configurar individualmente${colors.reset}`, value: 'individual' }
+    ],
+    hint: ' '
+  });
+
+  if (modeResponse.mode === undefined) process.exit(0);
+
+  const result: Record<string, string> = {};
+
+  if (modeResponse.mode === 'all') {
+    clearScreen();
+    printHeader();
+    const sharedKey = await askApiKeyForTag('todos los repositorios', apiKeys);
+    tags.forEach((tag) => (result[tag] = sharedKey));
+  } else {
+    for (let i = 0; i < tags.length; i++) {
+      clearScreen();
+      printHeader(i + 1, tags.length);
+      result[tags[i]] = await askApiKeyForTag(tags[i], apiKeys);
+    }
+  }
+
+  printSummary(tags, result);
+  return result;
+}
+
+async function askApiKeyForTag(tagName: string, apiKeys: ApiKeyInfo[]): Promise<string> {
+  const MANUAL_VALUE = '__manual__';
+
+  const choices = [
+    ...apiKeys.map((k) => ({
+      title: k.url
+        ? `${colors.bright}${k.key}${colors.reset}\n    ${colors.cyan}↳  ${k.url}${colors.reset}`
+        : `${colors.bright}${k.key}${colors.reset}`,
+      value: k.key
+    })),
+    {
+      title: `${colors.bright}Escribir manualmente${colors.reset}`,
+      value: MANUAL_VALUE
+    }
+  ];
+
+  const selectResponse = await prompts({
+    type: 'select',
+    name: 'key',
+    message: `Repositorio  ${colors.bright}${tagName}${colors.reset}`,
+    choices,
+    hint: ' '
+  });
+
+  if (selectResponse.key === undefined) process.exit(0);
+
+  if (selectResponse.key !== MANUAL_VALUE) {
+    return selectResponse.key as string;
+  }
+
+  console.log();
+
+  const textResponse = await prompts({
+    type: 'text',
+    name: 'key',
+    message: `Clave de environment`,
+    hint: 'ej: aprovalmApi',
+    validate: (v: string) => v.trim().length > 0 || 'La clave no puede estar vacía'
+  });
+
+  if (textResponse.key === undefined) process.exit(0);
+
+  return (textResponse.key as string).trim();
+}

package/src/utils/type-mapper.ts

@@ -0,0 +1,14 @@
+/** Translates a primitive OpenAPI/Swagger type to its TypeScript equivalent. */
+export function mapSwaggerTypeToTs(type?: string): string {
+  if (!type) return 'unknown';
+
+  const typeMap: Record<string, string> = {
+    integer: 'number',
+    string: 'string',
+    boolean: 'boolean',
+    number: 'number',
+    array: 'unknown[]',
+    object: 'unknown'
+  };
+  return typeMap[type] || 'unknown';
+}

package/templates/api.repository.contract.mustache

@@ -0,0 +1,34 @@
+{{#apiInfo}}
+{{#apis}}
+{{#operations}}
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+{{#imports}}
+import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+{{/imports}}
+
+/**
+ * {{classname}} Repository Contract
+ * Generated from OpenAPI tag: {{classname}}
+ */
+export interface {{classname}}Repository {
+{{#operation}}
+  /**
+   * {{summary}}
+   {{#notes}}
+   * {{notes}}
+   {{/notes}}
+   {{#allParams}}
+   * @param {{paramName}} {{description}}
+   {{/allParams}}
+   */
+  {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}{{^-last}}, {{/-last}}{{/allParams}}): Observable<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}>;
+
+{{/operation}}
+}
+
+export const {{constantName}}_REPOSITORY = new InjectionToken<{{classname}}Repository>('{{constantName}}_REPOSITORY');
+
+{{/operations}}
+{{/apis}}
+{{/apiInfo}}

package/templates/api.repository.impl.mock.mustache

@@ -0,0 +1,21 @@
+{{#apiInfo}}
+{{#apis}}
+{{#operations}}
+import { MockService } from 'ng-mocks';
+import { of } from 'rxjs';
+
+import { {{classname}}RepositoryImpl } from '@/data/repositories/{{classFilename}}.repository.impl';
+{{#returnImports}}
+import { mock{{classname}}Model } from '@/entities/models/{{classFilename}}.model.mock';
+{{/returnImports}}
+
+export const mock{{classname}}RepositoryImpl = () =>
+  MockService({{classname}}RepositoryImpl, {
+{{#operation}}
+    {{nickname}}: () => of({{#isListContainer}}[mock{{returnBaseType}}Model()]{{/isListContainer}}{{^isListContainer}}{{#returnBaseType}}mock{{returnBaseType}}Model(){{/returnBaseType}}{{^returnBaseType}}undefined{{/returnBaseType}}{{/isListContainer}}),
+{{/operation}}
+  });
+
+{{/operations}}
+{{/apis}}
+{{/apiInfo}}

package/templates/api.repository.impl.mustache

@@ -0,0 +1,58 @@
+{{#apiInfo}}
+{{#apis}}
+{{#operations}}
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { environment } from '@environment';
+
+import { MRepository } from '@mercadona/core/utils/repository';
+
+import { {{classname}}Repository } from '@/domain/repositories/{{classFilename}}.repository.contract';
+{{#returnImports}}
+import { {{classname}}Dto } from '@/dtos/{{classFilename}}.dto';
+import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+import { {{classVarName}}Mapper } from '@/mappers/{{classFilename}}.mapper';
+{{/returnImports}}
+{{#paramImports}}
+import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+{{/paramImports}}
+
+/**
+ * {{classname}} Repository Implementation
+ * Generated from OpenAPI tag: {{classname}}
+ */
+@Injectable()
+export class {{classname}}RepositoryImpl extends MRepository implements {{classname}}Repository {
+  constructor() {
+    super(`${environment.{{environmentApiKey}}.url}`);
+  }
+
+{{#operation}}
+  {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}{{^-last}}, {{/-last}}{{/allParams}}): Observable<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}> {
+    {{#isListContainer}}
+    return this.{{httpMethod}}<{{{returnBaseType}}}Dto>('{{path}}'{{#hasOptions}}, { {{#hasQueryParams}}params: { {{#queryParams}}{{paramName}}{{^-last}}, {{/-last}}{{/queryParams}} }{{/hasQueryParams}}{{#hasBothParamsAndBody}}, {{/hasBothParamsAndBody}}{{#hasBodyParam}}body{{/hasBodyParam}} }{{/hasOptions}})
+      .pipe(
+        map((response) => response.{{#vendorExtensions}}{{x-response-property}}{{/vendorExtensions}}{{^vendorExtensions}}items{{/vendorExtensions}}.map({{{returnBaseTypeVarName}}}Mapper))
+      );
+    {{/isListContainer}}
+    {{^isListContainer}}
+    {{#returnType}}
+    return this.{{httpMethod}}<{{{returnType}}}Dto>('{{path}}'{{#hasOptions}}, { {{#hasQueryParams}}params: { {{#queryParams}}{{paramName}}{{^-last}}, {{/-last}}{{/queryParams}} }{{/hasQueryParams}}{{#hasBothParamsAndBody}}, {{/hasBothParamsAndBody}}{{#hasBodyParam}}body{{/hasBodyParam}} }{{/hasOptions}})
+      .pipe(
+        map({{{returnTypeVarName}}}Mapper)
+      );
+    {{/returnType}}
+    {{^returnType}}
+    return this.{{httpMethod}}<void>('{{path}}'{{#hasOptions}}, { {{#hasQueryParams}}params: { {{#queryParams}}{{paramName}}{{^-last}}, {{/-last}}{{/queryParams}} }{{/hasQueryParams}}{{#hasBothParamsAndBody}}, {{/hasBothParamsAndBody}}{{#hasBodyParam}}body{{/hasBodyParam}} }{{/hasOptions}});
+    {{/returnType}}
+    {{/isListContainer}}
+  }
+
+{{/operation}}
+}
+
+{{/operations}}
+{{/apis}}
+{{/apiInfo}}