@nest-omni/core 3.1.2-7 → 3.1.2-8

package/http-client/examples/advanced-usage.example.js

@@ -0,0 +1,319 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentHttpService = exports.GitHubHttpService = void 0;
+const common_1 = require("@nestjs/common");
+const decorators_1 = require("../decorators");
+const http_client_service_1 = require("../services/http-client.service");
+let GitHubHttpService = class GitHubHttpService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    getUser(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/users/${username}`);
+        });
+    }
+    searchRepositories(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, sort = 'stars', order = 'desc') {
+            return this.httpClient.get('/search/repositories', {
+                params: {
+                    q: query,
+                    sort,
+                    order,
+                    per_page: 20,
+                },
+            });
+        });
+    }
+    getUserRepositories(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/users/${username}/repos`, {
+                params: {
+                    type: 'owner',
+                    sort: 'updated',
+                    per_page: 50,
+                },
+            });
+        });
+    }
+    createRepository(repoData, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post('/user/repos', repoData, {
+                headers: {
+                    Authorization: `token ${token}`,
+                    Accept: 'application/vnd.github.v3+json',
+                },
+            });
+        });
+    }
+    getRepositoryContributors(owner, repo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/repos/${owner}/${repo}/contributors`);
+        });
+    }
+    getMultipleUsers(usernames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = usernames.map((username) => this.getUser(username).catch((error) => {
+                console.error(`Failed to get user ${username}:`, error.message);
+                return null;
+            }));
+            return Promise.all(promises);
+        });
+    }
+    getRepositoryDetails(owner, repo, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/repos/${owner}/${repo}`);
+        });
+    }
+};
+exports.GitHubHttpService = GitHubHttpService;
+__decorate([
+    (0, decorators_1.HttpRetry)({
+        retries: 5,
+        retryDelay: (retryCount) => Math.pow(2, retryCount) * 1000,
+        retryCondition: (error) => {
+            if (!error.response)
+                return true;
+            const status = error.response.status;
+            return status >= 500 || status === 429;
+        },
+    }),
+    (0, decorators_1.HttpCircuitBreaker)({
+        failureThreshold: 3,
+        recoveryTimeoutMs: 30000,
+    }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 300000,
+        layers: ['cls', 'memory', 'redis'],
+        namespace: 'github',
+    }),
+    (0, decorators_1.HttpLogRequest)({
+        databaseLog: true,
+        logHeaders: true,
+        logBody: false,
+        serviceClass: 'GitHubHttpService',
+        methodName: 'getUser',
+        operationName: 'github.getUser',
+    }),
+    (0, decorators_1.HttpTimeout)(15000),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getUser", null);
+__decorate([
+    (0, decorators_1.HttpRetry)({ retries: 3 }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 600000,
+        layers: ['memory', 'redis'],
+        namespace: 'github-search',
+        condition: (args) => args[0].length > 2,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "searchRepositories", null);
+__decorate([
+    (0, decorators_1.HttpUseProxy)({
+        host: 'proxy.example.com',
+        port: 8080,
+        protocol: 'http',
+    }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 120000,
+        namespace: 'github-repos',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getUserRepositories", null);
+__decorate([
+    (0, decorators_1.HttpLogRequest)({
+        logHeaders: true,
+        logBody: true,
+        databaseLog: true,
+        sanitizeHeaders: ['authorization', 'x-api-key'],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "createRepository", null);
+__decorate([
+    (0, decorators_1.HttpCircuitBreaker)({
+        failureThreshold: 5,
+        recoveryTimeoutMs: 60000,
+    }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 900000,
+        namespace: 'github-contributors',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getRepositoryContributors", null);
+__decorate([
+    (0, decorators_1.HttpCacheable)({
+        ttl: 120000,
+        layers: ['memory'],
+        namespace: 'github-repo-details',
+        condition: (args) => { var _a; return ((_a = args[2]) === null || _a === void 0 ? void 0 : _a.public) === true; },
+        unless: (result, args) => (result === null || result === void 0 ? void 0 : result.archived) === true,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getRepositoryDetails", null);
+exports.GitHubHttpService = GitHubHttpService = __decorate([
+    (0, decorators_1.HttpClient)({
+        baseURL: 'https://api.github.com',
+        timeout: 10000,
+        cache: {
+            enabled: true,
+            defaultTtl: 300000,
+            options: {
+                layers: ['memory', 'redis'],
+            },
+        },
+        logging: {
+            enabled: true,
+            logHeaders: true,
+            logBody: true,
+            sanitizeHeaders: ['authorization'],
+        },
+    }),
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService])
+], GitHubHttpService);
+let PaymentHttpService = class PaymentHttpService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    createPayment(paymentData, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post('/payments', paymentData, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'X-Idempotency-Key': this.generateIdempotencyKey(),
+                    'Content-Type': 'application/json',
+                },
+            });
+        });
+    }
+    getPaymentStatus(paymentId, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/payments/${paymentId}`, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+        });
+    }
+    refundPayment(paymentId, refundData, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post(`/payments/${paymentId}/refund`, refundData, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'X-Idempotency-Key': this.generateIdempotencyKey(),
+                },
+            });
+        });
+    }
+    callExternalApi(url_1) {
+        return __awaiter(this, arguments, void 0, function* (url, method = 'GET', data) {
+            const { CallStackExtractor } = require('../utils');
+            CallStackExtractor.setCallInfo('PaymentHttpService', 'callExternalApi', `payment.${method.toLowerCase()}`);
+            try {
+                return this.httpClient.request({
+                    url,
+                    method,
+                    data,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: 'Bearer token123',
+                    },
+                });
+            }
+            finally {
+                CallStackExtractor.clearCallInfo();
+            }
+        });
+    }
+    generateIdempotencyKey() {
+        return `pay_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+};
+exports.PaymentHttpService = PaymentHttpService;
+__decorate([
+    (0, decorators_1.HttpLogRequest)({
+        logHeaders: false,
+        logBody: false,
+        databaseLog: false,
+    }),
+    (0, decorators_1.HttpTimeout)(10000),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], PaymentHttpService.prototype, "createPayment", null);
+__decorate([
+    (0, decorators_1.HttpCacheable)({
+        ttl: 30000,
+        layers: ['redis'],
+        namespace: 'payment-status',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], PaymentHttpService.prototype, "getPaymentStatus", null);
+__decorate([
+    (0, decorators_1.HttpRetry)({
+        retries: 2,
+        retryDelay: (retryCount) => retryCount * 2000,
+        retryCondition: (error) => {
+            if (!error.response)
+                return true;
+            return error.response.status >= 500;
+        },
+    }),
+    (0, decorators_1.HttpLogRequest)({
+        logHeaders: false,
+        logBody: false,
+        databaseLog: true,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, String]),
+    __metadata("design:returntype", Promise)
+], PaymentHttpService.prototype, "refundPayment", null);
+exports.PaymentHttpService = PaymentHttpService = __decorate([
+    (0, decorators_1.HttpClient)({
+        baseURL: 'https://api.payment-provider.com',
+        timeout: 15000,
+        retry: {
+            enabled: false,
+        },
+        logging: {
+            enabled: true,
+            logHeaders: false,
+            logBody: false,
+            sanitizeHeaders: ['authorization', 'x-api-key', 'x-client-secret'],
+        },
+    }),
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService])
+], PaymentHttpService);

package/http-client/examples/basic-usage.example.d.ts

@@ -0,0 +1,61 @@
+import { HttpClientService, HttpLogQueryService } from '../services';
+import { HttpLogQueryOptions } from '../entities';
+export declare class BasicHttpExample {
+    private readonly httpClient;
+    private readonly logQueryService;
+    constructor(httpClient: HttpClientService, logQueryService: HttpLogQueryService);
+    getUser(id: string): Promise<any>;
+    searchUsers(query: string, page?: number, limit?: number): Promise<any>;
+    createUser(userData: any): Promise<any>;
+    updateUser(id: string, userData: any): Promise<any>;
+    deleteUser(id: string): Promise<any>;
+    uploadFile(file: Buffer, filename: string): Promise<any>;
+    customRequest(): Promise<any>;
+    getStatistics(): any;
+    resetStatistics(): void;
+    generateCurlForRequest(url: string, method?: string, data?: any): string;
+    queryHttpLogs(options?: HttpLogQueryOptions): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    findErrorLogs(limit?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+    }>;
+    findSlowRequests(minResponseTime?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+    }>;
+    findRetryLogs(minRetries?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+    }>;
+    findLogsByServiceClass(serviceClass: string, limit?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    findLogsByMethodName(methodName: string, limit?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    findLogsByOperationName(operationName: string, limit?: number): Promise<{
+        logs: import("../entities").HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    getHttpStats(startDate?: Date, endDate?: Date): Promise<import("../entities").HttpLogStats>;
+    findLogByRequestId(requestId: string): Promise<import("../entities").HttpLogEntity>;
+    findLogsByCorrelationId(correlationId: string): Promise<any>;
+    cleanupOldLogs(daysToKeep?: number): Promise<number>;
+}

package/http-client/examples/basic-usage.example.js

@@ -0,0 +1,171 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicHttpExample = void 0;
+const common_1 = require("@nestjs/common");
+const services_1 = require("../services");
+let BasicHttpExample = class BasicHttpExample {
+    constructor(httpClient, logQueryService) {
+        this.httpClient = httpClient;
+        this.logQueryService = logQueryService;
+    }
+    getUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/users/${id}`);
+        });
+    }
+    searchUsers(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, page = 1, limit = 10) {
+            return this.httpClient.get('/users', {
+                params: {
+                    q: query,
+                    page,
+                    limit,
+                },
+            });
+        });
+    }
+    createUser(userData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post('/users', userData, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        });
+    }
+    updateUser(id, userData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.put(`/users/${id}`, userData);
+        });
+    }
+    deleteUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.delete(`/users/${id}`);
+        });
+    }
+    uploadFile(file, filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formData = new FormData();
+            formData.append('file', new Blob([file]), filename);
+            return this.httpClient.post('/upload', formData, {
+                headers: {
+                    'Content-Type': 'multipart/form-data',
+                },
+            });
+        });
+    }
+    customRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.request({
+                method: 'PATCH',
+                url: '/users/123',
+                data: { name: 'New Name' },
+                headers: {
+                    Authorization: 'Bearer token123',
+                    'X-Custom-Header': 'custom-value',
+                },
+                timeout: 5000,
+                params: {
+                    fields: 'id,name,email',
+                },
+            });
+        });
+    }
+    getStatistics() {
+        return this.httpClient.getStats();
+    }
+    resetStatistics() {
+        this.httpClient.resetStats();
+    }
+    generateCurlForRequest(url, method = 'GET', data) {
+        const config = {
+            url,
+            method,
+            data,
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': 'MyApp/1.0',
+            },
+        };
+        return this.httpClient.generateCurlCommand(config);
+    }
+    queryHttpLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            return this.logQueryService.findLogs(options);
+        });
+    }
+    findErrorLogs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 10) {
+            return this.logQueryService.findErrorLogs({ limit });
+        });
+    }
+    findSlowRequests() {
+        return __awaiter(this, arguments, void 0, function* (minResponseTime = 5000) {
+            return this.logQueryService.findSlowRequests(minResponseTime);
+        });
+    }
+    findRetryLogs() {
+        return __awaiter(this, arguments, void 0, function* (minRetries = 2) {
+            return this.logQueryService.findRetryLogs({ minRetries });
+        });
+    }
+    findLogsByServiceClass(serviceClass_1) {
+        return __awaiter(this, arguments, void 0, function* (serviceClass, limit = 20) {
+            return this.logQueryService.findLogs({ serviceClass, limit });
+        });
+    }
+    findLogsByMethodName(methodName_1) {
+        return __awaiter(this, arguments, void 0, function* (methodName, limit = 20) {
+            return this.logQueryService.findLogs({ methodName, limit });
+        });
+    }
+    findLogsByOperationName(operationName_1) {
+        return __awaiter(this, arguments, void 0, function* (operationName, limit = 20) {
+            return this.logQueryService.findLogs({ operationName, limit });
+        });
+    }
+    getHttpStats(startDate, endDate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.logQueryService.getStats({ startDate, endDate });
+        });
+    }
+    findLogByRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.logQueryService.findLogByRequestId(requestId);
+        });
+    }
+    findLogsByCorrelationId(correlationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.logQueryService.findLogsByCorrelationId(correlationId);
+        });
+    }
+    cleanupOldLogs() {
+        return __awaiter(this, arguments, void 0, function* (daysToKeep = 30) {
+            return this.logQueryService.deleteOldLogs(daysToKeep);
+        });
+    }
+};
+exports.BasicHttpExample = BasicHttpExample;
+exports.BasicHttpExample = BasicHttpExample = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [services_1.HttpClientService,
+        services_1.HttpLogQueryService])
+], BasicHttpExample);

package/http-client/examples/index.d.ts

@@ -0,0 +1,3 @@
+export * from './basic-usage.example';
+export * from './advanced-usage.example';
+export * from './multi-api-configuration.example';

package/http-client/examples/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./basic-usage.example"), exports);
+__exportStar(require("./advanced-usage.example"), exports);
+__exportStar(require("./multi-api-configuration.example"), exports);

package/http-client/examples/multi-api-configuration.example.d.ts

@@ -0,0 +1,98 @@
+import { ApiClientInstanceConfig, ApiClientRegistryService } from '../services/api-client-registry.service';
+export declare class GitHubApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get github(): GitHubApiClient;
+    private initializeClients;
+}
+export interface GitHubApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    delete<T = any>(url: string, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class StripeApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get stripe(): StripeApiClient;
+    private initializeClients;
+}
+export interface StripeApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class WeChatApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get wechat(): WeChatApiClient;
+    private initializeClients;
+}
+export interface WeChatApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class CustomApiService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    get customApi(): CustomApiClient;
+    private initializeClients;
+    private getValidToken;
+    private refreshToken;
+    private generateSignature;
+}
+export interface CustomApiClient {
+    get<T = any>(url: string, config?: any): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    patch<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    delete<T = any>(url: string, config?: any): Promise<T>;
+    request<T = any>(config: any): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export declare class ApiManagementService {
+    private readonly apiRegistry;
+    constructor(apiRegistry: ApiClientRegistryService);
+    createDynamicClient(name: string, config: Partial<ApiClientInstanceConfig>): any;
+    getAllStats(): Record<string, any>;
+    resetAllStats(): void;
+    healthCheck(): Promise<{
+        status: "healthy" | "unhealthy";
+        clients: Record<string, {
+            status: "healthy" | "unhealthy";
+            error?: string;
+        }>;
+    }>;
+    createMultipleClients(configs: ApiClientInstanceConfig[]): void;
+    listClients(): string[];
+}
+export declare class ExampleController {
+    private readonly githubApi;
+    private readonly stripeApi;
+    private readonly wechatApi;
+    private readonly customApi;
+    private readonly apiManagement;
+    constructor(githubApi: GitHubApiService, stripeApi: StripeApiService, wechatApi: WeChatApiService, customApi: CustomApiService, apiManagement: ApiManagementService);
+    getGitHubUser(username: string): Promise<any>;
+    createStripePayment(amount: number, currency: string): Promise<any>;
+    sendWeChatMessage(openid: string, content: string): Promise<any>;
+    getCustomData(id: string): Promise<any>;
+    callDynamicApi(url: string): Promise<any>;
+    getApiHealth(): Promise<{
+        status: "healthy" | "unhealthy";
+        clients: Record<string, {
+            status: "healthy" | "unhealthy";
+            error?: string;
+        }>;
+    }>;
+    getApiStats(): Promise<Record<string, any>>;
+}