#!/usr/bin/env node
declare const destructiveTools: ({
    name: string;
    description: string;
    annotations: {
        destructiveHint: boolean;
    };
    inputSchema: {
        type: string;
        properties: {
            name: {
                type: string;
                description: string;
            };
            namespace: {
                type: "string";
                description: string;
                default: string;
            };
            context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    annotations: {
        destructiveHint: boolean;
    };
    inputSchema: {
        type: string;
        properties: {
            operation: {
                type: string;
                description: string;
                enum: string[];
            };
            nodeName: {
                type: string;
                description: string;
            };
            force: {
                type: string;
                description: string;
                default: boolean;
            };
            gracePeriod: {
                type: string;
                description: string;
                default: number;
            };
            deleteLocalData: {
                type: string;
                description: string;
                default: boolean;
            };
            ignoreDaemonsets: {
                type: string;
                description: string;
                default: boolean;
            };
            timeout: {
                type: string;
                description: string;
                default: string;
            };
            dryRun: {
                type: string;
                description: string;
                default: boolean;
            };
            confirmDrain: {
                type: string;
                description: string;
                default: boolean;
            };
        };
        required: string[];
    };
} | {
    readonly name: "cleanup";
    readonly description: "Cleanup all managed resources";
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {};
    };
    readonly annotations: {
        readonly destructiveHint: true;
    };
} | {
    readonly name: "kubectl_delete";
    readonly description: "Delete Kubernetes resources by resource type, name, labels, or from a manifest file";
    readonly annotations: {
        readonly destructiveHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly resourceType: {
                readonly type: "string";
                readonly description: "Type of resource to delete (e.g., pods, deployments, services, etc.)";
            };
            readonly name: {
                readonly type: "string";
                readonly description: "Name of the resource to delete";
            };
            readonly namespace: {
                type: "string";
                description: string;
                default: string;
            };
            readonly labelSelector: {
                readonly type: "string";
                readonly description: "Delete resources matching this label selector (e.g. 'app=nginx')";
            };
            readonly manifest: {
                readonly type: "string";
                readonly description: "YAML manifest defining resources to delete (optional)";
            };
            readonly filename: {
                readonly type: "string";
                readonly description: "Path to a YAML file to delete resources from (optional). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead.";
            };
            readonly allNamespaces: {
                readonly type: "boolean";
                readonly description: "If true, delete resources across all namespaces";
                readonly default: false;
            };
            readonly force: {
                readonly type: "boolean";
                readonly description: "If true, immediately remove resources from API and bypass graceful deletion";
                readonly default: false;
            };
            readonly gracePeriodSeconds: {
                readonly type: "number";
                readonly description: "Period of time in seconds given to the resource to terminate gracefully";
            };
            readonly context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        readonly required: readonly [];
    };
})[];
declare const allTools: ({
    name: string;
    description: string;
    annotations: {
        destructiveHint: boolean;
    };
    inputSchema: {
        type: string;
        properties: {
            name: {
                type: string;
                description: string;
            };
            namespace: {
                type: "string";
                description: string;
                default: string;
            };
            context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    annotations: {
        destructiveHint: boolean;
    };
    inputSchema: {
        type: string;
        properties: {
            operation: {
                type: string;
                description: string;
                enum: string[];
            };
            nodeName: {
                type: string;
                description: string;
            };
            force: {
                type: string;
                description: string;
                default: boolean;
            };
            gracePeriod: {
                type: string;
                description: string;
                default: number;
            };
            deleteLocalData: {
                type: string;
                description: string;
                default: boolean;
            };
            ignoreDaemonsets: {
                type: string;
                description: string;
                default: boolean;
            };
            timeout: {
                type: string;
                description: string;
                default: string;
            };
            dryRun: {
                type: string;
                description: string;
                default: boolean;
            };
            confirmDrain: {
                type: string;
                description: string;
                default: boolean;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    annotations: {
        readOnlyHint: boolean;
    };
    inputSchema: {
        type: string;
        properties: {
            resource: {
                type: string;
                description: string;
            };
            apiVersion: {
                type: string;
                description: string;
            };
            recursive: {
                type: string;
                description: string;
                default: boolean;
            };
            context: {
                type: "string";
                description: string;
                default: string;
            };
            output: {
                type: string;
                description: string;
                enum: string[];
                default: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    annotations: {
        readOnlyHint: boolean;
    };
    inputSchema: {
        type: string;
        properties: {
            apiGroup: {
                type: string;
                description: string;
            };
            namespaced: {
                type: string;
                description: string;
            };
            context: {
                type: string;
                description: string;
                default: string;
            };
            verbs: {
                type: string;
                items: {
                    type: string;
                };
                description: string;
            };
            output: {
                type: string;
                description: string;
                enum: string[];
                default: string;
            };
        };
    };
} | {
    readonly name: "cleanup";
    readonly description: "Cleanup all managed resources";
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {};
    };
    readonly annotations: {
        readonly destructiveHint: true;
    };
} | {
    name: string;
    description: string;
    annotations: {
        title: string;
    };
    inputSchema: {
        type: string;
        properties: {
            resourceType: {
                type: string;
            };
            resourceName: {
                type: string;
            };
            localPort: {
                type: string;
            };
            targetPort: {
                type: string;
            };
            namespace: {
                type: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    annotations: {
        title: string;
    };
    inputSchema: {
        type: string;
        properties: {
            id: {
                type: string;
            };
        };
        required: string[];
    };
} | {
    readonly name: "kubectl_context";
    readonly description: "Manage Kubernetes contexts - list, get, or set the current context";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly operation: {
                readonly type: "string";
                readonly enum: readonly ["list", "get", "set"];
                readonly description: "Operation to perform: list contexts, get current context, or set current context";
                readonly default: "list";
            };
            readonly name: {
                readonly type: "string";
                readonly description: "Name of the context to set as current (required for set operation)";
            };
            readonly showCurrent: {
                readonly type: "boolean";
                readonly description: "When listing contexts, highlight which one is currently active";
                readonly default: true;
            };
            readonly detailed: {
                readonly type: "boolean";
                readonly description: "Include detailed information about the context";
                readonly default: false;
            };
            readonly output: {
                readonly type: "string";
                readonly enum: readonly ["json", "yaml", "name", "custom"];
                readonly description: "Output format";
                readonly default: "json";
            };
        };
        readonly required: readonly ["operation"];
    };
} | {
    readonly name: "kubectl_reconnect";
    readonly description: "Reconnect to the Kubernetes API server by recreating all API clients. Use this after cluster upgrades (e.g., EKS control plane upgrades that rotate ENIs/IPs) to force fresh DNS resolution and new TCP connections.";
    readonly annotations: {
        readonly readOnlyHint: false;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {};
        readonly required: readonly [];
    };
} | {
    readonly name: "kubectl_get";
    readonly description: "Get or list Kubernetes resources by resource type, name, and optionally namespace";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly resourceType: {
                readonly type: "string";
                readonly description: "Type of resource to get (e.g., pods, deployments, services, configmaps, events, etc.)";
            };
            readonly name: {
                readonly type: "string";
                readonly description: "Name of the resource (optional - if not provided, lists all resources of the specified type)";
            };
            readonly namespace: {
                type: "string";
                description: string;
                default: string;
            };
            readonly output: {
                readonly type: "string";
                readonly enum: readonly ["json", "yaml", "wide", "name", "custom"];
                readonly description: "Output format";
                readonly default: "json";
            };
            readonly allNamespaces: {
                readonly type: "boolean";
                readonly description: "If true, list resources across all namespaces";
                readonly default: false;
            };
            readonly labelSelector: {
                readonly type: "string";
                readonly description: "Filter resources by label selector (e.g. 'app=nginx')";
            };
            readonly fieldSelector: {
                readonly type: "string";
                readonly description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')";
            };
            readonly sortBy: {
                readonly type: "string";
                readonly description: "Sort events by a field (default: lastTimestamp). Only applicable for events.";
            };
            readonly context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        readonly required: readonly ["resourceType"];
    };
} | {
    readonly name: "kubectl_describe";
    readonly description: "Describe Kubernetes resources by resource type, name, and optionally namespace";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly resourceType: {
                readonly type: "string";
                readonly description: "Type of resource to describe (e.g., pods, deployments, services, etc.)";
            };
            readonly name: {
                readonly type: "string";
                readonly description: "Name of the resource to describe";
            };
            readonly namespace: {
                type: "string";
                description: string;
                default: string;
            };
            readonly context: {
                type: "string";
                description: string;
                default: string;
            };
            readonly allNamespaces: {
                readonly type: "boolean";
                readonly description: "If true, describe resources across all namespaces";
                readonly default: false;
            };
        };
        readonly required: readonly ["resourceType", "name"];
    };
} | {
    readonly name: "kubectl_apply";
    readonly description: "Apply a Kubernetes YAML manifest from a string or file";
    readonly annotations: {
        readonly destructiveHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly manifest: {
                readonly type: "string";
                readonly description: "YAML manifest to apply";
            };
            readonly filename: {
                readonly type: "string";
                readonly description: "Path to a YAML file to apply (optional - use either manifest or filename). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead.";
            };
            readonly namespace: {
                type: "string";
                description: string;
                default: string;
            };
            readonly dryRun: {
                type: "boolean";
                description: string;
                default: boolean;
            };
            readonly force: {
                readonly type: "boolean";
                readonly description: "If true, immediately remove resources from API and bypass graceful deletion";
                readonly default: false;
            };
            readonly context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        readonly required: readonly [];
    };
} | {
    readonly name: "kubectl_delete";
    readonly description: "Delete Kubernetes resources by resource type, name, labels, or from a manifest file";
    readonly annotations: {
        readonly destructiveHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly resourceType: {
                readonly type: "string";
                readonly description: "Type of resource to delete (e.g., pods, deployments, services, etc.)";
            };
            readonly name: {
                readonly type: "string";
                readonly description: "Name of the resource to delete";
            };
            readonly namespace: {
                type: "string";
                description: string;
                default: string;
            };
            readonly labelSelector: {
                readonly type: "string";
                readonly description: "Delete resources matching this label selector (e.g. 'app=nginx')";
            };
            readonly manifest: {
                readonly type: "string";
                readonly description: "YAML manifest defining resources to delete (optional)";
            };
            readonly filename: {
                readonly type: "string";
                readonly description: "Path to a YAML file to delete resources from (optional). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead.";
            };
            readonly allNamespaces: {
                readonly type: "boolean";
                readonly description: "If true, delete resources across all namespaces";
                readonly default: false;
            };
            readonly force: {
                readonly type: "boolean";
                readonly description: "If true, immediately remove resources from API and bypass graceful deletion";
                readonly default: false;
            };
            readonly gracePeriodSeconds: {
                readonly type: "number";
                readonly description: "Period of time in seconds given to the resource to terminate gracefully";
            };
            readonly context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        readonly required: readonly [];
    };
} | {
    readonly name: "kubectl_create";
    readonly description: "Create Kubernetes resources using various methods (from file or using subcommands)";
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly dryRun: {
                type: "boolean";
                description: string;
                default: boolean;
            };
            readonly output: {
                readonly type: "string";
                readonly enum: readonly ["json", "yaml", "name", "go-template", "go-template-file", "template", "templatefile", "jsonpath", "jsonpath-as-json", "jsonpath-file"];
                readonly description: "Output format. One of: json|yaml|name|go-template|go-template-file|template|templatefile|jsonpath|jsonpath-as-json|jsonpath-file";
                readonly default: "yaml";
            };
            readonly validate: {
                readonly type: "boolean";
                readonly description: "If true, validate resource schema against server schema";
                readonly default: true;
            };
            readonly manifest: {
                readonly type: "string";
                readonly description: "YAML manifest to create resources from";
            };
            readonly filename: {
                readonly type: "string";
                readonly description: "Path to a YAML file to create resources from. The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead.";
            };
            readonly resourceType: {
                readonly type: "string";
                readonly description: "Type of resource to create (namespace, configmap, deployment, service, etc.)";
            };
            readonly name: {
                readonly type: "string";
                readonly description: "Name of the resource to create";
            };
            readonly namespace: {
                type: "string";
                description: string;
                default: string;
            };
            readonly fromLiteral: {
                readonly type: "array";
                readonly items: {
                    readonly type: "string";
                };
                readonly description: "Key-value pair for creating configmap (e.g. [\"key1=value1\", \"key2=value2\"])";
            };
            readonly fromFile: {
                readonly type: "array";
                readonly items: {
                    readonly type: "string";
                };
                readonly description: "Path to file for creating configmap/secret (e.g. [\"key1=/path/to/file1\", \"key2=/path/to/file2\"]). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use \"fromFileContent\" to pass file contents directly instead.";
            };
            readonly fromFileContent: {
                readonly type: "array";
                readonly items: {
                    readonly type: "object";
                    readonly properties: {
                        readonly key: {
                            readonly type: "string";
                            readonly description: "Key to store the content under in the configmap/secret";
                        };
                        readonly content: {
                            readonly type: "string";
                            readonly description: "The file content to store";
                        };
                    };
                    readonly required: readonly ["key", "content"];
                    readonly additionalProperties: false;
                };
                readonly description: "Inline file contents for creating a configmap/secret, provided by the client instead of a server-side path (e.g. [{\"key\": \"app.conf\", \"content\": \"...\"}]). Safe on all transports; use this instead of \"fromFile\" on remote (SSE/Streamable HTTP) servers.";
            };
            readonly secretType: {
                readonly type: "string";
                readonly enum: readonly ["generic", "docker-registry", "tls"];
                readonly description: "Type of secret to create (generic, docker-registry, tls)";
            };
            readonly serviceType: {
                readonly type: "string";
                readonly enum: readonly ["clusterip", "nodeport", "loadbalancer", "externalname"];
                readonly description: "Type of service to create (clusterip, nodeport, loadbalancer, externalname)";
            };
            readonly tcpPort: {
                readonly type: "array";
                readonly items: {
                    readonly type: "string";
                };
                readonly description: "Port pairs for tcp service (e.g. [\"80:8080\", \"443:8443\"])";
            };
            readonly image: {
                readonly type: "string";
                readonly description: "Image to use for the containers in the deployment";
            };
            readonly replicas: {
                readonly type: "number";
                readonly description: "Number of replicas to create for the deployment";
                readonly default: 1;
            };
            readonly port: {
                readonly type: "number";
                readonly description: "Port that the container exposes";
            };
            readonly schedule: {
                readonly type: "string";
                readonly description: "Cron schedule expression for the CronJob (e.g. \"*/5 * * * *\")";
            };
            readonly suspend: {
                readonly type: "boolean";
                readonly description: "Whether to suspend the CronJob";
                readonly default: false;
            };
            readonly command: {
                readonly type: "array";
                readonly items: {
                    readonly type: "string";
                };
                readonly description: "Command to run in the container";
            };
            readonly labels: {
                readonly type: "array";
                readonly items: {
                    readonly type: "string";
                };
                readonly description: "Labels to apply to the resource (e.g. [\"key1=value1\", \"key2=value2\"])";
            };
            readonly annotations: {
                readonly type: "array";
                readonly items: {
                    readonly type: "string";
                };
                readonly description: "Annotations to apply to the resource (e.g. [\"key1=value1\", \"key2=value2\"])";
            };
            readonly context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        readonly required: readonly [];
    };
} | {
    readonly name: "kubectl_logs";
    readonly description: "Get logs from Kubernetes resources like pods, deployments, or jobs";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly resourceType: {
                readonly type: "string";
                readonly enum: readonly ["pod", "deployment", "job", "cronjob"];
                readonly description: "Type of resource to get logs from";
            };
            readonly name: {
                readonly type: "string";
                readonly description: "Name of the resource";
            };
            readonly namespace: {
                type: "string";
                description: string;
                default: string;
            };
            readonly container: {
                readonly type: "string";
                readonly description: "Container name (required when pod has multiple containers)";
            };
            readonly tail: {
                readonly type: "number";
                readonly description: "Number of lines to show from end of logs";
            };
            readonly since: {
                readonly type: "string";
                readonly description: "Show logs since relative time (e.g. '5s', '2m', '3h')";
            };
            readonly sinceTime: {
                readonly type: "string";
                readonly description: "Show logs since absolute time (RFC3339)";
            };
            readonly timestamps: {
                readonly type: "boolean";
                readonly description: "Include timestamps in logs";
                readonly default: false;
            };
            readonly previous: {
                readonly type: "boolean";
                readonly description: "Include logs from previously terminated containers";
                readonly default: false;
            };
            readonly follow: {
                readonly type: "boolean";
                readonly description: "Follow logs output (not recommended, may cause timeouts)";
                readonly default: false;
            };
            readonly labelSelector: {
                readonly type: "string";
                readonly description: "Filter resources by label selector";
            };
            readonly context: {
                type: "string";
                description: string;
                default: string;
            };
        };
        readonly required: readonly ["resourceType", "name", "namespace"];
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {};
        required: never[];
    };
    annotations: {
        readOnlyHint: boolean;
    };
})[];
/**
 * Returns the names in `allowedToolNames` that no tool actually provides.
 *
 * Exported for testing.
 */
export declare function findUnknownToolNames(allowedToolNames: Iterable<string>, knownToolNames: Iterable<string>): string[];
export { allTools, destructiveTools };
