@downatthebottomofthemolehole/terraform-best-practices-mcp-server 2.1.3 → 3.0.0

package/dist/tools/analyze_state_management.d.ts

@@ -4,21 +4,17 @@ declare const analyzeStateManagementInputSchema: z.ZodObject<{
     terraformCode: z.ZodString;
     teamSize: z.ZodDefault<z.ZodNumber>;
     environmentCount: z.ZodDefault<z.ZodNumber>;
-    currentBackend: z.ZodDefault<z.ZodEnum<["auto", "s3", "azurerm", "gcs", "remote", "local", "unknown"]>>;
+    currentBackend: z.ZodDefault<z.ZodEnum<{
+        unknown: "unknown";
+        auto: "auto";
+        s3: "s3";
+        azurerm: "azurerm";
+        gcs: "gcs";
+        remote: "remote";
+        local: "local";
+    }>>;
     useWorkspaces: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    terraformCode: string;
-    teamSize: number;
-    environmentCount: number;
-    currentBackend: "auto" | "s3" | "azurerm" | "gcs" | "remote" | "local" | "unknown";
-    useWorkspaces: boolean;
-}, {
-    terraformCode: string;
-    teamSize?: number | undefined;
-    environmentCount?: number | undefined;
-    currentBackend?: "auto" | "s3" | "azurerm" | "gcs" | "remote" | "local" | "unknown" | undefined;
-    useWorkspaces?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type AnalyzeStateManagementInput = z.infer<typeof analyzeStateManagementInputSchema>;
 export declare const analyzeStateManagementInputJsonSchema: Record<string, unknown>;
 export declare const analyzeStateManagementTool: ToolDefinition<AnalyzeStateManagementInput>;

package/dist/tools/analyze_terraform_code.d.ts

@@ -2,14 +2,14 @@ import { z } from "zod";
 import type { ToolDefinition } from "./types.js";
 declare const analyzeTerraformCodeInputSchema: z.ZodObject<{
     code: z.ZodString;
-    focusArea: z.ZodDefault<z.ZodEnum<["modularity", "variables", "outputs", "locals", "general"]>>;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    focusArea: "modularity" | "variables" | "outputs" | "locals" | "general";
-}, {
-    code: string;
-    focusArea?: "modularity" | "variables" | "outputs" | "locals" | "general" | undefined;
-}>;
+    focusArea: z.ZodDefault<z.ZodEnum<{
+        modularity: "modularity";
+        variables: "variables";
+        outputs: "outputs";
+        locals: "locals";
+        general: "general";
+    }>>;
+}, z.core.$strip>;
 export type AnalyzeTerraformCodeInput = z.infer<typeof analyzeTerraformCodeInputSchema>;
 export declare const analyzeTerraformCodeInputJsonSchema: Record<string, unknown>;
 export declare const analyzeTerraformCodeTool: ToolDefinition<AnalyzeTerraformCodeInput>;

package/dist/tools/analyze_terraform_performance.d.ts

@@ -5,17 +5,7 @@ declare const analyzeTerraformPerformanceInputSchema: z.ZodObject<{
     stateSizeMb: z.ZodOptional<z.ZodNumber>;
     workspaceCount: z.ZodOptional<z.ZodNumber>;
     providerRateLimitSensitive: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    terraformCode: string;
-    providerRateLimitSensitive: boolean;
-    stateSizeMb?: number | undefined;
-    workspaceCount?: number | undefined;
-}, {
-    terraformCode: string;
-    stateSizeMb?: number | undefined;
-    workspaceCount?: number | undefined;
-    providerRateLimitSensitive?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type AnalyzeTerraformPerformanceInput = z.infer<typeof analyzeTerraformPerformanceInputSchema>;
 export declare const analyzeTerraformPerformanceInputJsonSchema: Record<string, unknown>;
 export declare const analyzeTerraformPerformanceTool: ToolDefinition<AnalyzeTerraformPerformanceInput>;

package/dist/tools/common.d.ts

@@ -2,17 +2,9 @@ import { z } from "zod";
 import type { CommandExecutionResult } from "../lib/exec.js";
 export declare const commandToolInputSchema: z.ZodObject<{
     path: z.ZodDefault<z.ZodString>;
-    extraArgs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    extraArgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    extraArgs: string[];
-    timeoutMs?: number | undefined;
-}, {
-    path?: string | undefined;
-    extraArgs?: string[] | undefined;
-    timeoutMs?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type CommandToolInput = z.infer<typeof commandToolInputSchema>;
 export declare const commandToolInputJsonSchema: Record<string, unknown>;
 declare const installHints: Record<string, string>;

package/dist/tools/fetch_provider_best_practices.d.ts

@@ -1,18 +1,14 @@
 import { z } from "zod";
 import type { ToolDefinition } from "./types.js";
 export declare const fetchProviderBestPracticesInputSchema: z.ZodObject<{
-    provider: z.ZodEnum<["azure", "aws", "gcp"]>;
+    provider: z.ZodEnum<{
+        azure: "azure";
+        aws: "aws";
+        gcp: "gcp";
+    }>;
     topic: z.ZodOptional<z.ZodString>;
     liveFetch: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    provider: "azure" | "aws" | "gcp";
-    liveFetch: boolean;
-    topic?: string | undefined;
-}, {
-    provider: "azure" | "aws" | "gcp";
-    topic?: string | undefined;
-    liveFetch?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type FetchProviderBestPracticesInput = z.infer<typeof fetchProviderBestPracticesInputSchema>;
 export declare const fetchProviderBestPracticesInputJsonSchema: Record<string, unknown>;
 export declare const fetchProviderBestPracticesTool: ToolDefinition<FetchProviderBestPracticesInput>;

package/dist/tools/fetch_terraform_best_practices.d.ts

@@ -3,13 +3,7 @@ import type { ToolDefinition } from "./types.js";
 export declare const fetchTerraformBestPracticesInputSchema: z.ZodObject<{
     topic: z.ZodOptional<z.ZodString>;
     liveFetch: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    liveFetch: boolean;
-    topic?: string | undefined;
-}, {
-    topic?: string | undefined;
-    liveFetch?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type FetchTerraformBestPracticesInput = z.infer<typeof fetchTerraformBestPracticesInputSchema>;
 export declare const fetchTerraformBestPracticesInputJsonSchema: Record<string, unknown>;
 export declare const fetchTerraformBestPracticesTool: ToolDefinition<FetchTerraformBestPracticesInput>;

package/dist/tools/fetch_terraform_registry_guidance.d.ts

@@ -6,19 +6,7 @@ export declare const fetchTerraformRegistryGuidanceInputSchema: z.ZodObject<{
     module: z.ZodOptional<z.ZodString>;
     topic: z.ZodOptional<z.ZodString>;
     liveFetch: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    liveFetch: boolean;
-    provider?: string | undefined;
-    topic?: string | undefined;
-    module?: string | undefined;
-    resource?: string | undefined;
-}, {
-    provider?: string | undefined;
-    topic?: string | undefined;
-    liveFetch?: boolean | undefined;
-    module?: string | undefined;
-    resource?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type FetchTerraformRegistryGuidanceInput = z.infer<typeof fetchTerraformRegistryGuidanceInputSchema>;
 export declare const fetchTerraformRegistryGuidanceInputJsonSchema: Record<string, unknown>;
 export declare const fetchTerraformRegistryGuidanceTool: ToolDefinition<FetchTerraformRegistryGuidanceInput>;

package/dist/tools/generate_compliance_summary.d.ts

@@ -4,18 +4,14 @@ declare const generateComplianceSummaryInputSchema: z.ZodObject<{
     checkovOutput: z.ZodOptional<z.ZodString>;
     trivyOutput: z.ZodOptional<z.ZodString>;
     kicsOutput: z.ZodOptional<z.ZodString>;
-    complianceFramework: z.ZodDefault<z.ZodEnum<["cis", "pci-dss", "hipaa", "sox", "general"]>>;
-}, "strip", z.ZodTypeAny, {
-    complianceFramework: "general" | "cis" | "pci-dss" | "hipaa" | "sox";
-    checkovOutput?: string | undefined;
-    trivyOutput?: string | undefined;
-    kicsOutput?: string | undefined;
-}, {
-    checkovOutput?: string | undefined;
-    trivyOutput?: string | undefined;
-    kicsOutput?: string | undefined;
-    complianceFramework?: "general" | "cis" | "pci-dss" | "hipaa" | "sox" | undefined;
-}>;
+    complianceFramework: z.ZodDefault<z.ZodEnum<{
+        general: "general";
+        cis: "cis";
+        "pci-dss": "pci-dss";
+        hipaa: "hipaa";
+        sox: "sox";
+    }>>;
+}, z.core.$strip>;
 export type GenerateComplianceSummaryInput = z.infer<typeof generateComplianceSummaryInputSchema>;
 export declare const generateComplianceSummaryInputJsonSchema: Record<string, unknown>;
 export declare const generateComplianceSummaryTool: ToolDefinition<GenerateComplianceSummaryInput>;

package/dist/tools/generate_cost_report.d.ts

@@ -3,13 +3,7 @@ import type { ToolDefinition } from "./types.js";
 declare const generateCostReportInputSchema: z.ZodObject<{
     infracostJson: z.ZodString;
     includeOptimizations: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    infracostJson: string;
-    includeOptimizations: boolean;
-}, {
-    infracostJson: string;
-    includeOptimizations?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type GenerateCostReportInput = z.infer<typeof generateCostReportInputSchema>;
 export declare const generateCostReportInputJsonSchema: Record<string, unknown>;
 export declare const generateCostReportTool: ToolDefinition<GenerateCostReportInput>;

package/dist/tools/generate_terraform_module_docs.d.ts

@@ -5,17 +5,7 @@ declare const generateTerraformModuleDocsInputSchema: z.ZodObject<{
     moduleName: z.ZodDefault<z.ZodString>;
     includeUsageExample: z.ZodDefault<z.ZodBoolean>;
     includeInputsOutputsTables: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    terraformCode: string;
-    moduleName: string;
-    includeUsageExample: boolean;
-    includeInputsOutputsTables: boolean;
-}, {
-    terraformCode: string;
-    moduleName?: string | undefined;
-    includeUsageExample?: boolean | undefined;
-    includeInputsOutputsTables?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type GenerateTerraformModuleDocsInput = z.infer<typeof generateTerraformModuleDocsInputSchema>;
 export declare const generateTerraformModuleDocsInputJsonSchema: Record<string, unknown>;
 export declare const generateTerraformModuleDocsTool: ToolDefinition<GenerateTerraformModuleDocsInput>;

package/dist/tools/recommend_terraform_modules.d.ts

@@ -2,20 +2,24 @@ import { z } from "zod";
 import type { ToolDefinition } from "./types.js";
 declare const recommendTerraformModulesInputSchema: z.ZodObject<{
     terraformCode: z.ZodString;
-    provider: z.ZodDefault<z.ZodEnum<["aws", "azure", "gcp", "any"]>>;
-    deploymentIntent: z.ZodDefault<z.ZodEnum<["networking", "kubernetes", "serverless", "storage", "database", "observability", "security", "general"]>>;
+    provider: z.ZodDefault<z.ZodEnum<{
+        any: "any";
+        azure: "azure";
+        aws: "aws";
+        gcp: "gcp";
+    }>>;
+    deploymentIntent: z.ZodDefault<z.ZodEnum<{
+        general: "general";
+        security: "security";
+        storage: "storage";
+        networking: "networking";
+        kubernetes: "kubernetes";
+        serverless: "serverless";
+        database: "database";
+        observability: "observability";
+    }>>;
     maxRecommendations: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    provider: "azure" | "aws" | "gcp" | "any";
-    terraformCode: string;
-    deploymentIntent: "general" | "security" | "storage" | "networking" | "kubernetes" | "serverless" | "database" | "observability";
-    maxRecommendations: number;
-}, {
-    terraformCode: string;
-    provider?: "azure" | "aws" | "gcp" | "any" | undefined;
-    deploymentIntent?: "general" | "security" | "storage" | "networking" | "kubernetes" | "serverless" | "database" | "observability" | undefined;
-    maxRecommendations?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type RecommendTerraformModulesInput = z.infer<typeof recommendTerraformModulesInputSchema>;
 export declare const recommendTerraformModulesInputJsonSchema: Record<string, unknown>;
 export declare const recommendTerraformModulesTool: ToolDefinition<RecommendTerraformModulesInput>;

package/dist/tools/run_checkov.d.ts

@@ -2,16 +2,8 @@ import type { CommandToolInput } from "./common.js";
 import type { ToolDefinition } from "./types.js";
 export declare const runCheckovInputSchema: import("zod").ZodObject<{
     path: import("zod").ZodDefault<import("zod").ZodString>;
-    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
     timeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
-}, "strip", import("zod").ZodTypeAny, {
-    path: string;
-    extraArgs: string[];
-    timeoutMs?: number | undefined;
-}, {
-    path?: string | undefined;
-    extraArgs?: string[] | undefined;
-    timeoutMs?: number | undefined;
-}>;
+}, import("zod/v4/core").$strip>;
 export type RunCheckovInput = CommandToolInput;
 export declare const runCheckovTool: ToolDefinition<RunCheckovInput>;

package/dist/tools/run_infracost.d.ts

@@ -2,16 +2,8 @@ import type { CommandToolInput } from "./common.js";
 import type { ToolDefinition } from "./types.js";
 export declare const runInfracostInputSchema: import("zod").ZodObject<{
     path: import("zod").ZodDefault<import("zod").ZodString>;
-    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
     timeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
-}, "strip", import("zod").ZodTypeAny, {
-    path: string;
-    extraArgs: string[];
-    timeoutMs?: number | undefined;
-}, {
-    path?: string | undefined;
-    extraArgs?: string[] | undefined;
-    timeoutMs?: number | undefined;
-}>;
+}, import("zod/v4/core").$strip>;
 export type RunInfracostInput = CommandToolInput;
 export declare const runInfracostTool: ToolDefinition<RunInfracostInput>;

package/dist/tools/run_kics.d.ts

@@ -2,16 +2,8 @@ import type { CommandToolInput } from "./common.js";
 import type { ToolDefinition } from "./types.js";
 export declare const runKicsInputSchema: import("zod").ZodObject<{
     path: import("zod").ZodDefault<import("zod").ZodString>;
-    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
     timeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
-}, "strip", import("zod").ZodTypeAny, {
-    path: string;
-    extraArgs: string[];
-    timeoutMs?: number | undefined;
-}, {
-    path?: string | undefined;
-    extraArgs?: string[] | undefined;
-    timeoutMs?: number | undefined;
-}>;
+}, import("zod/v4/core").$strip>;
 export type RunKicsInput = CommandToolInput;
 export declare const runKicsTool: ToolDefinition<RunKicsInput>;

package/dist/tools/run_tflint.d.ts

@@ -2,16 +2,8 @@ import type { CommandToolInput } from "./common.js";
 import type { ToolDefinition } from "./types.js";
 export declare const runTflintInputSchema: import("zod").ZodObject<{
     path: import("zod").ZodDefault<import("zod").ZodString>;
-    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
     timeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
-}, "strip", import("zod").ZodTypeAny, {
-    path: string;
-    extraArgs: string[];
-    timeoutMs?: number | undefined;
-}, {
-    path?: string | undefined;
-    extraArgs?: string[] | undefined;
-    timeoutMs?: number | undefined;
-}>;
+}, import("zod/v4/core").$strip>;
 export type RunTflintInput = CommandToolInput;
 export declare const runTflintTool: ToolDefinition<RunTflintInput>;

package/dist/tools/run_trivy.d.ts

@@ -2,16 +2,8 @@ import type { CommandToolInput } from "./common.js";
 import type { ToolDefinition } from "./types.js";
 export declare const runTrivyInputSchema: import("zod").ZodObject<{
     path: import("zod").ZodDefault<import("zod").ZodString>;
-    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    extraArgs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
     timeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
-}, "strip", import("zod").ZodTypeAny, {
-    path: string;
-    extraArgs: string[];
-    timeoutMs?: number | undefined;
-}, {
-    path?: string | undefined;
-    extraArgs?: string[] | undefined;
-    timeoutMs?: number | undefined;
-}>;
+}, import("zod/v4/core").$strip>;
 export type RunTrivyInput = CommandToolInput;
 export declare const runTrivyTool: ToolDefinition<RunTrivyInput>;

package/dist/tools/suggest_security_hardening.d.ts

@@ -2,14 +2,12 @@ import { z } from "zod";
 import type { ToolDefinition } from "./types.js";
 declare const suggestSecurityHardeningInputSchema: z.ZodObject<{
     scanOutput: z.ZodString;
-    scanTool: z.ZodDefault<z.ZodEnum<["checkov", "trivy", "kics"]>>;
-}, "strip", z.ZodTypeAny, {
-    scanOutput: string;
-    scanTool: "checkov" | "trivy" | "kics";
-}, {
-    scanOutput: string;
-    scanTool?: "checkov" | "trivy" | "kics" | undefined;
-}>;
+    scanTool: z.ZodDefault<z.ZodEnum<{
+        checkov: "checkov";
+        trivy: "trivy";
+        kics: "kics";
+    }>>;
+}, z.core.$strip>;
 export type SuggestSecurityHardeningInput = z.infer<typeof suggestSecurityHardeningInputSchema>;
 export declare const suggestSecurityHardeningInputJsonSchema: Record<string, unknown>;
 export declare const suggestSecurityHardeningTool: ToolDefinition<SuggestSecurityHardeningInput>;

package/dist/tools/suggest_terraform_architecture.d.ts

@@ -1,30 +1,33 @@
 import { z } from "zod";
 import type { ToolDefinition } from "./types.js";
 declare const suggestTerraformArchitectureInputSchema: z.ZodObject<{
-    workloadType: z.ZodDefault<z.ZodEnum<["web-api", "data-platform", "event-driven", "platform-foundation", "general"]>>;
-    environments: z.ZodDefault<z.ZodArray<z.ZodEnum<["dev", "test", "stage", "prod", "sandbox", "dr"]>, "many">>;
+    workloadType: z.ZodDefault<z.ZodEnum<{
+        general: "general";
+        "web-api": "web-api";
+        "data-platform": "data-platform";
+        "event-driven": "event-driven";
+        "platform-foundation": "platform-foundation";
+    }>>;
+    environments: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        dev: "dev";
+        test: "test";
+        stage: "stage";
+        prod: "prod";
+        sandbox: "sandbox";
+        dr: "dr";
+    }>>>;
     multiRegion: z.ZodDefault<z.ZodBoolean>;
-    complianceProfile: z.ZodDefault<z.ZodEnum<["none", "cis", "pci-dss", "hipaa", "sox"]>>;
+    complianceProfile: z.ZodDefault<z.ZodEnum<{
+        cis: "cis";
+        "pci-dss": "pci-dss";
+        hipaa: "hipaa";
+        sox: "sox";
+        none: "none";
+    }>>;
     teamSize: z.ZodDefault<z.ZodNumber>;
     currentPainPoints: z.ZodOptional<z.ZodString>;
     includeReferenceLayout: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    teamSize: number;
-    workloadType: "general" | "web-api" | "data-platform" | "event-driven" | "platform-foundation";
-    environments: ("dev" | "test" | "stage" | "prod" | "sandbox" | "dr")[];
-    multiRegion: boolean;
-    complianceProfile: "cis" | "pci-dss" | "hipaa" | "sox" | "none";
-    includeReferenceLayout: boolean;
-    currentPainPoints?: string | undefined;
-}, {
-    teamSize?: number | undefined;
-    workloadType?: "general" | "web-api" | "data-platform" | "event-driven" | "platform-foundation" | undefined;
-    environments?: ("dev" | "test" | "stage" | "prod" | "sandbox" | "dr")[] | undefined;
-    multiRegion?: boolean | undefined;
-    complianceProfile?: "cis" | "pci-dss" | "hipaa" | "sox" | "none" | undefined;
-    currentPainPoints?: string | undefined;
-    includeReferenceLayout?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type SuggestTerraformArchitectureInput = z.infer<typeof suggestTerraformArchitectureInputSchema>;
 export declare const suggestTerraformArchitectureInputJsonSchema: Record<string, unknown>;
 export declare const suggestTerraformArchitectureTool: ToolDefinition<SuggestTerraformArchitectureInput>;

package/dist/tools/suggest_terraform_testing_strategy.d.ts

@@ -2,23 +2,27 @@ import { z } from "zod";
 import type { ToolDefinition } from "./types.js";
 declare const suggestTerraformTestingStrategyInputSchema: z.ZodObject<{
     terraformCode: z.ZodOptional<z.ZodString>;
-    deploymentCriticality: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "mission-critical"]>>;
-    changeFrequency: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
-    ciSystem: z.ZodDefault<z.ZodEnum<["github-actions", "azure-devops", "gitlab", "circleci", "jenkins", "other"]>>;
+    deploymentCriticality: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        "mission-critical": "mission-critical";
+    }>>;
+    changeFrequency: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    ciSystem: z.ZodDefault<z.ZodEnum<{
+        "github-actions": "github-actions";
+        "azure-devops": "azure-devops";
+        gitlab: "gitlab";
+        circleci: "circleci";
+        jenkins: "jenkins";
+        other: "other";
+    }>>;
     includeExamplePipeline: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    deploymentCriticality: "low" | "medium" | "high" | "mission-critical";
-    changeFrequency: "low" | "medium" | "high";
-    ciSystem: "github-actions" | "azure-devops" | "gitlab" | "circleci" | "jenkins" | "other";
-    includeExamplePipeline: boolean;
-    terraformCode?: string | undefined;
-}, {
-    terraformCode?: string | undefined;
-    deploymentCriticality?: "low" | "medium" | "high" | "mission-critical" | undefined;
-    changeFrequency?: "low" | "medium" | "high" | undefined;
-    ciSystem?: "github-actions" | "azure-devops" | "gitlab" | "circleci" | "jenkins" | "other" | undefined;
-    includeExamplePipeline?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type SuggestTerraformTestingStrategyInput = z.infer<typeof suggestTerraformTestingStrategyInputSchema>;
 export declare const suggestTerraformTestingStrategyInputJsonSchema: Record<string, unknown>;
 export declare const suggestTerraformTestingStrategyTool: ToolDefinition<SuggestTerraformTestingStrategyInput>;

package/mcp.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/DownAtTheBottomOfTheMoleHole/terraform-best-practices-mcp",
     "source": "github"
   },
-  "version": "2.1.3",
+  "version": "3.0.0",
   "packages": [
     {
       "registryType": "npm",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@downatthebottomofthemolehole/terraform-best-practices-mcp-server",
-  "version": "2.1.3",
+  "version": "3.0.0",
   "mcpName": "io.github.DownAtTheBottomOfTheMoleHole/terraform-best-practices",
   "description": "MCP server for Terraform cost, lint, security, and cloud best-practice guidance.",
   "type": "module",
@@ -54,7 +54,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.27.1",
-    "zod": "^3.23.8"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "25.3.5",