interface ApisixResponse { node?: { key: string; value: T; createdIndex?: number; modifiedIndex?: number; }; key?: string; value?: T; createdIndex?: number; modifiedIndex?: number; action?: string; } interface ApisixListResponse { total?: number; list?: Array<{ key: string; value: T; createdIndex?: number; modifiedIndex?: number; }>; has_more?: boolean; node?: { key: string; nodes: Array<{ key: string; value: T; createdIndex?: number; modifiedIndex?: number; }>; dir?: boolean; }; count?: number; action?: string; } interface ListOptions { page?: number; page_size?: number; name?: string; label?: string; uri?: string; search?: string; sort?: string; order?: "asc" | "desc"; status?: 0 | 1; method?: string | string[]; host?: string; plugin?: string; upstream_id?: string; service_id?: string; consumer_id?: string; created_after?: number; created_before?: number; updated_after?: number; updated_before?: number; fields?: string[]; exclude_fields?: string[]; with_count?: boolean; [key: string]: string | number | boolean | string[] | undefined; } interface ErrorResponse { error_msg: string; } interface Route { id?: string; name?: string; desc?: string; uri?: string; uris?: string[]; methods?: string[]; host?: string; hosts?: string[]; remote_addr?: string; remote_addrs?: string[]; vars?: Array<[string, string, string]>; filter_func?: string; plugins?: Record; upstream?: Upstream; upstream_id?: string; service_id?: string; plugin_config_id?: string; priority?: number; enable_websocket?: boolean; timeout?: { connect?: number; send?: number; read?: number; }; status?: 0 | 1; labels?: Record; create_time?: number; update_time?: number; } interface Service { id?: string; name?: string; desc?: string; upstream?: Upstream; upstream_id?: string; plugins?: Record; plugin_config_id?: string; hosts?: string[]; enable_websocket?: boolean; labels?: Record; create_time?: number; update_time?: number; } type UpstreamType = "roundrobin" | "chash" | "ewma" | "least_conn"; type HashOn = "vars" | "header" | "cookie" | "consumer"; type HealthCheckType = "http" | "https" | "tcp"; type UpstreamScheme = "http" | "https" | "grpc" | "grpcs" | "tcp" | "udp" | "tls"; type PassHost = "pass" | "node" | "rewrite"; interface UpstreamNode { host: string; port: number; weight: number; priority?: number; metadata?: Record; } interface HealthCheck { active?: { type?: HealthCheckType; timeout?: number; concurrency?: number; http_path?: string; https_verify_certificate?: boolean; req_headers?: string[]; healthy?: { interval?: number; http_statuses?: number[]; successes?: number; }; unhealthy?: { interval?: number; http_statuses?: number[]; http_failures?: number; tcp_failures?: number; timeouts?: number; }; }; passive?: { type?: HealthCheckType; healthy?: { http_statuses?: number[]; successes?: number; }; unhealthy?: { http_statuses?: number[]; http_failures?: number; tcp_failures?: number; timeouts?: number; }; }; } interface KeepalivePool { size?: number; idle_timeout?: number; requests?: number; } interface UpstreamTLS { client_cert?: string; client_key?: string; client_cert_id?: string; } interface Upstream { id?: string; name?: string; desc?: string; type?: UpstreamType; nodes?: Record | UpstreamNode[]; service_name?: string; discovery_type?: string; hash_on?: HashOn; key?: string; checks?: HealthCheck; retries?: number; retry_timeout?: number; timeout?: { connect?: number; send?: number; read?: number; }; keepalive_pool?: KeepalivePool; scheme?: UpstreamScheme; pass_host?: PassHost; upstream_host?: string; tls?: UpstreamTLS; labels?: Record; create_time?: number; update_time?: number; } interface Consumer { id?: string; username: string; desc?: string; plugins?: Record; group_id?: string; labels?: Record; create_time?: number; update_time?: number; } interface Credential { id?: string; plugins: Record; desc?: string; labels?: Record; create_time?: number; update_time?: number; } interface SSL { id?: string; cert: string; key: string; certs?: string[]; keys?: string[]; snis?: string[]; client?: { ca?: string; depth?: number; skip_mtls_uri_regex?: string[]; }; labels?: Record; status?: 0 | 1; type?: "server" | "client"; ssl_protocols?: string[]; validity_start?: number; validity_end?: number; create_time?: number; update_time?: number; } interface GlobalRule { id?: string; plugins?: Record; create_time?: number; update_time?: number; } interface ConsumerGroup { id?: string; desc?: string; plugins?: Record; labels?: Record; create_time?: number; update_time?: number; } interface PluginConfig { id?: string; desc?: string; plugins?: Record; labels?: Record; create_time?: number; update_time?: number; } interface StreamRoute { id?: string; desc?: string; remote_addr?: string; remote_addrs?: string[]; server_addr?: string; server_port?: number; sni?: string; upstream?: Upstream; upstream_id?: string; service_id?: string; plugins?: Record; protocol?: { name?: string; conf?: Record; }; create_time?: number; update_time?: number; } interface VaultSecret { id?: string; uri: string; prefix: string; token: string; namespace?: string; create_time?: number; update_time?: number; } interface AWSSecret { id?: string; access_key_id: string; secret_access_key: string; session_token?: string; region?: string; endpoint_url?: string; create_time?: number; update_time?: number; } interface GCPAuthConfig { client_email: string; private_key: string; project_id: string; token_uri?: string; entries_uri?: string; scope?: string[]; } interface GCPSecret { id?: string; auth_config?: GCPAuthConfig; auth_file?: string; ssl_verify?: boolean; create_time?: number; update_time?: number; } type Secret = VaultSecret | AWSSecret | GCPSecret; interface Plugin { name: string; version?: string; priority?: number; schema?: object; consumer_schema?: object; metadata_schema?: object; type?: string; disable?: boolean; } interface PluginInfo { name: string; version?: string; priority?: number; type?: string; status?: "enabled" | "disabled"; [key: string]: unknown; } interface PluginList { [key: string]: boolean; } interface PluginMetadata { id?: string; [key: string]: unknown; } interface HealthCheckStatus { status: "ok" | "error"; info?: { version: string; hostname: string; up_time: number; }; } interface UpstreamHealthNode { host: string; port: number; status: "healthy" | "unhealthy" | "mostly_healthy" | "mostly_unhealthy"; counter: { http_failure: number; tcp_failure: number; timeout_failure: number; success: number; }; } interface UpstreamHealth { name: string; type: "http" | "https" | "tcp"; nodes: UpstreamHealthNode[]; } interface ServerInfo { hostname: string; version: string; up_time: number; boot_time: number; last_report_time: number; etcd_version: string; } interface SchemaInfo { main: { route: { properties: object; }; upstream: { properties: object; }; service: { properties: object; }; consumer: { properties: object; }; ssl: { properties: object; }; [key: string]: { properties: object; }; }; plugins: Record; "stream-plugins": Record; } interface DiscoveryServices { services: Record>; expire: number; last_update: number; } interface ApisixSDKConfig { adminAPI: { baseURL: string; apiKey?: string; timeout?: number; headers?: Record; }; controlAPI?: { baseURL: string; timeout?: number; headers?: Record; }; } type CreateInput = Omit; type UpdateInput = Partial>; interface ForceDeleteOptions { force?: boolean; } interface TTLOptions { ttl?: number; } interface FilterOptions extends ListOptions { name?: string; label?: string; uri?: string; } interface Proto { id?: string; desc?: string; content: string; labels?: Record; create_time?: number; update_time?: number; } interface PrometheusMetrics { metrics: string; } interface RequestStatistics { total_requests: number; requests_per_second: number; average_response_time: number; error_rate: number; } interface ConnectionStatistics { active_connections: number; total_connections: number; requests_per_connection: number; } interface ConsumerCredential { id?: string; plugins: Record; desc?: string; create_time?: number; update_time?: number; } interface DiscoveryDumpNode { host: string; port: number; weight: number; default_weight: number; id: string; client: Record; service: { host: string; port: number; proto: string; enable_ipv6: boolean; }; } interface DiscoveryDump { endpoints: Array<{ endpoints: Array<{ value: string; name: string; }>; id: string; }>; config: Array<{ default_weight: number; id: string; client: Record; service: { host: string; port: string; schema: string; }; shared_size: string; }>; } interface DiscoveryDump { services: Record; } interface DiscoveryDumpFile { path: string; size: number; last_modified: string; } interface VersionConfig { version: string; supportsCredentials: boolean; supportsSecrets: boolean; supportsNewResponseFormat: boolean; supportsStreamRoutes: boolean; supportedPlugins: string[]; deprecatedFeatures: string[]; } interface MigrationRecommendations { newFeatures: string[]; deprecatedFeatures: string[]; breakingChanges: string[]; } interface ValidationResult { valid: boolean; errors: string[]; warnings: string[]; } interface BatchOperation { operation: "create" | "update" | "delete"; id?: string; data?: T; } interface BatchResult { success: boolean; id?: string; data?: T; error?: string; } interface BatchResponse { total: number; successful: number; failed: number; results: BatchResult[]; } interface ImportOptions { strategy?: "replace" | "merge" | "skip_existing"; validate?: boolean; dry_run?: boolean; } interface ExportOptions { format?: "json" | "yaml" | "openapi"; include?: string[]; exclude?: string[]; pretty?: boolean; } interface ImportResult { total: number; created: number; updated: number; skipped: number; errors: Array<{ id?: string; error: string; }>; } interface OpenAPIRoute { operationId?: string; summary?: string; description?: string; tags?: string[]; security?: Array>; parameters?: Array<{ name: string; in: "path" | "query" | "header" | "cookie"; required?: boolean; schema?: object; description?: string; }>; requestBody?: { content: Record; required?: boolean; }; responses?: Record; }>; "x-apisix-upstream"?: Upstream; "x-apisix-plugins"?: Record; "x-apisix-service_id"?: string; "x-apisix-status"?: 0 | 1; "x-apisix-priority"?: number; "x-apisix-enableWebsocket"?: boolean; "x-apisix-labels"?: Record; "x-apisix-vars"?: Array<[string, string, string]>; } interface OpenAPISpec { openapi: string; info: { title: string; version: string; description?: string; license?: { name: string; url?: string; }; }; servers?: Array<{ url: string; description?: string; }>; paths: Record>; components?: { securitySchemes?: Record; schemas?: Record; }; security?: Array>; } declare class ApisixClient { private adminBaseURL; private controlBaseURL; private apiKey?; private adminTimeout; private controlTimeout; private adminHeaders; private controlHeaders; private _serverInfo?; private _apiVersion?; constructor(config: ApisixSDKConfig); /** * Get cached server information or fetch if not available */ getServerInfo(): Promise; /** * Get APISIX version */ getVersion(): Promise; /** * Check if current APISIX version is compatible with specified version */ isVersionCompatible(minVersion: string): Promise; /** * Compare two version strings (returns -1, 0, or 1) */ private compareVersions; /** * Check if APISIX version is 3.0 or later */ isVersion3OrLater(): Promise; /** * Get API version-specific configuration */ getApiVersionConfig(): Promise<{ supportsCredentials: boolean; supportsSecrets: boolean; supportsNewResponseFormat: boolean; supportsStreamRoutes: boolean; supportsPagination: boolean; }>; /** * Make HTTP request with proper authentication and error handling */ protected request(endpoint: string, options?: { method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD"; headers?: Record; body?: Record | string; params?: Record; }): Promise; /** * GET request */ get(endpoint: string, params?: Record): Promise; /** * POST request */ post(endpoint: string, body?: Record | string): Promise; /** * PUT request */ put(endpoint: string, body?: Record | string): Promise; /** * PATCH request */ protected patch(endpoint: string, body?: Record | string): Promise; /** * DELETE request */ protected delete(endpoint: string): Promise; /** * Check if current APISIX version supports pagination */ supportsPagination(): Promise; /** * List resources with optional pagination and filtering * Automatically handles version compatibility */ list(endpoint: string, options?: ListOptions): Promise>; /** * Get single resource */ getOne(endpoint: string, id: string): Promise>; /** * Create resource */ create(endpoint: string, data: Record, id?: string): Promise>; /** * Update resource */ update(endpoint: string, id: string, data: Record): Promise>; /** * Partially update resource */ partialUpdate(endpoint: string, id: string, data: Record): Promise>; /** * Delete resource */ remove(endpoint: string, id: string): Promise>; /** * Delete resource with query parameters (e.g., force delete) */ removeWithQuery(endpoint: string, id: string, queryParams?: Record): Promise>; /** * Extract value from APISIX response format (version-aware) */ extractValue(response: ApisixResponse): Promise; /** * Extract list data from response, handling both v2.x and v3.x formats */ extractList(response: unknown): T[]; /** * Extract pagination info from response */ extractPaginationInfo(response: unknown): { total: number; hasMore: boolean; }; /** * Get configuration for admin API endpoints */ getAdminEndpoint(path: string): string; /** * Get configuration for control API endpoints */ getControlEndpoint(path: string): string; /** * Make Control API request (convenience method) */ controlRequest(endpoint: string, options?: { method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD"; headers?: Record; body?: Record | string; params?: Record; }): Promise; /** * Execute batch operations */ batch(endpoint: string, operations: Array<{ operation: "create" | "update" | "delete"; id?: string; data?: Record; }>, options?: { continueOnError?: boolean; validateBeforeExecution?: boolean; }): Promise<{ total: number; successful: number; failed: number; results: Array<{ success: boolean; id?: string; data?: T; error?: string; }>; }>; /** * Import data from various formats */ importData(endpoint: string, data: T[] | string, options?: { strategy?: "replace" | "merge" | "skip_existing"; validate?: boolean; dryRun?: boolean; }): Promise<{ total: number; created: number; updated: number; skipped: number; errors: Array<{ id?: string; error: string; }>; }>; /** * Export data in various formats */ exportData(endpoint: string, options?: { format?: "json" | "yaml"; include?: string[]; exclude?: string[]; pretty?: boolean; }): Promise; /** * Simple YAML serialization (basic implementation) */ private toYaml; /** * Check if resource exists */ private checkExists; /** * Validate data (placeholder for actual validation logic) */ private validateData; } declare class ConsumerGroups { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all consumer groups with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific consumer group by ID */ get(id: string): Promise; /** * Create a new consumer group */ create(consumerGroup: CreateInput, id?: string): Promise; /** * Update an existing consumer group */ update(id: string, consumerGroup: UpdateInput): Promise; /** * Partially update an existing consumer group */ patch(id: string, consumerGroup: UpdateInput): Promise; /** * Delete a consumer group */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if consumer group exists */ exists(id: string): Promise; /** * List consumer groups with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ consumerGroups: ConsumerGroup[]; total?: number; hasMore?: boolean; }>; /** * Find consumer groups by label */ findByLabel(key: string, value?: string): Promise; /** * Find consumer groups by plugin name */ findByPlugin(pluginName: string): Promise; /** * Add plugin to consumer group */ addPlugin(id: string, pluginName: string, config: Record): Promise; /** * Remove plugin from consumer group */ removePlugin(id: string, pluginName: string): Promise; /** * Update plugin configuration in consumer group */ updatePlugin(id: string, pluginName: string, config: Record): Promise; /** * Add label to consumer group */ addLabel(id: string, key: string, value: string): Promise; /** * Remove label from consumer group */ removeLabel(id: string, key: string): Promise; /** * Clone a consumer group with optional modifications */ clone(sourceId: string, modifications?: Partial, newId?: string): Promise; /** * Get consumer group statistics */ getStatistics(): Promise<{ total: number; pluginUsage: Record; labelUsage: Record; topPlugins: Array<{ plugin: string; count: number; }>; topLabels: Array<{ label: string; count: number; }>; }>; } declare class Consumers { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all consumers with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific consumer by username */ get(username: string): Promise; /** * Create a new consumer */ create(consumer: CreateInput): Promise; /** * Update an existing consumer */ update(username: string, consumer: UpdateInput): Promise; /** * Partially update an existing consumer */ patch(username: string, consumer: UpdateInput): Promise; /** * Delete a consumer */ delete(username: string, options?: { force?: boolean; }): Promise; /** * Check if consumer exists */ exists(username: string): Promise; /** * List consumers with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ consumers: Consumer[]; total?: number; hasMore?: boolean; }>; /** * Find consumers by label */ findByLabel(key: string, value?: string): Promise; /** * List credentials for a consumer */ listCredentials(username: string): Promise; /** * Get a specific credential for a consumer */ getCredential(username: string, credentialId: string): Promise; /** * Create or update a credential for a consumer */ createCredential(username: string, credentialId: string, credential: Omit): Promise; /** * Update a credential for a consumer */ updateCredential(username: string, credentialId: string, credential: Partial>): Promise; /** * Delete a credential for a consumer */ deleteCredential(username: string, credentialId: string): Promise; /** * Add key-auth credential to consumer */ addKeyAuth(username: string, key: string, credentialId?: string): Promise; /** * Add basic-auth credential to consumer */ addBasicAuth(username: string, authUsername: string, password: string, credentialId?: string): Promise; /** * Add JWT auth credential to consumer */ addJwtAuth(username: string, key: string, secret?: string, credentialId?: string): Promise; /** * Add HMAC auth credential to consumer */ addHmacAuth(username: string, accessKey: string, secretKey: string, credentialId?: string): Promise; } declare class Control { private client; constructor(client: ApisixClient); /** * Get runtime upstreams information */ getUpstreams(): Promise[]>; /** * Get specific upstream runtime information */ getUpstream(upstreamId: string): Promise>; /** * Get all available schemas */ getSchemas(): Promise; /** * Get schema for a specific resource type */ getSchema(resourceType: string): Promise>; /** * Get schema for a specific plugin */ getPluginSchema(pluginName: string): Promise>; /** * Check if Control API is healthy */ isHealthy(): Promise; /** * Get server information */ getServerInfo(): Promise; /** * Get all available plugins information * Note: This endpoint is not available via Control API, use Admin API instead */ getPlugins(): Promise; /** * Get upstream health check status * Note: APISIX requires specific upstream ID for health check queries */ getUpstreamHealth(upstreamName?: string): Promise; /** * Check if specific service discovery is available */ hasDiscovery(service: string): Promise; /** * Get available service discovery types */ listDiscoveries(): Promise; /** * Get services dump for service discovery * Note: Requires service discovery to be configured */ getDiscoveryDump(service?: string): Promise; /** * Get discovery dump files list * Note: Requires service discovery to be configured */ getDiscoveryDumpFiles(service?: string): Promise; /** * Get discovery dump file content */ getDiscoveryDumpFile(filename: string): Promise; /** * Get all plugin metadata */ getPluginMetadata(): Promise>; /** * Get specific plugin metadata */ getPluginMetadataById(pluginName: string): Promise<{ id: string; [key: string]: unknown; }>; /** * Get current APISIX configuration */ getConfig(): Promise>; /** * Get active routes */ getRoutes(): Promise[]>; /** * Get specific route runtime information */ getRoute(routeId: string): Promise>; /** * Get active services */ getServices(): Promise[]>; /** * Get specific service runtime information */ getService(serviceId: string): Promise>; /** * Get active consumers */ getConsumers(): Promise[]>; /** * Get specific consumer runtime information */ getConsumer(consumerId: string): Promise>; /** * Get SSL certificates */ getSSLCertificates(): Promise[]>; /** * Get specific SSL certificate */ getSSLCertificate(certId: string): Promise>; /** * Get global rules */ getGlobalRules(): Promise[]>; /** * Get specific global rule */ getGlobalRule(ruleId: string): Promise>; /** * Get consumer groups */ getConsumerGroups(): Promise[]>; /** * Get specific consumer group */ getConsumerGroup(groupId: string): Promise>; /** * Trigger garbage collection */ triggerGC(): Promise<{ message: string; }>; /** * Get system overview with proper error handling for unavailable endpoints */ getSystemOverview(): Promise<{ server: ServerInfo; schemas: SchemaInfo; health: boolean; upstreamHealth: UpstreamHealth[]; discoveryServices?: Record; }>; /** * Get memory usage statistics */ getMemoryStats(): Promise>; /** * Get Prometheus metrics (from Prometheus export server on port 9091) * Note: Prometheus metrics are NOT available via Control API port 9090 */ getPrometheusMetrics(): Promise; /** * Health check endpoint */ healthCheck(): Promise; /** * Trigger plugins reload */ reloadPlugins(): Promise<{ message: string; }>; /** * Validate data against APISIX schemas */ validateSchema(entityType: "route" | "service" | "upstream" | "consumer" | "ssl" | "plugin", data: Record, options?: { pluginName?: string; validatePlugins?: boolean; }): Promise<{ valid: boolean; errors: string[]; warnings: string[]; }>; /** * Validate multiple plugins configuration */ private validatePlugins; /** * Basic validation logic (placeholder for proper JSON schema validation) */ private performBasicValidation; /** * Get configuration validation recommendations */ getValidationRecommendations(): Promise<{ schemaVersion: string; availablePlugins: string[]; deprecatedPlugins: string[]; recommendedSettings: Array<{ category: string; setting: string; description: string; recommended: unknown; }>; }>; /** * Get schema compatibility information */ getSchemaCompatibility(targetVersion?: string): Promise<{ currentVersion: string; targetVersion: string; compatible: boolean; breaking_changes: string[]; new_features: string[]; deprecated_features: string[]; }>; /** * Compare version strings */ private compareVersions; } declare class Credentials { private client; constructor(client: ApisixClient); /** * Create a new credential for a consumer * @param consumerId The consumer ID * @param credential The credential data * @param credentialId Optional credential ID */ create(consumerId: string, credential: CreateInput, credentialId?: string): Promise; /** * Get a specific credential by consumer ID and credential ID */ get(consumerId: string, credentialId: string): Promise; /** * List all credentials for a consumer */ list(consumerId: string, options?: ListOptions): Promise; /** * Update an existing credential */ update(consumerId: string, credentialId: string, credential: UpdateInput): Promise; /** * Partially update an existing credential * Note: PATCH method is not supported for credentials in APISIX * This method will fall back to using PUT method */ patch(consumerId: string, credentialId: string, credential: UpdateInput): Promise; /** * Delete a credential */ delete(consumerId: string, credentialId: string): Promise; /** * Check if credential exists */ exists(consumerId: string, credentialId: string): Promise; /** * List credentials with pagination support */ listPaginated(consumerId: string, page?: number, pageSize?: number, filters?: Record): Promise<{ credentials: Credential[]; total?: number; hasMore?: boolean; }>; /** * Find credentials by plugin type for a consumer */ findByPlugin(consumerId: string, pluginName: string): Promise; /** * Find credentials matching a pattern for a consumer */ findByPattern(consumerId: string, pattern: RegExp): Promise; /** * Clone a credential with optional modifications for a consumer */ clone(sourceConsumerId: string, sourceCredentialId: string, targetConsumerId: string, modifications?: Partial, newCredentialId?: string): Promise; /** * Get credential statistics for a consumer */ getStatistics(consumerId?: string): Promise<{ total: number; byPlugin: Array<{ plugin: string; count: number; }>; byConsumer: Array<{ consumer: string; count: number; }>; }>; } declare class GlobalRules { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all global rules with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific global rule by ID */ get(id: string): Promise; /** * Create a new global rule */ create(globalRule: CreateInput, id?: string): Promise; /** * Update an existing global rule */ update(id: string, globalRule: UpdateInput): Promise; /** * Partially update an existing global rule */ patch(id: string, globalRule: UpdateInput): Promise; /** * Delete a global rule */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if global rule exists */ exists(id: string): Promise; /** * List global rules with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ globalRules: GlobalRule[]; total?: number; hasMore?: boolean; }>; /** * Find global rules by plugin name */ findByPlugin(pluginName: string): Promise; /** * Add plugin to global rule */ addPlugin(id: string, pluginName: string, config: Record): Promise; /** * Remove plugin from global rule */ removePlugin(id: string, pluginName: string): Promise; /** * Update plugin configuration in global rule */ updatePlugin(id: string, pluginName: string, config: Record): Promise; /** * Clone a global rule with optional modifications */ clone(sourceId: string, modifications?: Partial, newId?: string): Promise; /** * Get global rule statistics */ getStatistics(): Promise<{ total: number; pluginUsage: Record; topPlugins: Array<{ plugin: string; count: number; }>; }>; } declare class PluginConfigs { private client; constructor(client: ApisixClient); /** * List all plugin configs */ list(options?: { page?: number; page_size?: number; name?: string; label?: string; }): Promise; /** * Get plugin config by id */ get(id: string): Promise; /** * Create plugin config */ create(data: Omit, id?: string): Promise; /** * Update plugin config */ update(id: string, data: Partial>): Promise; /** * Delete plugin config */ delete(id: string): Promise; /** * Add plugin to config */ addPlugin(id: string, pluginName: string, config: Record): Promise; /** * Remove plugin from config */ removePlugin(id: string, pluginName: string): Promise; /** * Update plugin configuration in plugin config */ updatePlugin(id: string, pluginName: string, config: Record): Promise; /** * Enable/disable plugin in config */ togglePlugin(id: string, pluginName: string, enabled: boolean): Promise; /** * Get plugin configs by label */ getByLabel(label: string, value?: string): Promise; /** * Clone plugin config */ clone(sourceId: string, newId: string, overrides?: Partial>): Promise; /** * Validate plugin config */ validate(config: PluginConfig): Promise<{ valid: boolean; errors?: string[]; }>; /** * Get plugin config template with common plugins */ getTemplate(type: "basic" | "security" | "observability" | "traffic"): Partial; /** * Batch operations for plugin configs */ batchCreate(configs: Array<{ id?: string; data: Omit; }>): Promise; /** * Export plugin config to JSON */ export(id: string): Promise; /** * Import plugin config from JSON */ import(jsonString: string, newId?: string): Promise; } declare class Plugins { private client; private pluginCache; constructor(client: ApisixClient); /** * List all available plugins */ list(): Promise; /** * Get plugin schema */ getSchema(pluginName: string): Promise>; /** * Set plugin global state (enable/disable globally) * Note: This feature may not be available in all APISIX versions */ setGlobalState(pluginName: string, enabled: boolean): Promise; /** * Enable plugin globally */ enable(pluginName: string): Promise; /** * Disable plugin globally */ disable(pluginName: string): Promise; /** * Get plugin metadata */ getMetadata(pluginName: string): Promise; /** * Update plugin metadata */ updateMetadata(pluginName: string, metadata: Omit): Promise; /** * Delete plugin metadata */ deleteMetadata(pluginName: string): Promise; /** * List all plugin metadata */ listMetadata(): Promise; /** * Check if plugin is available */ isAvailable(pluginName: string): Promise; /** * Validate plugin configuration */ validateConfig(pluginName: string, config: Record): Promise<{ valid: boolean; errors?: string[]; }>; /** * Get plugin configuration template */ getConfigTemplate(pluginName: string): Promise>; /** * Get plugins by category */ getPluginCategories(): Record; /** * Get plugins by category */ getPluginsByCategory(category: string): Promise; /** * Get plugin documentation URL */ getPluginDocUrl(pluginName: string): string; /** * Get comprehensive plugin information */ getPluginInfo(pluginName: string): Promise<{ name: string; available: boolean; schema?: Record; metadata?: PluginMetadata; category?: string; docUrl: string; }>; /** * Clear plugin cache (useful when plugins are reloaded) */ clearCache(): void; /** * Get list of available plugins with caching */ getAvailablePlugins(): Promise; } declare class Protos { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all proto definitions with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific proto by ID */ get(id: string): Promise; /** * Create a new proto definition */ create(proto: CreateInput, id?: string): Promise; /** * Update an existing proto definition */ update(id: string, proto: UpdateInput): Promise; /** * Partially update an existing proto definition */ patch(id: string, proto: UpdateInput): Promise; /** * Delete a proto definition */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if proto exists */ exists(id: string): Promise; /** * List protos with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ protos: Proto[]; total?: number; hasMore?: boolean; }>; /** * Find protos by label */ findByLabel(label: string, value?: string): Promise; /** * Clone a proto with optional modifications */ clone(sourceId: string, modifications?: Partial, newId?: string): Promise; /** * Validate protobuf content */ validateProtobufContent(content: string): { valid: boolean; errors?: string[]; }; /** * Create proto with validation */ createWithValidation(proto: CreateInput, id?: string): Promise; /** * Get statistics for proto definitions */ getStatistics(): Promise<{ total: number; labelUsage: Record; topLabels: Array<{ label: string; count: number; }>; }>; } declare class Routes { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all routes with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific route by ID */ get(id: string): Promise; /** * Create a new route */ create(route: CreateInput, id?: string): Promise; /** * Update an existing route */ update(id: string, route: UpdateInput): Promise; /** * Partially update an existing route */ patch(id: string, route: UpdateInput): Promise; /** * Delete a route */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if route exists */ exists(id: string): Promise; /** * List routes with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ routes: Route[]; total?: number; hasMore?: boolean; }>; /** * Find routes by URI pattern */ findByUri(uriPattern: string): Promise; /** * Find routes by method */ findByMethod(method: string): Promise; /** * Find routes by host */ findByHost(host: string): Promise; /** * Enable a route */ enable(id: string): Promise; /** * Disable a route */ disable(id: string): Promise; /** * Clone a route with optional modifications */ clone(sourceId: string, modifications?: Partial, newId?: string): Promise; /** * Get route statistics */ getStatistics(): Promise<{ total: number; enabledCount: number; disabledCount: number; methodDistribution: Array<{ method: string; count: number; }>; topPlugins: Array<{ plugin: string; count: number; }>; hostCount: number; serviceRoutes: number; upstreamRoutes: number; }>; /** * Batch operations on routes */ batchOperations(operations: Array<{ operation: "create" | "update" | "delete"; id?: string; data?: CreateInput | UpdateInput; }>): Promise<{ total: number; successful: number; failed: number; results: Array<{ success: boolean; id?: string; data?: Route; error?: string; }>; }>; /** * Advanced search with multiple criteria */ search(criteria: { uri?: string; uriPattern?: string; methods?: string[]; hosts?: string[]; plugins?: string[]; status?: 0 | 1; hasUpstream?: boolean; hasService?: boolean; labels?: Record; createdAfter?: Date; createdBefore?: Date; }): Promise; /** * Import routes from OpenAPI specification */ importFromOpenAPI(spec: { openapi: string; info: { title: string; version: string; description?: string; }; paths: Record>>; }, options?: { strategy?: "replace" | "merge" | "skip_existing"; defaultUpstream?: Upstream; validateBeforeImport?: boolean; }): Promise<{ total: number; created: number; updated: number; skipped: number; errors: Array<{ path?: string; method?: string; error: string; }>; }>; /** * Export routes to OpenAPI specification */ exportToOpenAPI(options?: { title?: string; version?: string; description?: string; serverUrl?: string; includeDisabled?: boolean; filterByLabels?: Record; }): Promise<{ openapi: string; info: { title: string; version: string; description?: string; }; servers?: Array<{ url: string; }>; paths: Record>>; }>; } declare class Secrets { private client; constructor(client: ApisixClient); listVaultSecrets(options?: ListOptions): Promise; getVaultSecret(id: string): Promise; createVaultSecret(secret: CreateInput, id?: string): Promise; updateVaultSecret(id: string, secret: UpdateInput): Promise; deleteVaultSecret(id: string): Promise; listAWSSecrets(options?: ListOptions): Promise; getAWSSecret(id: string): Promise; createAWSSecret(secret: CreateInput, id?: string): Promise; updateAWSSecret(id: string, secret: UpdateInput): Promise; deleteAWSSecret(id: string): Promise; listGCPSecrets(options?: ListOptions): Promise; getGCPSecret(id: string): Promise; createGCPSecret(secret: CreateInput, id?: string): Promise; updateGCPSecret(id: string, secret: UpdateInput): Promise; deleteGCPSecret(id: string): Promise; listAllSecrets(): Promise<{ vault: VaultSecret[]; aws: AWSSecret[]; gcp: GCPSecret[]; }>; testVaultConnection(id: string): Promise<{ connected: boolean; error?: string; }>; testAWSConnection(id: string): Promise<{ connected: boolean; error?: string; }>; testGCPConnection(id: string): Promise<{ connected: boolean; error?: string; }>; findVaultSecretsByNamespace(namespace: string): Promise; findAWSSecretsByRegion(region: string): Promise; findSecretsByPrefix(prefix: string): Promise; /** * Create a Vault secret with validation */ createVaultSecretWithValidation(config: { uri: string; prefix: string; token: string; namespace?: string; }, id?: string): Promise; /** * Create an AWS secret with validation */ createAWSSecretWithValidation(config: { access_key_id: string; secret_access_key: string; session_token?: string; region?: string; endpoint_url?: string; }, id?: string): Promise; /** * Create a GCP secret with validation */ createGCPSecretWithValidation(config: { auth_config?: { client_email: string; private_key: string; project_id: string; token_uri?: string; entries_uri?: string; scope?: string[]; }; auth_file?: string; ssl_verify?: boolean; }, id?: string): Promise; } declare class Services { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all services with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific service by ID */ get(id: string): Promise; /** * Create a new service */ create(service: CreateInput, id?: string): Promise; /** * Update an existing service */ update(id: string, service: UpdateInput): Promise; /** * Partially update an existing service */ patch(id: string, service: UpdateInput): Promise; /** * Delete a service */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if service exists */ exists(id: string): Promise; /** * List services with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ services: Service[]; total?: number; hasMore?: boolean; }>; /** * Find services by name */ findByName(name: string): Promise; /** * Find services by host */ findByHost(host: string): Promise; /** * Clone a service with optional modifications */ clone(sourceId: string, modifications?: Partial, newId?: string): Promise; /** * Get service statistics */ getStatistics(): Promise<{ total: number; upstreamServices: number; websocketEnabled: number; topPlugins: Array<{ plugin: string; count: number; }>; hostCount: number; pluginConfigServices: number; }>; } declare class SSLCertificates { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all SSL certificates with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific SSL certificate by ID */ get(id: string): Promise; /** * Create a new SSL certificate */ create(ssl: CreateInput, id?: string): Promise; /** * Update an existing SSL certificate */ update(id: string, ssl: UpdateInput): Promise; /** * Partially update an existing SSL certificate */ patch(id: string, ssl: UpdateInput): Promise; /** * Delete an SSL certificate */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if SSL certificate exists */ exists(id: string): Promise; /** * List SSL certificates with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ certificates: SSL[]; total?: number; hasMore?: boolean; }>; /** * Find SSL certificates by SNI (Server Name Indication) */ findBySNI(sni: string): Promise; /** * Find SSL certificates by status */ findByStatus(status: 0 | 1): Promise; /** * Enable an SSL certificate */ enable(id: string): Promise; /** * Disable an SSL certificate */ disable(id: string): Promise; /** * Check if SSL certificate is expired or will expire soon */ checkExpiration(id: string, daysToExpire?: number): Promise<{ isExpired: boolean; willExpireSoon: boolean; daysRemaining?: number; validityEnd?: number; }>; /** * Get all expiring certificates */ getExpiringCertificates(daysToExpire?: number): Promise>; /** * Clone an SSL certificate with optional modifications */ clone(sourceId: string, modifications?: Partial, newId?: string): Promise; } declare class StreamRoutes { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all stream routes with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific stream route by ID */ get(id: string): Promise; /** * Create a new stream route */ create(streamRoute: CreateInput, id?: string): Promise; /** * Update an existing stream route (full update) */ update(id: string, streamRoute: UpdateInput): Promise; /** * Partially update an existing stream route * Note: PATCH method is not supported for stream routes in APISIX * This method will fall back to using PUT method */ patch(id: string, streamRoute: UpdateInput): Promise; /** * Delete a stream route */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if stream route exists */ exists(id: string): Promise; /** * List stream routes with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ streamRoutes: StreamRoute[]; total?: number; hasMore?: boolean; }>; /** * Find stream routes by server address */ findByServerAddress(serverAddr: string): Promise; /** * Find stream routes by server port */ findByServerPort(serverPort: number): Promise; /** * Find stream routes by protocol name */ findByProtocol(protocolName: string): Promise; /** * Find stream routes by SNI */ findBySNI(sni: string): Promise; /** * Find stream routes by remote address */ findByRemoteAddress(remoteAddr: string): Promise; /** * Clone a stream route with optional modifications */ clone(sourceId: string, modifications?: Partial, newId?: string): Promise; /** * Create TCP stream route */ createTCPRoute(data: CreateInput, id?: string): Promise; /** * Create UDP stream route */ createUDPRoute(data: CreateInput, id?: string): Promise; /** * Create TLS stream route */ createTLSRoute(data: CreateInput, id?: string): Promise; /** * Get stream routes by plugin */ getByPlugin(pluginName: string): Promise; /** * Get stream routes by upstream ID */ getByUpstreamId(upstreamId: string): Promise; /** * Get stream routes by service ID */ getByServiceId(serviceId: string): Promise; /** * Validate stream route configuration */ validateConfig(config: CreateInput): { valid: boolean; errors: string[]; }; } declare class Upstreams { private readonly endpoint; private client; constructor(client: ApisixClient); /** * List all upstreams with optional pagination and filtering */ list(options?: ListOptions): Promise; /** * Get a specific upstream by ID */ get(id: string): Promise; /** * Create a new upstream */ create(upstream: CreateInput, id?: string): Promise; /** * Update an existing upstream */ update(id: string, upstream: UpdateInput): Promise; /** * Partially update an existing upstream */ patch(id: string, upstream: UpdateInput): Promise; /** * Delete an upstream */ delete(id: string, options?: { force?: boolean; }): Promise; /** * Check if upstream exists */ exists(id: string): Promise; /** * List upstreams with pagination support (v3 API) */ listPaginated(page?: number, pageSize?: number, filters?: Record): Promise<{ upstreams: Upstream[]; total?: number; hasMore?: boolean; }>; /** * Find upstreams by name */ findByName(name: string): Promise; /** * Find upstreams by type */ findByType(type: "roundrobin" | "chash" | "ewma" | "least_conn"): Promise; /** * Add node to upstream */ addNode(id: string, host: string, port: number, weight?: number): Promise