aiox-core 5.0.2 → 5.0.4

package/.aiox-core/development/templates/service-template/client.ts.hbs

@@ -1,403 +1,403 @@
-/**
- * HTTP client for {{pascalCase serviceName}} API integration.
- * Includes rate limiting, retry logic with exponential backoff, and request logging.
- * @module @aiox/{{kebabCase serviceName}}/client
- * @story {{storyId}}
- */
-
-{{#if isApiIntegration}}
-import type {
-  {{pascalCase serviceName}}Config,
-  {{pascalCase serviceName}}ApiResponse,
-  {{pascalCase serviceName}}RequestOptions,
-  {{pascalCase serviceName}}RateLimit,
-} from './types';
-import {
-  {{pascalCase serviceName}}Error,
-  {{pascalCase serviceName}}ErrorCode,
-  {{pascalCase serviceName}}Errors,
-} from './errors';
-
-/**
- * Default configuration values.
- */
-const DEFAULTS = {
-  baseUrl: '{{apiBaseUrl}}',
-  timeout: 30000,
-  maxRetries: 3,
-  retryBaseDelay: 1000,
-  retryMaxDelay: 30000,
-  debug: false,
-};
-
-/**
- * HTTP client for {{pascalCase serviceName}} API.
- */
-export class {{pascalCase serviceName}}Client {
-  private readonly config: Required<Pick<{{pascalCase serviceName}}Config, 'baseUrl' | 'timeout' | 'maxRetries' | 'debug'>> & {{pascalCase serviceName}}Config;
-  private rateLimit: {{pascalCase serviceName}}RateLimit | null = null;
-
-  constructor(config: {{pascalCase serviceName}}Config) {
-    this.config = {
-      ...config,
-      baseUrl: config.baseUrl ?? DEFAULTS.baseUrl,
-      timeout: config.timeout ?? DEFAULTS.timeout,
-      maxRetries: config.maxRetries ?? DEFAULTS.maxRetries,
-      debug: config.debug ?? DEFAULTS.debug,
-    };
-  }
-
-  /**
-   * Make an API request with automatic retry and rate limiting.
-   */
-  async request<T>(
-    endpoint: string,
-    options: {{pascalCase serviceName}}RequestOptions = {}
-  ): Promise<{{pascalCase serviceName}}ApiResponse<T>> {
-    const {
-      method = 'GET',
-      headers = {},
-      body,
-      params,
-      timeout = this.config.timeout,
-      noRetry = false,
-    } = options;
-
-    // Build URL with query parameters
-    const url = this.buildUrl(endpoint, params);
-
-    // Wait for rate limit if necessary
-    await this.waitForRateLimit();
-
-    const requestHeaders: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'Accept': 'application/json',
-      ...this.getAuthHeaders(),
-      ...headers,
-    };
-
-    const requestInit: RequestInit = {
-      method,
-      headers: requestHeaders,
-      body: body ? JSON.stringify(body) : undefined,
-    };
-
-    // Retry logic
-    const maxAttempts = noRetry ? 1 : this.config.maxRetries + 1;
-    let lastError: Error | null = null;
-
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        this.debug(`Request attempt ${attempt}/${maxAttempts}: ${method} ${url}`);
-
-        const response = await this.fetchWithTimeout(url, requestInit, timeout);
-
-        // Update rate limit info from headers
-        this.updateRateLimit(response.headers);
-
-        // Handle rate limiting (429)
-        if (response.status === 429) {
-          const retryAfter = this.getRetryAfter(response.headers);
-          if (attempt < maxAttempts) {
-            this.debug(`Rate limited, waiting ${retryAfter}ms before retry`);
-            await this.sleep(retryAfter);
-            continue;
-          }
-          throw {{pascalCase serviceName}}Errors.rateLimitError(
-            Math.ceil(retryAfter / 1000),
-            this.rateLimit ?? { remaining: 0, reset: Date.now() + retryAfter }
-          );
-        }
-
-        // Parse response
-        const data = await this.parseResponse<T>(response);
-
-        // Handle error responses
-        if (!response.ok) {
-          throw this.handleErrorResponse(response.status, data);
-        }
-
-        return {
-          success: true,
-          data: data as T,
-          meta: {
-            requestId: response.headers.get('x-request-id') ?? undefined,
-            rateLimit: this.rateLimit ?? undefined,
-          },
-        };
-      } catch (error) {
-        lastError = error as Error;
-
-        // Don't retry on certain errors
-        if (
-          error instanceof {{pascalCase serviceName}}Error &&
-          [
-            {{pascalCase serviceName}}ErrorCode.AUTHENTICATION_ERROR,
-            {{pascalCase serviceName}}ErrorCode.AUTHORIZATION_ERROR,
-            {{pascalCase serviceName}}ErrorCode.CONFIGURATION_ERROR,
-          ].includes(error.code)
-        ) {
-          throw error;
-        }
-
-        // Retry with exponential backoff
-        if (attempt < maxAttempts) {
-          const delay = this.calculateBackoff(attempt);
-          this.debug(`Request failed, retrying in ${delay}ms: ${(error as Error).message}`);
-          await this.sleep(delay);
-        }
-      }
-    }
-
-    // All retries exhausted
-    throw lastError instanceof {{pascalCase serviceName}}Error
-      ? lastError
-      : {{pascalCase serviceName}}Errors.networkError(
-          `Request failed after ${maxAttempts} attempts`,
-          lastError ?? undefined
-        );
-  }
-
-  /**
-   * Convenience method for GET requests.
-   */
-  async get<T>(endpoint: string, params?: Record<string, string | number | boolean>): Promise<T> {
-    const response = await this.request<T>(endpoint, { method: 'GET', params });
-    return response.data as T;
-  }
-
-  /**
-   * Convenience method for POST requests.
-   */
-  async post<T>(endpoint: string, body?: unknown): Promise<T> {
-    const response = await this.request<T>(endpoint, { method: 'POST', body });
-    return response.data as T;
-  }
-
-  /**
-   * Convenience method for PUT requests.
-   */
-  async put<T>(endpoint: string, body?: unknown): Promise<T> {
-    const response = await this.request<T>(endpoint, { method: 'PUT', body });
-    return response.data as T;
-  }
-
-  /**
-   * Convenience method for DELETE requests.
-   */
-  async delete<T>(endpoint: string): Promise<T> {
-    const response = await this.request<T>(endpoint, { method: 'DELETE' });
-    return response.data as T;
-  }
-
-  /**
-   * Health check / ping endpoint.
-   */
-  async ping(): Promise<boolean> {
-    try {
-      await this.get('/ping');
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get current rate limit status.
-   */
-  getRateLimit(): {{pascalCase serviceName}}RateLimit | null {
-    return this.rateLimit;
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Private Methods
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /**
-   * Build full URL with query parameters.
-   */
-  private buildUrl(
-    endpoint: string,
-    params?: Record<string, string | number | boolean>
-  ): string {
-    const baseUrl = this.config.baseUrl.replace(/\/$/, '');
-    const path = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
-    const url = new URL(`${baseUrl}${path}`);
-
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-
-    return url.toString();
-  }
-
-  /**
-   * Get authentication headers.
-   */
-  private getAuthHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {};
-
-{{#each envVars}}
-{{#if this.isAuthHeader}}
-    if (this.config.{{camelCase this.name}}) {
-      headers['{{this.headerName}}'] = {{#if this.headerPrefix}}`{{this.headerPrefix}} ${this.config.{{camelCase this.name}}}`{{else}}this.config.{{camelCase this.name}}{{/if}};
-    }
-{{/if}}
-{{/each}}
-
-    return headers;
-  }
-
-  /**
-   * Fetch with timeout support.
-   */
-  private async fetchWithTimeout(
-    url: string,
-    init: RequestInit,
-    timeout: number
-  ): Promise<Response> {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-    try {
-      const response = await fetch(url, {
-        ...init,
-        signal: controller.signal,
-      });
-      return response;
-    } catch (error) {
-      if ((error as Error).name === 'AbortError') {
-        throw {{pascalCase serviceName}}Errors.timeoutError(`Request timed out after ${timeout}ms`);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-
-  /**
-   * Parse response body.
-   */
-  private async parseResponse<T>(response: Response): Promise<T | null> {
-    const contentType = response.headers.get('content-type');
-
-    if (contentType?.includes('application/json')) {
-      try {
-        return await response.json();
-      } catch {
-        return null;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Handle error response.
-   */
-  private handleErrorResponse(status: number, data: unknown): {{pascalCase serviceName}}Error {
-    const errorData = data as { error?: { message?: string; code?: string } } | null;
-    const message = errorData?.error?.message ?? `Request failed with status ${status}`;
-
-    switch (status) {
-      case 401:
-        return {{pascalCase serviceName}}Errors.authenticationError(message);
-      case 403:
-        return {{pascalCase serviceName}}Errors.authorizationError(message);
-      default:
-        return {{pascalCase serviceName}}Errors.apiError(status, message, errorData ?? undefined);
-    }
-  }
-
-  /**
-   * Update rate limit from response headers.
-   */
-  private updateRateLimit(headers: Headers): void {
-    const limit = headers.get('x-ratelimit-limit');
-    const remaining = headers.get('x-ratelimit-remaining');
-    const reset = headers.get('x-ratelimit-reset');
-
-    if (limit && remaining && reset) {
-      const parsedLimit = parseInt(limit, 10);
-      const parsedRemaining = parseInt(remaining, 10);
-      const parsedReset = parseInt(reset, 10);
-
-      if (isNaN(parsedLimit) || isNaN(parsedRemaining) || isNaN(parsedReset)) {
-        this.debug('Invalid rate limit headers received');
-        return;
-      }
-
-      this.rateLimit = {
-        limit: parsedLimit,
-        remaining: parsedRemaining,
-        reset: parsedReset * 1000, // Convert to milliseconds
-      };
-    }
-  }
-
-  /**
-   * Wait if rate limited.
-   */
-  private async waitForRateLimit(): Promise<void> {
-    if (this.rateLimit && this.rateLimit.remaining <= 0) {
-      const waitTime = Math.max(0, this.rateLimit.reset - Date.now());
-      if (waitTime > 0) {
-        this.debug(`Rate limit reached, waiting ${waitTime}ms`);
-        await this.sleep(waitTime);
-      }
-    }
-  }
-
-  /**
-   * Get retry-after delay from headers.
-   */
-  private getRetryAfter(headers: Headers): number {
-    const retryAfter = headers.get('retry-after');
-    if (retryAfter) {
-      // Could be seconds or HTTP date
-      const seconds = parseInt(retryAfter, 10);
-      if (!isNaN(seconds)) {
-        return seconds * 1000;
-      }
-      const date = new Date(retryAfter);
-      if (!isNaN(date.getTime())) {
-        return Math.max(0, date.getTime() - Date.now());
-      }
-    }
-    return DEFAULTS.retryBaseDelay;
-  }
-
-  /**
-   * Calculate exponential backoff delay.
-   */
-  private calculateBackoff(attempt: number): number {
-    const delay = DEFAULTS.retryBaseDelay * Math.pow(2, attempt - 1);
-    // Add jitter (±25%)
-    const jitter = delay * 0.25 * (Math.random() * 2 - 1);
-    return Math.min(delay + jitter, DEFAULTS.retryMaxDelay);
-  }
-
-  /**
-   * Sleep for specified milliseconds.
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Debug logging.
-   */
-  private debug(message: string): void {
-    if (this.config.debug) {
-      console.debug(`[{{pascalCase serviceName}}Client] ${message}`);
-    }
-  }
-}
-{{else}}
-// This file is only generated for API integrations (isApiIntegration: true)
-export {};
-{{/if}}
+/**
+ * HTTP client for {{pascalCase serviceName}} API integration.
+ * Includes rate limiting, retry logic with exponential backoff, and request logging.
+ * @module @aiox/{{kebabCase serviceName}}/client
+ * @story {{storyId}}
+ */
+
+{{#if isApiIntegration}}
+import type {
+  {{pascalCase serviceName}}Config,
+  {{pascalCase serviceName}}ApiResponse,
+  {{pascalCase serviceName}}RequestOptions,
+  {{pascalCase serviceName}}RateLimit,
+} from './types';
+import {
+  {{pascalCase serviceName}}Error,
+  {{pascalCase serviceName}}ErrorCode,
+  {{pascalCase serviceName}}Errors,
+} from './errors';
+
+/**
+ * Default configuration values.
+ */
+const DEFAULTS = {
+  baseUrl: '{{apiBaseUrl}}',
+  timeout: 30000,
+  maxRetries: 3,
+  retryBaseDelay: 1000,
+  retryMaxDelay: 30000,
+  debug: false,
+};
+
+/**
+ * HTTP client for {{pascalCase serviceName}} API.
+ */
+export class {{pascalCase serviceName}}Client {
+  private readonly config: Required<Pick<{{pascalCase serviceName}}Config, 'baseUrl' | 'timeout' | 'maxRetries' | 'debug'>> & {{pascalCase serviceName}}Config;
+  private rateLimit: {{pascalCase serviceName}}RateLimit | null = null;
+
+  constructor(config: {{pascalCase serviceName}}Config) {
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl ?? DEFAULTS.baseUrl,
+      timeout: config.timeout ?? DEFAULTS.timeout,
+      maxRetries: config.maxRetries ?? DEFAULTS.maxRetries,
+      debug: config.debug ?? DEFAULTS.debug,
+    };
+  }
+
+  /**
+   * Make an API request with automatic retry and rate limiting.
+   */
+  async request<T>(
+    endpoint: string,
+    options: {{pascalCase serviceName}}RequestOptions = {}
+  ): Promise<{{pascalCase serviceName}}ApiResponse<T>> {
+    const {
+      method = 'GET',
+      headers = {},
+      body,
+      params,
+      timeout = this.config.timeout,
+      noRetry = false,
+    } = options;
+
+    // Build URL with query parameters
+    const url = this.buildUrl(endpoint, params);
+
+    // Wait for rate limit if necessary
+    await this.waitForRateLimit();
+
+    const requestHeaders: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      ...this.getAuthHeaders(),
+      ...headers,
+    };
+
+    const requestInit: RequestInit = {
+      method,
+      headers: requestHeaders,
+      body: body ? JSON.stringify(body) : undefined,
+    };
+
+    // Retry logic
+    const maxAttempts = noRetry ? 1 : this.config.maxRetries + 1;
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        this.debug(`Request attempt ${attempt}/${maxAttempts}: ${method} ${url}`);
+
+        const response = await this.fetchWithTimeout(url, requestInit, timeout);
+
+        // Update rate limit info from headers
+        this.updateRateLimit(response.headers);
+
+        // Handle rate limiting (429)
+        if (response.status === 429) {
+          const retryAfter = this.getRetryAfter(response.headers);
+          if (attempt < maxAttempts) {
+            this.debug(`Rate limited, waiting ${retryAfter}ms before retry`);
+            await this.sleep(retryAfter);
+            continue;
+          }
+          throw {{pascalCase serviceName}}Errors.rateLimitError(
+            Math.ceil(retryAfter / 1000),
+            this.rateLimit ?? { remaining: 0, reset: Date.now() + retryAfter }
+          );
+        }
+
+        // Parse response
+        const data = await this.parseResponse<T>(response);
+
+        // Handle error responses
+        if (!response.ok) {
+          throw this.handleErrorResponse(response.status, data);
+        }
+
+        return {
+          success: true,
+          data: data as T,
+          meta: {
+            requestId: response.headers.get('x-request-id') ?? undefined,
+            rateLimit: this.rateLimit ?? undefined,
+          },
+        };
+      } catch (error) {
+        lastError = error as Error;
+
+        // Don't retry on certain errors
+        if (
+          error instanceof {{pascalCase serviceName}}Error &&
+          [
+            {{pascalCase serviceName}}ErrorCode.AUTHENTICATION_ERROR,
+            {{pascalCase serviceName}}ErrorCode.AUTHORIZATION_ERROR,
+            {{pascalCase serviceName}}ErrorCode.CONFIGURATION_ERROR,
+          ].includes(error.code)
+        ) {
+          throw error;
+        }
+
+        // Retry with exponential backoff
+        if (attempt < maxAttempts) {
+          const delay = this.calculateBackoff(attempt);
+          this.debug(`Request failed, retrying in ${delay}ms: ${(error as Error).message}`);
+          await this.sleep(delay);
+        }
+      }
+    }
+
+    // All retries exhausted
+    throw lastError instanceof {{pascalCase serviceName}}Error
+      ? lastError
+      : {{pascalCase serviceName}}Errors.networkError(
+          `Request failed after ${maxAttempts} attempts`,
+          lastError ?? undefined
+        );
+  }
+
+  /**
+   * Convenience method for GET requests.
+   */
+  async get<T>(endpoint: string, params?: Record<string, string | number | boolean>): Promise<T> {
+    const response = await this.request<T>(endpoint, { method: 'GET', params });
+    return response.data as T;
+  }
+
+  /**
+   * Convenience method for POST requests.
+   */
+  async post<T>(endpoint: string, body?: unknown): Promise<T> {
+    const response = await this.request<T>(endpoint, { method: 'POST', body });
+    return response.data as T;
+  }
+
+  /**
+   * Convenience method for PUT requests.
+   */
+  async put<T>(endpoint: string, body?: unknown): Promise<T> {
+    const response = await this.request<T>(endpoint, { method: 'PUT', body });
+    return response.data as T;
+  }
+
+  /**
+   * Convenience method for DELETE requests.
+   */
+  async delete<T>(endpoint: string): Promise<T> {
+    const response = await this.request<T>(endpoint, { method: 'DELETE' });
+    return response.data as T;
+  }
+
+  /**
+   * Health check / ping endpoint.
+   */
+  async ping(): Promise<boolean> {
+    try {
+      await this.get('/ping');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get current rate limit status.
+   */
+  getRateLimit(): {{pascalCase serviceName}}RateLimit | null {
+    return this.rateLimit;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Build full URL with query parameters.
+   */
+  private buildUrl(
+    endpoint: string,
+    params?: Record<string, string | number | boolean>
+  ): string {
+    const baseUrl = this.config.baseUrl.replace(/\/$/, '');
+    const path = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+    const url = new URL(`${baseUrl}${path}`);
+
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+
+    return url.toString();
+  }
+
+  /**
+   * Get authentication headers.
+   */
+  private getAuthHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {};
+
+{{#each envVars}}
+{{#if this.isAuthHeader}}
+    if (this.config.{{camelCase this.name}}) {
+      headers['{{this.headerName}}'] = {{#if this.headerPrefix}}`{{this.headerPrefix}} ${this.config.{{camelCase this.name}}}`{{else}}this.config.{{camelCase this.name}}{{/if}};
+    }
+{{/if}}
+{{/each}}
+
+    return headers;
+  }
+
+  /**
+   * Fetch with timeout support.
+   */
+  private async fetchWithTimeout(
+    url: string,
+    init: RequestInit,
+    timeout: number
+  ): Promise<Response> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetch(url, {
+        ...init,
+        signal: controller.signal,
+      });
+      return response;
+    } catch (error) {
+      if ((error as Error).name === 'AbortError') {
+        throw {{pascalCase serviceName}}Errors.timeoutError(`Request timed out after ${timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  /**
+   * Parse response body.
+   */
+  private async parseResponse<T>(response: Response): Promise<T | null> {
+    const contentType = response.headers.get('content-type');
+
+    if (contentType?.includes('application/json')) {
+      try {
+        return await response.json();
+      } catch {
+        return null;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Handle error response.
+   */
+  private handleErrorResponse(status: number, data: unknown): {{pascalCase serviceName}}Error {
+    const errorData = data as { error?: { message?: string; code?: string } } | null;
+    const message = errorData?.error?.message ?? `Request failed with status ${status}`;
+
+    switch (status) {
+      case 401:
+        return {{pascalCase serviceName}}Errors.authenticationError(message);
+      case 403:
+        return {{pascalCase serviceName}}Errors.authorizationError(message);
+      default:
+        return {{pascalCase serviceName}}Errors.apiError(status, message, errorData ?? undefined);
+    }
+  }
+
+  /**
+   * Update rate limit from response headers.
+   */
+  private updateRateLimit(headers: Headers): void {
+    const limit = headers.get('x-ratelimit-limit');
+    const remaining = headers.get('x-ratelimit-remaining');
+    const reset = headers.get('x-ratelimit-reset');
+
+    if (limit && remaining && reset) {
+      const parsedLimit = parseInt(limit, 10);
+      const parsedRemaining = parseInt(remaining, 10);
+      const parsedReset = parseInt(reset, 10);
+
+      if (isNaN(parsedLimit) || isNaN(parsedRemaining) || isNaN(parsedReset)) {
+        this.debug('Invalid rate limit headers received');
+        return;
+      }
+
+      this.rateLimit = {
+        limit: parsedLimit,
+        remaining: parsedRemaining,
+        reset: parsedReset * 1000, // Convert to milliseconds
+      };
+    }
+  }
+
+  /**
+   * Wait if rate limited.
+   */
+  private async waitForRateLimit(): Promise<void> {
+    if (this.rateLimit && this.rateLimit.remaining <= 0) {
+      const waitTime = Math.max(0, this.rateLimit.reset - Date.now());
+      if (waitTime > 0) {
+        this.debug(`Rate limit reached, waiting ${waitTime}ms`);
+        await this.sleep(waitTime);
+      }
+    }
+  }
+
+  /**
+   * Get retry-after delay from headers.
+   */
+  private getRetryAfter(headers: Headers): number {
+    const retryAfter = headers.get('retry-after');
+    if (retryAfter) {
+      // Could be seconds or HTTP date
+      const seconds = parseInt(retryAfter, 10);
+      if (!isNaN(seconds)) {
+        return seconds * 1000;
+      }
+      const date = new Date(retryAfter);
+      if (!isNaN(date.getTime())) {
+        return Math.max(0, date.getTime() - Date.now());
+      }
+    }
+    return DEFAULTS.retryBaseDelay;
+  }
+
+  /**
+   * Calculate exponential backoff delay.
+   */
+  private calculateBackoff(attempt: number): number {
+    const delay = DEFAULTS.retryBaseDelay * Math.pow(2, attempt - 1);
+    // Add jitter (±25%)
+    const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+    return Math.min(delay + jitter, DEFAULTS.retryMaxDelay);
+  }
+
+  /**
+   * Sleep for specified milliseconds.
+   */
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Debug logging.
+   */
+  private debug(message: string): void {
+    if (this.config.debug) {
+      console.debug(`[{{pascalCase serviceName}}Client] ${message}`);
+    }
+  }
+}
+{{else}}
+// This file is only generated for API integrations (isApiIntegration: true)
+export {};
+{{/if}}