@objectstack/spec 0.9.2 → 1.0.1

package/dist/ai/devops-agent.zod.d.ts

@@ -57,310 +57,979 @@ import { z } from 'zod';
 /**
  * Code Generation Targets
  */
-export declare const CodeGenerationTargetSchema: z.ZodEnum<{
-    database: "database";
-    api: "api";
-    documentation: "documentation";
-    backend: "backend";
-    frontend: "frontend";
-    tests: "tests";
-    infrastructure: "infrastructure";
-}>;
+export declare const CodeGenerationTargetSchema: z.ZodEnum<["frontend", "backend", "api", "database", "tests", "documentation", "infrastructure"]>;
 export type CodeGenerationTarget = z.infer<typeof CodeGenerationTargetSchema>;
 /**
  * Code Generation Configuration
  */
 export declare const CodeGenerationConfigSchema: z.ZodObject<{
+    /**
+     * Enable code generation
+     */
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    targets: z.ZodArray<z.ZodEnum<{
-        database: "database";
-        api: "api";
-        documentation: "documentation";
-        backend: "backend";
-        frontend: "frontend";
-        tests: "tests";
-        infrastructure: "infrastructure";
-    }>>;
+    /**
+     * Generation targets
+     */
+    targets: z.ZodArray<z.ZodEnum<["frontend", "backend", "api", "database", "tests", "documentation", "infrastructure"]>, "many">;
+    /**
+     * Template repository
+     */
     templateRepo: z.ZodOptional<z.ZodString>;
+    /**
+     * Code style guide
+     */
     styleGuide: z.ZodOptional<z.ZodString>;
+    /**
+     * Include tests
+     */
     includeTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Include documentation
+     */
     includeDocumentation: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        strict: "strict";
-        moderate: "moderate";
-        permissive: "permissive";
-    }>>>;
-}, z.core.$strip>;
+    /**
+     * Validation mode
+     */
+    validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["strict", "moderate", "permissive"]>>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+    includeTests: boolean;
+    includeDocumentation: boolean;
+    validationMode: "strict" | "moderate" | "permissive";
+    templateRepo?: string | undefined;
+    styleGuide?: string | undefined;
+}, {
+    targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+    enabled?: boolean | undefined;
+    templateRepo?: string | undefined;
+    styleGuide?: string | undefined;
+    includeTests?: boolean | undefined;
+    includeDocumentation?: boolean | undefined;
+    validationMode?: "strict" | "moderate" | "permissive" | undefined;
+}>;
 export type CodeGenerationConfig = z.infer<typeof CodeGenerationConfigSchema>;
 /**
  * Testing Configuration
  */
 export declare const TestingConfigSchema: z.ZodObject<{
+    /**
+     * Enable automated testing
+     */
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    testTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        integration: "integration";
-        performance: "performance";
-        unit: "unit";
-        security: "security";
-        e2e: "e2e";
-        accessibility: "accessibility";
-    }>>>>;
+    /**
+     * Test types to run
+     */
+    testTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["unit", "integration", "e2e", "performance", "security", "accessibility"]>, "many">>>;
+    /**
+     * Minimum coverage threshold
+     */
     coverageThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Test framework
+     */
     framework: z.ZodOptional<z.ZodString>;
+    /**
+     * Run tests before commit
+     */
     preCommitTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Auto-fix failing tests
+     */
     autoFix: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    testTypes: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[];
+    coverageThreshold: number;
+    preCommitTests: boolean;
+    autoFix: boolean;
+    framework?: string | undefined;
+}, {
+    enabled?: boolean | undefined;
+    testTypes?: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[] | undefined;
+    coverageThreshold?: number | undefined;
+    framework?: string | undefined;
+    preCommitTests?: boolean | undefined;
+    autoFix?: boolean | undefined;
+}>;
 export type TestingConfig = z.infer<typeof TestingConfigSchema>;
 /**
  * CI/CD Pipeline Stage
  */
 export declare const PipelineStageSchema: z.ZodObject<{
+    /**
+     * Stage name
+     */
     name: z.ZodString;
-    type: z.ZodEnum<{
-        rollback: "rollback";
-        test: "test";
-        build: "build";
-        lint: "lint";
-        security_scan: "security_scan";
-        deploy: "deploy";
-        smoke_test: "smoke_test";
-    }>;
+    /**
+     * Stage type
+     */
+    type: z.ZodEnum<["build", "test", "lint", "security_scan", "deploy", "smoke_test", "rollback"]>;
+    /**
+     * Stage order
+     */
     order: z.ZodNumber;
+    /**
+     * Run in parallel
+     */
     parallel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    commands: z.ZodArray<z.ZodString>;
+    /**
+     * Commands to execute
+     */
+    commands: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Environment variables
+     */
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /**
+     * Timeout in seconds
+     */
     timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Retry on failure
+     */
     retryOnFailure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Max retry attempts
+     */
     maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+    order: number;
+    name: string;
+    timeout: number;
+    maxRetries: number;
+    parallel: boolean;
+    commands: string[];
+    retryOnFailure: boolean;
+    env?: Record<string, string> | undefined;
+}, {
+    type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+    order: number;
+    name: string;
+    commands: string[];
+    timeout?: number | undefined;
+    env?: Record<string, string> | undefined;
+    maxRetries?: number | undefined;
+    parallel?: boolean | undefined;
+    retryOnFailure?: boolean | undefined;
+}>;
 export type PipelineStage = z.infer<typeof PipelineStageSchema>;
 /**
  * CI/CD Pipeline Configuration
  */
 export declare const CICDPipelineConfigSchema: z.ZodObject<{
+    /**
+     * Pipeline name
+     */
     name: z.ZodString;
-    trigger: z.ZodEnum<{
-        push: "push";
-        schedule: "schedule";
-        manual: "manual";
-        pull_request: "pull_request";
-        release: "release";
-    }>;
-    branches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    /**
+     * Pipeline trigger
+     */
+    trigger: z.ZodEnum<["push", "pull_request", "release", "schedule", "manual"]>;
+    /**
+     * Branch filters
+     */
+    branches: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Pipeline stages
+     */
     stages: z.ZodArray<z.ZodObject<{
+        /**
+         * Stage name
+         */
         name: z.ZodString;
-        type: z.ZodEnum<{
-            rollback: "rollback";
-            test: "test";
-            build: "build";
-            lint: "lint";
-            security_scan: "security_scan";
-            deploy: "deploy";
-            smoke_test: "smoke_test";
-        }>;
+        /**
+         * Stage type
+         */
+        type: z.ZodEnum<["build", "test", "lint", "security_scan", "deploy", "smoke_test", "rollback"]>;
+        /**
+         * Stage order
+         */
         order: z.ZodNumber;
+        /**
+         * Run in parallel
+         */
         parallel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        commands: z.ZodArray<z.ZodString>;
+        /**
+         * Commands to execute
+         */
+        commands: z.ZodArray<z.ZodString, "many">;
+        /**
+         * Environment variables
+         */
         env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Timeout in seconds
+         */
         timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Retry on failure
+         */
         retryOnFailure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Max retry attempts
+         */
         maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+        order: number;
+        name: string;
+        timeout: number;
+        maxRetries: number;
+        parallel: boolean;
+        commands: string[];
+        retryOnFailure: boolean;
+        env?: Record<string, string> | undefined;
+    }, {
+        type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+        order: number;
+        name: string;
+        commands: string[];
+        timeout?: number | undefined;
+        env?: Record<string, string> | undefined;
+        maxRetries?: number | undefined;
+        parallel?: boolean | undefined;
+        retryOnFailure?: boolean | undefined;
+    }>, "many">;
+    /**
+     * Enable notifications
+     */
     notifications: z.ZodOptional<z.ZodObject<{
         onSuccess: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         onFailure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        channels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        onFailure: boolean;
+        onSuccess: boolean;
+        channels?: string[] | undefined;
+    }, {
+        channels?: string[] | undefined;
+        onFailure?: boolean | undefined;
+        onSuccess?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    stages: {
+        type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+        order: number;
+        name: string;
+        timeout: number;
+        maxRetries: number;
+        parallel: boolean;
+        commands: string[];
+        retryOnFailure: boolean;
+        env?: Record<string, string> | undefined;
+    }[];
+    trigger: "push" | "manual" | "schedule" | "pull_request" | "release";
+    notifications?: {
+        onFailure: boolean;
+        onSuccess: boolean;
+        channels?: string[] | undefined;
+    } | undefined;
+    branches?: string[] | undefined;
+}, {
+    name: string;
+    stages: {
+        type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+        order: number;
+        name: string;
+        commands: string[];
+        timeout?: number | undefined;
+        env?: Record<string, string> | undefined;
+        maxRetries?: number | undefined;
+        parallel?: boolean | undefined;
+        retryOnFailure?: boolean | undefined;
+    }[];
+    trigger: "push" | "manual" | "schedule" | "pull_request" | "release";
+    notifications?: {
+        channels?: string[] | undefined;
+        onFailure?: boolean | undefined;
+        onSuccess?: boolean | undefined;
+    } | undefined;
+    branches?: string[] | undefined;
+}>;
 export type CICDPipelineConfig = z.infer<typeof CICDPipelineConfigSchema>;
 /**
  * Version Management Configuration
  */
 export declare const VersionManagementSchema: z.ZodObject<{
-    scheme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        custom: "custom";
-        semver: "semver";
-        calver: "calver";
-    }>>>;
-    autoIncrement: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        major: "major";
-        minor: "minor";
-        patch: "patch";
-    }>>>;
+    /**
+     * Versioning scheme
+     */
+    scheme: z.ZodDefault<z.ZodOptional<z.ZodEnum<["semver", "calver", "custom"]>>>;
+    /**
+     * Auto-increment strategy
+     */
+    autoIncrement: z.ZodDefault<z.ZodOptional<z.ZodEnum<["major", "minor", "patch", "none"]>>>;
+    /**
+     * Version prefix
+     */
     prefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /**
+     * Create changelog
+     */
     generateChangelog: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    changelogFormat: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        custom: "custom";
-        conventional: "conventional";
-        keepachangelog: "keepachangelog";
-    }>>>;
+    /**
+     * Changelog format
+     */
+    changelogFormat: z.ZodDefault<z.ZodOptional<z.ZodEnum<["conventional", "keepachangelog", "custom"]>>>;
+    /**
+     * Tag releases
+     */
     tagReleases: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    prefix: string;
+    scheme: "custom" | "semver" | "calver";
+    autoIncrement: "none" | "major" | "minor" | "patch";
+    generateChangelog: boolean;
+    changelogFormat: "custom" | "conventional" | "keepachangelog";
+    tagReleases: boolean;
+}, {
+    prefix?: string | undefined;
+    scheme?: "custom" | "semver" | "calver" | undefined;
+    autoIncrement?: "none" | "major" | "minor" | "patch" | undefined;
+    generateChangelog?: boolean | undefined;
+    changelogFormat?: "custom" | "conventional" | "keepachangelog" | undefined;
+    tagReleases?: boolean | undefined;
+}>;
 export type VersionManagement = z.infer<typeof VersionManagementSchema>;
 /**
  * Deployment Strategy Configuration
  */
 export declare const DeploymentStrategySchema: z.ZodObject<{
-    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        rolling: "rolling";
-        canary: "canary";
-        blue_green: "blue_green";
-        recreate: "recreate";
-    }>>>;
+    /**
+     * Strategy type
+     */
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["rolling", "blue_green", "canary", "recreate"]>>>;
+    /**
+     * Canary percentage (for canary deployments)
+     */
     canaryPercentage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Health check URL
+     */
     healthCheckUrl: z.ZodOptional<z.ZodString>;
+    /**
+     * Health check timeout
+     */
     healthCheckTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Rollback on failure
+     */
     autoRollback: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    smokeTests: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+    /**
+     * Smoke tests
+     */
+    smokeTests: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "rolling" | "canary" | "blue_green" | "recreate";
+    canaryPercentage: number;
+    healthCheckTimeout: number;
+    autoRollback: boolean;
+    healthCheckUrl?: string | undefined;
+    smokeTests?: string[] | undefined;
+}, {
+    type?: "rolling" | "canary" | "blue_green" | "recreate" | undefined;
+    canaryPercentage?: number | undefined;
+    healthCheckUrl?: string | undefined;
+    healthCheckTimeout?: number | undefined;
+    autoRollback?: boolean | undefined;
+    smokeTests?: string[] | undefined;
+}>;
 export type DeploymentStrategy = z.infer<typeof DeploymentStrategySchema>;
 /**
  * Monitoring Configuration
  */
 export declare const MonitoringConfigSchema: z.ZodObject<{
+    /**
+     * Enable monitoring
+     */
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    metrics: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        errors: "errors";
-        performance: "performance";
-        availability: "availability";
-        latency: "latency";
-        usage: "usage";
-    }>>>>;
+    /**
+     * Metrics to track
+     */
+    metrics: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["performance", "errors", "usage", "availability", "latency"]>, "many">>>;
+    /**
+     * Alert thresholds
+     */
     alerts: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         metric: z.ZodString;
         threshold: z.ZodNumber;
-        severity: z.ZodEnum<{
-            warning: "warning";
-            info: "info";
-            critical: "critical";
-        }>;
-    }, z.core.$strip>>>;
-    integrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        threshold: number;
+        severity: "warning" | "info" | "critical";
+        metric: string;
+    }, {
+        name: string;
+        threshold: number;
+        severity: "warning" | "info" | "critical";
+        metric: string;
+    }>, "many">>;
+    /**
+     * Monitoring integrations
+     */
+    integrations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    metrics: ("errors" | "performance" | "availability" | "latency" | "usage")[];
+    alerts?: {
+        name: string;
+        threshold: number;
+        severity: "warning" | "info" | "critical";
+        metric: string;
+    }[] | undefined;
+    integrations?: string[] | undefined;
+}, {
+    enabled?: boolean | undefined;
+    alerts?: {
+        name: string;
+        threshold: number;
+        severity: "warning" | "info" | "critical";
+        metric: string;
+    }[] | undefined;
+    metrics?: ("errors" | "performance" | "availability" | "latency" | "usage")[] | undefined;
+    integrations?: string[] | undefined;
+}>;
 export type MonitoringConfig = z.infer<typeof MonitoringConfigSchema>;
 /**
  * Development Configuration
  */
 export declare const DevelopmentConfigSchema: z.ZodObject<{
+    /**
+     * ObjectStack specification source
+     */
     specificationSource: z.ZodString;
+    /**
+     * Code generation configuration
+     */
     codeGeneration: z.ZodObject<{
+        /**
+         * Enable code generation
+         */
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        targets: z.ZodArray<z.ZodEnum<{
-            database: "database";
-            api: "api";
-            documentation: "documentation";
-            backend: "backend";
-            frontend: "frontend";
-            tests: "tests";
-            infrastructure: "infrastructure";
-        }>>;
+        /**
+         * Generation targets
+         */
+        targets: z.ZodArray<z.ZodEnum<["frontend", "backend", "api", "database", "tests", "documentation", "infrastructure"]>, "many">;
+        /**
+         * Template repository
+         */
         templateRepo: z.ZodOptional<z.ZodString>;
+        /**
+         * Code style guide
+         */
         styleGuide: z.ZodOptional<z.ZodString>;
+        /**
+         * Include tests
+         */
         includeTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Include documentation
+         */
         includeDocumentation: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            strict: "strict";
-            moderate: "moderate";
-            permissive: "permissive";
-        }>>>;
-    }, z.core.$strip>;
+        /**
+         * Validation mode
+         */
+        validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["strict", "moderate", "permissive"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+        includeTests: boolean;
+        includeDocumentation: boolean;
+        validationMode: "strict" | "moderate" | "permissive";
+        templateRepo?: string | undefined;
+        styleGuide?: string | undefined;
+    }, {
+        targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+        enabled?: boolean | undefined;
+        templateRepo?: string | undefined;
+        styleGuide?: string | undefined;
+        includeTests?: boolean | undefined;
+        includeDocumentation?: boolean | undefined;
+        validationMode?: "strict" | "moderate" | "permissive" | undefined;
+    }>;
+    /**
+     * Testing configuration
+     */
     testing: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable automated testing
+         */
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        testTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            integration: "integration";
-            performance: "performance";
-            unit: "unit";
-            security: "security";
-            e2e: "e2e";
-            accessibility: "accessibility";
-        }>>>>;
+        /**
+         * Test types to run
+         */
+        testTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["unit", "integration", "e2e", "performance", "security", "accessibility"]>, "many">>>;
+        /**
+         * Minimum coverage threshold
+         */
         coverageThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Test framework
+         */
         framework: z.ZodOptional<z.ZodString>;
+        /**
+         * Run tests before commit
+         */
         preCommitTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Auto-fix failing tests
+         */
         autoFix: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        testTypes: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[];
+        coverageThreshold: number;
+        preCommitTests: boolean;
+        autoFix: boolean;
+        framework?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        testTypes?: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[] | undefined;
+        coverageThreshold?: number | undefined;
+        framework?: string | undefined;
+        preCommitTests?: boolean | undefined;
+        autoFix?: boolean | undefined;
+    }>>;
+    /**
+     * Linting configuration
+     */
     linting: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         autoFix: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        autoFix: boolean;
+        rules?: Record<string, any> | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        rules?: Record<string, any> | undefined;
+        autoFix?: boolean | undefined;
+    }>>;
+    /**
+     * Formatting configuration
+     */
     formatting: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         autoFormat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        autoFormat: boolean;
+        config?: Record<string, any> | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        config?: Record<string, any> | undefined;
+        autoFormat?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    specificationSource: string;
+    codeGeneration: {
+        enabled: boolean;
+        targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+        includeTests: boolean;
+        includeDocumentation: boolean;
+        validationMode: "strict" | "moderate" | "permissive";
+        templateRepo?: string | undefined;
+        styleGuide?: string | undefined;
+    };
+    testing?: {
+        enabled: boolean;
+        testTypes: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[];
+        coverageThreshold: number;
+        preCommitTests: boolean;
+        autoFix: boolean;
+        framework?: string | undefined;
+    } | undefined;
+    linting?: {
+        enabled: boolean;
+        autoFix: boolean;
+        rules?: Record<string, any> | undefined;
+    } | undefined;
+    formatting?: {
+        enabled: boolean;
+        autoFormat: boolean;
+        config?: Record<string, any> | undefined;
+    } | undefined;
+}, {
+    specificationSource: string;
+    codeGeneration: {
+        targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+        enabled?: boolean | undefined;
+        templateRepo?: string | undefined;
+        styleGuide?: string | undefined;
+        includeTests?: boolean | undefined;
+        includeDocumentation?: boolean | undefined;
+        validationMode?: "strict" | "moderate" | "permissive" | undefined;
+    };
+    testing?: {
+        enabled?: boolean | undefined;
+        testTypes?: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[] | undefined;
+        coverageThreshold?: number | undefined;
+        framework?: string | undefined;
+        preCommitTests?: boolean | undefined;
+        autoFix?: boolean | undefined;
+    } | undefined;
+    linting?: {
+        enabled?: boolean | undefined;
+        rules?: Record<string, any> | undefined;
+        autoFix?: boolean | undefined;
+    } | undefined;
+    formatting?: {
+        enabled?: boolean | undefined;
+        config?: Record<string, any> | undefined;
+        autoFormat?: boolean | undefined;
+    } | undefined;
+}>;
 export type DevelopmentConfig = z.infer<typeof DevelopmentConfigSchema>;
 /**
  * GitHub Integration Configuration
  */
 export declare const GitHubIntegrationSchema: z.ZodObject<{
+    /**
+     * GitHub connector reference
+     */
     connector: z.ZodString;
+    /**
+     * Repository configuration
+     */
     repository: z.ZodObject<{
         owner: z.ZodString;
         name: z.ZodString;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        owner: string;
+    }, {
+        name: string;
+        owner: string;
+    }>;
+    /**
+     * Default branch for features
+     */
     featureBranch: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /**
+     * Pull request configuration
+     */
     pullRequest: z.ZodOptional<z.ZodObject<{
         autoCreate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         autoMerge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         requireReviews: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         deleteBranchOnMerge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        autoCreate: boolean;
+        autoMerge: boolean;
+        requireReviews: boolean;
+        deleteBranchOnMerge: boolean;
+    }, {
+        autoCreate?: boolean | undefined;
+        autoMerge?: boolean | undefined;
+        requireReviews?: boolean | undefined;
+        deleteBranchOnMerge?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    repository: {
+        name: string;
+        owner: string;
+    };
+    connector: string;
+    featureBranch: string;
+    pullRequest?: {
+        autoCreate: boolean;
+        autoMerge: boolean;
+        requireReviews: boolean;
+        deleteBranchOnMerge: boolean;
+    } | undefined;
+}, {
+    repository: {
+        name: string;
+        owner: string;
+    };
+    connector: string;
+    featureBranch?: string | undefined;
+    pullRequest?: {
+        autoCreate?: boolean | undefined;
+        autoMerge?: boolean | undefined;
+        requireReviews?: boolean | undefined;
+        deleteBranchOnMerge?: boolean | undefined;
+    } | undefined;
+}>;
 export type GitHubIntegration = z.infer<typeof GitHubIntegrationSchema>;
 /**
  * Vercel Integration Configuration
  */
 export declare const VercelIntegrationSchema: z.ZodObject<{
+    /**
+     * Vercel connector reference
+     */
     connector: z.ZodString;
+    /**
+     * Project name
+     */
     project: z.ZodString;
+    /**
+     * Environment mapping
+     */
     environments: z.ZodOptional<z.ZodObject<{
         production: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        preview: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>>;
+        preview: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        production: string;
+        preview: string[];
+    }, {
+        production?: string | undefined;
+        preview?: string[] | undefined;
+    }>>;
+    /**
+     * Deployment configuration
+     */
     deployment: z.ZodOptional<z.ZodObject<{
         autoDeployProduction: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         autoDeployPreview: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         requireApproval: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        autoDeployProduction: boolean;
+        autoDeployPreview: boolean;
+        requireApproval: boolean;
+    }, {
+        autoDeployProduction?: boolean | undefined;
+        autoDeployPreview?: boolean | undefined;
+        requireApproval?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    connector: string;
+    project: string;
+    deployment?: {
+        autoDeployProduction: boolean;
+        autoDeployPreview: boolean;
+        requireApproval: boolean;
+    } | undefined;
+    environments?: {
+        production: string;
+        preview: string[];
+    } | undefined;
+}, {
+    connector: string;
+    project: string;
+    deployment?: {
+        autoDeployProduction?: boolean | undefined;
+        autoDeployPreview?: boolean | undefined;
+        requireApproval?: boolean | undefined;
+    } | undefined;
+    environments?: {
+        production?: string | undefined;
+        preview?: string[] | undefined;
+    } | undefined;
+}>;
 export type VercelIntegration = z.infer<typeof VercelIntegrationSchema>;
 /**
  * Integration Configuration
  */
 export declare const IntegrationConfigSchema: z.ZodObject<{
+    /**
+     * GitHub integration
+     */
     github: z.ZodObject<{
+        /**
+         * GitHub connector reference
+         */
         connector: z.ZodString;
+        /**
+         * Repository configuration
+         */
         repository: z.ZodObject<{
             owner: z.ZodString;
             name: z.ZodString;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            owner: string;
+        }, {
+            name: string;
+            owner: string;
+        }>;
+        /**
+         * Default branch for features
+         */
         featureBranch: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        /**
+         * Pull request configuration
+         */
         pullRequest: z.ZodOptional<z.ZodObject<{
             autoCreate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             autoMerge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             requireReviews: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             deleteBranchOnMerge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            autoCreate: boolean;
+            autoMerge: boolean;
+            requireReviews: boolean;
+            deleteBranchOnMerge: boolean;
+        }, {
+            autoCreate?: boolean | undefined;
+            autoMerge?: boolean | undefined;
+            requireReviews?: boolean | undefined;
+            deleteBranchOnMerge?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        repository: {
+            name: string;
+            owner: string;
+        };
+        connector: string;
+        featureBranch: string;
+        pullRequest?: {
+            autoCreate: boolean;
+            autoMerge: boolean;
+            requireReviews: boolean;
+            deleteBranchOnMerge: boolean;
+        } | undefined;
+    }, {
+        repository: {
+            name: string;
+            owner: string;
+        };
+        connector: string;
+        featureBranch?: string | undefined;
+        pullRequest?: {
+            autoCreate?: boolean | undefined;
+            autoMerge?: boolean | undefined;
+            requireReviews?: boolean | undefined;
+            deleteBranchOnMerge?: boolean | undefined;
+        } | undefined;
+    }>;
+    /**
+     * Vercel integration
+     */
     vercel: z.ZodObject<{
+        /**
+         * Vercel connector reference
+         */
         connector: z.ZodString;
+        /**
+         * Project name
+         */
         project: z.ZodString;
+        /**
+         * Environment mapping
+         */
         environments: z.ZodOptional<z.ZodObject<{
             production: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-            preview: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        }, z.core.$strip>>;
+            preview: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            production: string;
+            preview: string[];
+        }, {
+            production?: string | undefined;
+            preview?: string[] | undefined;
+        }>>;
+        /**
+         * Deployment configuration
+         */
         deployment: z.ZodOptional<z.ZodObject<{
             autoDeployProduction: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             autoDeployPreview: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             requireApproval: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            autoDeployProduction: boolean;
+            autoDeployPreview: boolean;
+            requireApproval: boolean;
+        }, {
+            autoDeployProduction?: boolean | undefined;
+            autoDeployPreview?: boolean | undefined;
+            requireApproval?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        connector: string;
+        project: string;
+        deployment?: {
+            autoDeployProduction: boolean;
+            autoDeployPreview: boolean;
+            requireApproval: boolean;
+        } | undefined;
+        environments?: {
+            production: string;
+            preview: string[];
+        } | undefined;
+    }, {
+        connector: string;
+        project: string;
+        deployment?: {
+            autoDeployProduction?: boolean | undefined;
+            autoDeployPreview?: boolean | undefined;
+            requireApproval?: boolean | undefined;
+        } | undefined;
+        environments?: {
+            production?: string | undefined;
+            preview?: string[] | undefined;
+        } | undefined;
+    }>;
+    /**
+     * Additional integrations
+     */
     additional: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    vercel: {
+        connector: string;
+        project: string;
+        deployment?: {
+            autoDeployProduction: boolean;
+            autoDeployPreview: boolean;
+            requireApproval: boolean;
+        } | undefined;
+        environments?: {
+            production: string;
+            preview: string[];
+        } | undefined;
+    };
+    github: {
+        repository: {
+            name: string;
+            owner: string;
+        };
+        connector: string;
+        featureBranch: string;
+        pullRequest?: {
+            autoCreate: boolean;
+            autoMerge: boolean;
+            requireReviews: boolean;
+            deleteBranchOnMerge: boolean;
+        } | undefined;
+    };
+    additional?: Record<string, any> | undefined;
+}, {
+    vercel: {
+        connector: string;
+        project: string;
+        deployment?: {
+            autoDeployProduction?: boolean | undefined;
+            autoDeployPreview?: boolean | undefined;
+            requireApproval?: boolean | undefined;
+        } | undefined;
+        environments?: {
+            production?: string | undefined;
+            preview?: string[] | undefined;
+        } | undefined;
+    };
+    github: {
+        repository: {
+            name: string;
+            owner: string;
+        };
+        connector: string;
+        featureBranch?: string | undefined;
+        pullRequest?: {
+            autoCreate?: boolean | undefined;
+            autoMerge?: boolean | undefined;
+            requireReviews?: boolean | undefined;
+            deleteBranchOnMerge?: boolean | undefined;
+        } | undefined;
+    };
+    additional?: Record<string, any> | undefined;
+}>;
 export type IntegrationConfig = z.infer<typeof IntegrationConfigSchema>;
 /**
  * DevOps Agent Schema
@@ -373,219 +1042,1023 @@ export declare const DevOpsAgentSchema: z.ZodObject<{
     role: z.ZodString;
     instructions: z.ZodString;
     model: z.ZodOptional<z.ZodObject<{
-        provider: z.ZodDefault<z.ZodEnum<{
-            local: "local";
-            openai: "openai";
-            azure_openai: "azure_openai";
-            anthropic: "anthropic";
-        }>>;
+        provider: z.ZodDefault<z.ZodEnum<["openai", "azure_openai", "anthropic", "local"]>>;
         model: z.ZodString;
         temperature: z.ZodDefault<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
         topP: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "local" | "openai" | "azure_openai" | "anthropic";
+        model: string;
+        temperature: number;
+        maxTokens?: number | undefined;
+        topP?: number | undefined;
+    }, {
+        model: string;
+        provider?: "local" | "openai" | "azure_openai" | "anthropic" | undefined;
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        topP?: number | undefined;
+    }>>;
     tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            query: "query";
-            flow: "flow";
-            action: "action";
-            vector_search: "vector_search";
-        }>;
+        type: z.ZodEnum<["action", "flow", "query", "vector_search"]>;
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "query" | "action" | "flow" | "vector_search";
+        name: string;
+        description?: string | undefined;
+    }, {
+        type: "query" | "action" | "flow" | "vector_search";
+        name: string;
+        description?: string | undefined;
+    }>, "many">>;
     knowledge: z.ZodOptional<z.ZodObject<{
-        topics: z.ZodArray<z.ZodString>;
-        indexes: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
+        topics: z.ZodArray<z.ZodString, "many">;
+        indexes: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        indexes: string[];
+        topics: string[];
+    }, {
+        indexes: string[];
+        topics: string[];
+    }>>;
     active: z.ZodDefault<z.ZodBoolean>;
-    access: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    access: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodDefault<z.ZodEnum<["global", "organization", "private"]>>;
+} & {
+    /**
+     * Development configuration
+     */
     developmentConfig: z.ZodObject<{
+        /**
+         * ObjectStack specification source
+         */
         specificationSource: z.ZodString;
+        /**
+         * Code generation configuration
+         */
         codeGeneration: z.ZodObject<{
+            /**
+             * Enable code generation
+             */
             enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            targets: z.ZodArray<z.ZodEnum<{
-                database: "database";
-                api: "api";
-                documentation: "documentation";
-                backend: "backend";
-                frontend: "frontend";
-                tests: "tests";
-                infrastructure: "infrastructure";
-            }>>;
+            /**
+             * Generation targets
+             */
+            targets: z.ZodArray<z.ZodEnum<["frontend", "backend", "api", "database", "tests", "documentation", "infrastructure"]>, "many">;
+            /**
+             * Template repository
+             */
             templateRepo: z.ZodOptional<z.ZodString>;
+            /**
+             * Code style guide
+             */
             styleGuide: z.ZodOptional<z.ZodString>;
+            /**
+             * Include tests
+             */
             includeTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            /**
+             * Include documentation
+             */
             includeDocumentation: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-                strict: "strict";
-                moderate: "moderate";
-                permissive: "permissive";
-            }>>>;
-        }, z.core.$strip>;
+            /**
+             * Validation mode
+             */
+            validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["strict", "moderate", "permissive"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+            includeTests: boolean;
+            includeDocumentation: boolean;
+            validationMode: "strict" | "moderate" | "permissive";
+            templateRepo?: string | undefined;
+            styleGuide?: string | undefined;
+        }, {
+            targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+            enabled?: boolean | undefined;
+            templateRepo?: string | undefined;
+            styleGuide?: string | undefined;
+            includeTests?: boolean | undefined;
+            includeDocumentation?: boolean | undefined;
+            validationMode?: "strict" | "moderate" | "permissive" | undefined;
+        }>;
+        /**
+         * Testing configuration
+         */
         testing: z.ZodOptional<z.ZodObject<{
+            /**
+             * Enable automated testing
+             */
             enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            testTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                integration: "integration";
-                performance: "performance";
-                unit: "unit";
-                security: "security";
-                e2e: "e2e";
-                accessibility: "accessibility";
-            }>>>>;
+            /**
+             * Test types to run
+             */
+            testTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["unit", "integration", "e2e", "performance", "security", "accessibility"]>, "many">>>;
+            /**
+             * Minimum coverage threshold
+             */
             coverageThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Test framework
+             */
             framework: z.ZodOptional<z.ZodString>;
+            /**
+             * Run tests before commit
+             */
             preCommitTests: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            /**
+             * Auto-fix failing tests
+             */
             autoFix: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            testTypes: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[];
+            coverageThreshold: number;
+            preCommitTests: boolean;
+            autoFix: boolean;
+            framework?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            testTypes?: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[] | undefined;
+            coverageThreshold?: number | undefined;
+            framework?: string | undefined;
+            preCommitTests?: boolean | undefined;
+            autoFix?: boolean | undefined;
+        }>>;
+        /**
+         * Linting configuration
+         */
         linting: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             autoFix: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            autoFix: boolean;
+            rules?: Record<string, any> | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            rules?: Record<string, any> | undefined;
+            autoFix?: boolean | undefined;
+        }>>;
+        /**
+         * Formatting configuration
+         */
         formatting: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             autoFormat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            autoFormat: boolean;
+            config?: Record<string, any> | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            config?: Record<string, any> | undefined;
+            autoFormat?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        specificationSource: string;
+        codeGeneration: {
+            enabled: boolean;
+            targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+            includeTests: boolean;
+            includeDocumentation: boolean;
+            validationMode: "strict" | "moderate" | "permissive";
+            templateRepo?: string | undefined;
+            styleGuide?: string | undefined;
+        };
+        testing?: {
+            enabled: boolean;
+            testTypes: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[];
+            coverageThreshold: number;
+            preCommitTests: boolean;
+            autoFix: boolean;
+            framework?: string | undefined;
+        } | undefined;
+        linting?: {
+            enabled: boolean;
+            autoFix: boolean;
+            rules?: Record<string, any> | undefined;
+        } | undefined;
+        formatting?: {
+            enabled: boolean;
+            autoFormat: boolean;
+            config?: Record<string, any> | undefined;
+        } | undefined;
+    }, {
+        specificationSource: string;
+        codeGeneration: {
+            targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+            enabled?: boolean | undefined;
+            templateRepo?: string | undefined;
+            styleGuide?: string | undefined;
+            includeTests?: boolean | undefined;
+            includeDocumentation?: boolean | undefined;
+            validationMode?: "strict" | "moderate" | "permissive" | undefined;
+        };
+        testing?: {
+            enabled?: boolean | undefined;
+            testTypes?: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[] | undefined;
+            coverageThreshold?: number | undefined;
+            framework?: string | undefined;
+            preCommitTests?: boolean | undefined;
+            autoFix?: boolean | undefined;
+        } | undefined;
+        linting?: {
+            enabled?: boolean | undefined;
+            rules?: Record<string, any> | undefined;
+            autoFix?: boolean | undefined;
+        } | undefined;
+        formatting?: {
+            enabled?: boolean | undefined;
+            config?: Record<string, any> | undefined;
+            autoFormat?: boolean | undefined;
+        } | undefined;
+    }>;
+    /**
+     * CI/CD pipelines
+     */
     pipelines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /**
+         * Pipeline name
+         */
         name: z.ZodString;
-        trigger: z.ZodEnum<{
-            push: "push";
-            schedule: "schedule";
-            manual: "manual";
-            pull_request: "pull_request";
-            release: "release";
-        }>;
-        branches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        /**
+         * Pipeline trigger
+         */
+        trigger: z.ZodEnum<["push", "pull_request", "release", "schedule", "manual"]>;
+        /**
+         * Branch filters
+         */
+        branches: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Pipeline stages
+         */
         stages: z.ZodArray<z.ZodObject<{
+            /**
+             * Stage name
+             */
             name: z.ZodString;
-            type: z.ZodEnum<{
-                rollback: "rollback";
-                test: "test";
-                build: "build";
-                lint: "lint";
-                security_scan: "security_scan";
-                deploy: "deploy";
-                smoke_test: "smoke_test";
-            }>;
+            /**
+             * Stage type
+             */
+            type: z.ZodEnum<["build", "test", "lint", "security_scan", "deploy", "smoke_test", "rollback"]>;
+            /**
+             * Stage order
+             */
             order: z.ZodNumber;
+            /**
+             * Run in parallel
+             */
             parallel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            commands: z.ZodArray<z.ZodString>;
+            /**
+             * Commands to execute
+             */
+            commands: z.ZodArray<z.ZodString, "many">;
+            /**
+             * Environment variables
+             */
             env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            /**
+             * Timeout in seconds
+             */
             timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Retry on failure
+             */
             retryOnFailure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            /**
+             * Max retry attempts
+             */
             maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+            order: number;
+            name: string;
+            timeout: number;
+            maxRetries: number;
+            parallel: boolean;
+            commands: string[];
+            retryOnFailure: boolean;
+            env?: Record<string, string> | undefined;
+        }, {
+            type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+            order: number;
+            name: string;
+            commands: string[];
+            timeout?: number | undefined;
+            env?: Record<string, string> | undefined;
+            maxRetries?: number | undefined;
+            parallel?: boolean | undefined;
+            retryOnFailure?: boolean | undefined;
+        }>, "many">;
+        /**
+         * Enable notifications
+         */
         notifications: z.ZodOptional<z.ZodObject<{
             onSuccess: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             onFailure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
+            channels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            onFailure: boolean;
+            onSuccess: boolean;
+            channels?: string[] | undefined;
+        }, {
+            channels?: string[] | undefined;
+            onFailure?: boolean | undefined;
+            onSuccess?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        stages: {
+            type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+            order: number;
+            name: string;
+            timeout: number;
+            maxRetries: number;
+            parallel: boolean;
+            commands: string[];
+            retryOnFailure: boolean;
+            env?: Record<string, string> | undefined;
+        }[];
+        trigger: "push" | "manual" | "schedule" | "pull_request" | "release";
+        notifications?: {
+            onFailure: boolean;
+            onSuccess: boolean;
+            channels?: string[] | undefined;
+        } | undefined;
+        branches?: string[] | undefined;
+    }, {
+        name: string;
+        stages: {
+            type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+            order: number;
+            name: string;
+            commands: string[];
+            timeout?: number | undefined;
+            env?: Record<string, string> | undefined;
+            maxRetries?: number | undefined;
+            parallel?: boolean | undefined;
+            retryOnFailure?: boolean | undefined;
+        }[];
+        trigger: "push" | "manual" | "schedule" | "pull_request" | "release";
+        notifications?: {
+            channels?: string[] | undefined;
+            onFailure?: boolean | undefined;
+            onSuccess?: boolean | undefined;
+        } | undefined;
+        branches?: string[] | undefined;
+    }>, "many">>;
+    /**
+     * Version management
+     */
     versionManagement: z.ZodOptional<z.ZodObject<{
-        scheme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            custom: "custom";
-            semver: "semver";
-            calver: "calver";
-        }>>>;
-        autoIncrement: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            major: "major";
-            minor: "minor";
-            patch: "patch";
-        }>>>;
+        /**
+         * Versioning scheme
+         */
+        scheme: z.ZodDefault<z.ZodOptional<z.ZodEnum<["semver", "calver", "custom"]>>>;
+        /**
+         * Auto-increment strategy
+         */
+        autoIncrement: z.ZodDefault<z.ZodOptional<z.ZodEnum<["major", "minor", "patch", "none"]>>>;
+        /**
+         * Version prefix
+         */
         prefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        /**
+         * Create changelog
+         */
         generateChangelog: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        changelogFormat: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            custom: "custom";
-            conventional: "conventional";
-            keepachangelog: "keepachangelog";
-        }>>>;
+        /**
+         * Changelog format
+         */
+        changelogFormat: z.ZodDefault<z.ZodOptional<z.ZodEnum<["conventional", "keepachangelog", "custom"]>>>;
+        /**
+         * Tag releases
+         */
         tagReleases: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        prefix: string;
+        scheme: "custom" | "semver" | "calver";
+        autoIncrement: "none" | "major" | "minor" | "patch";
+        generateChangelog: boolean;
+        changelogFormat: "custom" | "conventional" | "keepachangelog";
+        tagReleases: boolean;
+    }, {
+        prefix?: string | undefined;
+        scheme?: "custom" | "semver" | "calver" | undefined;
+        autoIncrement?: "none" | "major" | "minor" | "patch" | undefined;
+        generateChangelog?: boolean | undefined;
+        changelogFormat?: "custom" | "conventional" | "keepachangelog" | undefined;
+        tagReleases?: boolean | undefined;
+    }>>;
+    /**
+     * Deployment strategy
+     */
     deploymentStrategy: z.ZodOptional<z.ZodObject<{
-        type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            rolling: "rolling";
-            canary: "canary";
-            blue_green: "blue_green";
-            recreate: "recreate";
-        }>>>;
+        /**
+         * Strategy type
+         */
+        type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["rolling", "blue_green", "canary", "recreate"]>>>;
+        /**
+         * Canary percentage (for canary deployments)
+         */
         canaryPercentage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Health check URL
+         */
         healthCheckUrl: z.ZodOptional<z.ZodString>;
+        /**
+         * Health check timeout
+         */
         healthCheckTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Rollback on failure
+         */
         autoRollback: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        smokeTests: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
+        /**
+         * Smoke tests
+         */
+        smokeTests: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "rolling" | "canary" | "blue_green" | "recreate";
+        canaryPercentage: number;
+        healthCheckTimeout: number;
+        autoRollback: boolean;
+        healthCheckUrl?: string | undefined;
+        smokeTests?: string[] | undefined;
+    }, {
+        type?: "rolling" | "canary" | "blue_green" | "recreate" | undefined;
+        canaryPercentage?: number | undefined;
+        healthCheckUrl?: string | undefined;
+        healthCheckTimeout?: number | undefined;
+        autoRollback?: boolean | undefined;
+        smokeTests?: string[] | undefined;
+    }>>;
+    /**
+     * Monitoring configuration
+     */
     monitoring: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable monitoring
+         */
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        metrics: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            errors: "errors";
-            performance: "performance";
-            availability: "availability";
-            latency: "latency";
-            usage: "usage";
-        }>>>>;
+        /**
+         * Metrics to track
+         */
+        metrics: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["performance", "errors", "usage", "availability", "latency"]>, "many">>>;
+        /**
+         * Alert thresholds
+         */
         alerts: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             metric: z.ZodString;
             threshold: z.ZodNumber;
-            severity: z.ZodEnum<{
-                warning: "warning";
-                info: "info";
-                critical: "critical";
-            }>;
-        }, z.core.$strip>>>;
-        integrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
+            severity: z.ZodEnum<["info", "warning", "critical"]>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            threshold: number;
+            severity: "warning" | "info" | "critical";
+            metric: string;
+        }, {
+            name: string;
+            threshold: number;
+            severity: "warning" | "info" | "critical";
+            metric: string;
+        }>, "many">>;
+        /**
+         * Monitoring integrations
+         */
+        integrations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        metrics: ("errors" | "performance" | "availability" | "latency" | "usage")[];
+        alerts?: {
+            name: string;
+            threshold: number;
+            severity: "warning" | "info" | "critical";
+            metric: string;
+        }[] | undefined;
+        integrations?: string[] | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        alerts?: {
+            name: string;
+            threshold: number;
+            severity: "warning" | "info" | "critical";
+            metric: string;
+        }[] | undefined;
+        metrics?: ("errors" | "performance" | "availability" | "latency" | "usage")[] | undefined;
+        integrations?: string[] | undefined;
+    }>>;
+    /**
+     * Integration configuration
+     */
     integrations: z.ZodObject<{
+        /**
+         * GitHub integration
+         */
         github: z.ZodObject<{
+            /**
+             * GitHub connector reference
+             */
             connector: z.ZodString;
+            /**
+             * Repository configuration
+             */
             repository: z.ZodObject<{
                 owner: z.ZodString;
                 name: z.ZodString;
-            }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                owner: string;
+            }, {
+                name: string;
+                owner: string;
+            }>;
+            /**
+             * Default branch for features
+             */
             featureBranch: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            /**
+             * Pull request configuration
+             */
             pullRequest: z.ZodOptional<z.ZodObject<{
                 autoCreate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 autoMerge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 requireReviews: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 deleteBranchOnMerge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                autoCreate: boolean;
+                autoMerge: boolean;
+                requireReviews: boolean;
+                deleteBranchOnMerge: boolean;
+            }, {
+                autoCreate?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                requireReviews?: boolean | undefined;
+                deleteBranchOnMerge?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            repository: {
+                name: string;
+                owner: string;
+            };
+            connector: string;
+            featureBranch: string;
+            pullRequest?: {
+                autoCreate: boolean;
+                autoMerge: boolean;
+                requireReviews: boolean;
+                deleteBranchOnMerge: boolean;
+            } | undefined;
+        }, {
+            repository: {
+                name: string;
+                owner: string;
+            };
+            connector: string;
+            featureBranch?: string | undefined;
+            pullRequest?: {
+                autoCreate?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                requireReviews?: boolean | undefined;
+                deleteBranchOnMerge?: boolean | undefined;
+            } | undefined;
+        }>;
+        /**
+         * Vercel integration
+         */
         vercel: z.ZodObject<{
+            /**
+             * Vercel connector reference
+             */
             connector: z.ZodString;
+            /**
+             * Project name
+             */
             project: z.ZodString;
+            /**
+             * Environment mapping
+             */
             environments: z.ZodOptional<z.ZodObject<{
                 production: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-                preview: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            }, z.core.$strip>>;
+                preview: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+            }, "strip", z.ZodTypeAny, {
+                production: string;
+                preview: string[];
+            }, {
+                production?: string | undefined;
+                preview?: string[] | undefined;
+            }>>;
+            /**
+             * Deployment configuration
+             */
             deployment: z.ZodOptional<z.ZodObject<{
                 autoDeployProduction: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 autoDeployPreview: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 requireApproval: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                autoDeployProduction: boolean;
+                autoDeployPreview: boolean;
+                requireApproval: boolean;
+            }, {
+                autoDeployProduction?: boolean | undefined;
+                autoDeployPreview?: boolean | undefined;
+                requireApproval?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            connector: string;
+            project: string;
+            deployment?: {
+                autoDeployProduction: boolean;
+                autoDeployPreview: boolean;
+                requireApproval: boolean;
+            } | undefined;
+            environments?: {
+                production: string;
+                preview: string[];
+            } | undefined;
+        }, {
+            connector: string;
+            project: string;
+            deployment?: {
+                autoDeployProduction?: boolean | undefined;
+                autoDeployPreview?: boolean | undefined;
+                requireApproval?: boolean | undefined;
+            } | undefined;
+            environments?: {
+                production?: string | undefined;
+                preview?: string[] | undefined;
+            } | undefined;
+        }>;
+        /**
+         * Additional integrations
+         */
         additional: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        vercel: {
+            connector: string;
+            project: string;
+            deployment?: {
+                autoDeployProduction: boolean;
+                autoDeployPreview: boolean;
+                requireApproval: boolean;
+            } | undefined;
+            environments?: {
+                production: string;
+                preview: string[];
+            } | undefined;
+        };
+        github: {
+            repository: {
+                name: string;
+                owner: string;
+            };
+            connector: string;
+            featureBranch: string;
+            pullRequest?: {
+                autoCreate: boolean;
+                autoMerge: boolean;
+                requireReviews: boolean;
+                deleteBranchOnMerge: boolean;
+            } | undefined;
+        };
+        additional?: Record<string, any> | undefined;
+    }, {
+        vercel: {
+            connector: string;
+            project: string;
+            deployment?: {
+                autoDeployProduction?: boolean | undefined;
+                autoDeployPreview?: boolean | undefined;
+                requireApproval?: boolean | undefined;
+            } | undefined;
+            environments?: {
+                production?: string | undefined;
+                preview?: string[] | undefined;
+            } | undefined;
+        };
+        github: {
+            repository: {
+                name: string;
+                owner: string;
+            };
+            connector: string;
+            featureBranch?: string | undefined;
+            pullRequest?: {
+                autoCreate?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                requireReviews?: boolean | undefined;
+                deleteBranchOnMerge?: boolean | undefined;
+            } | undefined;
+        };
+        additional?: Record<string, any> | undefined;
+    }>;
+    /**
+     * Self-iteration configuration
+     */
     selfIteration: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         iterationFrequency: z.ZodOptional<z.ZodString>;
-        optimizationGoals: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            documentation: "documentation";
-            performance: "performance";
-            security: "security";
-            code_quality: "code_quality";
-            test_coverage: "test_coverage";
-        }>>>;
-        learningMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            conservative: "conservative";
-            balanced: "balanced";
-            aggressive: "aggressive";
-        }>>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        optimizationGoals: z.ZodOptional<z.ZodArray<z.ZodEnum<["performance", "security", "code_quality", "test_coverage", "documentation"]>, "many">>;
+        learningMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["conservative", "balanced", "aggressive"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        learningMode: "conservative" | "balanced" | "aggressive";
+        iterationFrequency?: string | undefined;
+        optimizationGoals?: ("documentation" | "security" | "performance" | "code_quality" | "test_coverage")[] | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        iterationFrequency?: string | undefined;
+        optimizationGoals?: ("documentation" | "security" | "performance" | "code_quality" | "test_coverage")[] | undefined;
+        learningMode?: "conservative" | "balanced" | "aggressive" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    name: string;
+    active: boolean;
+    role: string;
+    visibility: "private" | "global" | "organization";
+    instructions: string;
+    integrations: {
+        vercel: {
+            connector: string;
+            project: string;
+            deployment?: {
+                autoDeployProduction: boolean;
+                autoDeployPreview: boolean;
+                requireApproval: boolean;
+            } | undefined;
+            environments?: {
+                production: string;
+                preview: string[];
+            } | undefined;
+        };
+        github: {
+            repository: {
+                name: string;
+                owner: string;
+            };
+            connector: string;
+            featureBranch: string;
+            pullRequest?: {
+                autoCreate: boolean;
+                autoMerge: boolean;
+                requireReviews: boolean;
+                deleteBranchOnMerge: boolean;
+            } | undefined;
+        };
+        additional?: Record<string, any> | undefined;
+    };
+    developmentConfig: {
+        specificationSource: string;
+        codeGeneration: {
+            enabled: boolean;
+            targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+            includeTests: boolean;
+            includeDocumentation: boolean;
+            validationMode: "strict" | "moderate" | "permissive";
+            templateRepo?: string | undefined;
+            styleGuide?: string | undefined;
+        };
+        testing?: {
+            enabled: boolean;
+            testTypes: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[];
+            coverageThreshold: number;
+            preCommitTests: boolean;
+            autoFix: boolean;
+            framework?: string | undefined;
+        } | undefined;
+        linting?: {
+            enabled: boolean;
+            autoFix: boolean;
+            rules?: Record<string, any> | undefined;
+        } | undefined;
+        formatting?: {
+            enabled: boolean;
+            autoFormat: boolean;
+            config?: Record<string, any> | undefined;
+        } | undefined;
+    };
+    avatar?: string | undefined;
+    tenantId?: string | undefined;
+    access?: string[] | undefined;
+    monitoring?: {
+        enabled: boolean;
+        metrics: ("errors" | "performance" | "availability" | "latency" | "usage")[];
+        alerts?: {
+            name: string;
+            threshold: number;
+            severity: "warning" | "info" | "critical";
+            metric: string;
+        }[] | undefined;
+        integrations?: string[] | undefined;
+    } | undefined;
+    model?: {
+        provider: "local" | "openai" | "azure_openai" | "anthropic";
+        model: string;
+        temperature: number;
+        maxTokens?: number | undefined;
+        topP?: number | undefined;
+    } | undefined;
+    tools?: {
+        type: "query" | "action" | "flow" | "vector_search";
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
+    knowledge?: {
+        indexes: string[];
+        topics: string[];
+    } | undefined;
+    pipelines?: {
+        name: string;
+        stages: {
+            type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+            order: number;
+            name: string;
+            timeout: number;
+            maxRetries: number;
+            parallel: boolean;
+            commands: string[];
+            retryOnFailure: boolean;
+            env?: Record<string, string> | undefined;
+        }[];
+        trigger: "push" | "manual" | "schedule" | "pull_request" | "release";
+        notifications?: {
+            onFailure: boolean;
+            onSuccess: boolean;
+            channels?: string[] | undefined;
+        } | undefined;
+        branches?: string[] | undefined;
+    }[] | undefined;
+    versionManagement?: {
+        prefix: string;
+        scheme: "custom" | "semver" | "calver";
+        autoIncrement: "none" | "major" | "minor" | "patch";
+        generateChangelog: boolean;
+        changelogFormat: "custom" | "conventional" | "keepachangelog";
+        tagReleases: boolean;
+    } | undefined;
+    deploymentStrategy?: {
+        type: "rolling" | "canary" | "blue_green" | "recreate";
+        canaryPercentage: number;
+        healthCheckTimeout: number;
+        autoRollback: boolean;
+        healthCheckUrl?: string | undefined;
+        smokeTests?: string[] | undefined;
+    } | undefined;
+    selfIteration?: {
+        enabled: boolean;
+        learningMode: "conservative" | "balanced" | "aggressive";
+        iterationFrequency?: string | undefined;
+        optimizationGoals?: ("documentation" | "security" | "performance" | "code_quality" | "test_coverage")[] | undefined;
+    } | undefined;
+}, {
+    label: string;
+    name: string;
+    role: string;
+    instructions: string;
+    integrations: {
+        vercel: {
+            connector: string;
+            project: string;
+            deployment?: {
+                autoDeployProduction?: boolean | undefined;
+                autoDeployPreview?: boolean | undefined;
+                requireApproval?: boolean | undefined;
+            } | undefined;
+            environments?: {
+                production?: string | undefined;
+                preview?: string[] | undefined;
+            } | undefined;
+        };
+        github: {
+            repository: {
+                name: string;
+                owner: string;
+            };
+            connector: string;
+            featureBranch?: string | undefined;
+            pullRequest?: {
+                autoCreate?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                requireReviews?: boolean | undefined;
+                deleteBranchOnMerge?: boolean | undefined;
+            } | undefined;
+        };
+        additional?: Record<string, any> | undefined;
+    };
+    developmentConfig: {
+        specificationSource: string;
+        codeGeneration: {
+            targets: ("database" | "api" | "documentation" | "backend" | "frontend" | "tests" | "infrastructure")[];
+            enabled?: boolean | undefined;
+            templateRepo?: string | undefined;
+            styleGuide?: string | undefined;
+            includeTests?: boolean | undefined;
+            includeDocumentation?: boolean | undefined;
+            validationMode?: "strict" | "moderate" | "permissive" | undefined;
+        };
+        testing?: {
+            enabled?: boolean | undefined;
+            testTypes?: ("security" | "integration" | "performance" | "unit" | "e2e" | "accessibility")[] | undefined;
+            coverageThreshold?: number | undefined;
+            framework?: string | undefined;
+            preCommitTests?: boolean | undefined;
+            autoFix?: boolean | undefined;
+        } | undefined;
+        linting?: {
+            enabled?: boolean | undefined;
+            rules?: Record<string, any> | undefined;
+            autoFix?: boolean | undefined;
+        } | undefined;
+        formatting?: {
+            enabled?: boolean | undefined;
+            config?: Record<string, any> | undefined;
+            autoFormat?: boolean | undefined;
+        } | undefined;
+    };
+    avatar?: string | undefined;
+    active?: boolean | undefined;
+    tenantId?: string | undefined;
+    access?: string[] | undefined;
+    visibility?: "private" | "global" | "organization" | undefined;
+    monitoring?: {
+        enabled?: boolean | undefined;
+        alerts?: {
+            name: string;
+            threshold: number;
+            severity: "warning" | "info" | "critical";
+            metric: string;
+        }[] | undefined;
+        metrics?: ("errors" | "performance" | "availability" | "latency" | "usage")[] | undefined;
+        integrations?: string[] | undefined;
+    } | undefined;
+    model?: {
+        model: string;
+        provider?: "local" | "openai" | "azure_openai" | "anthropic" | undefined;
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        topP?: number | undefined;
+    } | undefined;
+    tools?: {
+        type: "query" | "action" | "flow" | "vector_search";
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
+    knowledge?: {
+        indexes: string[];
+        topics: string[];
+    } | undefined;
+    pipelines?: {
+        name: string;
+        stages: {
+            type: "rollback" | "test" | "build" | "lint" | "security_scan" | "deploy" | "smoke_test";
+            order: number;
+            name: string;
+            commands: string[];
+            timeout?: number | undefined;
+            env?: Record<string, string> | undefined;
+            maxRetries?: number | undefined;
+            parallel?: boolean | undefined;
+            retryOnFailure?: boolean | undefined;
+        }[];
+        trigger: "push" | "manual" | "schedule" | "pull_request" | "release";
+        notifications?: {
+            channels?: string[] | undefined;
+            onFailure?: boolean | undefined;
+            onSuccess?: boolean | undefined;
+        } | undefined;
+        branches?: string[] | undefined;
+    }[] | undefined;
+    versionManagement?: {
+        prefix?: string | undefined;
+        scheme?: "custom" | "semver" | "calver" | undefined;
+        autoIncrement?: "none" | "major" | "minor" | "patch" | undefined;
+        generateChangelog?: boolean | undefined;
+        changelogFormat?: "custom" | "conventional" | "keepachangelog" | undefined;
+        tagReleases?: boolean | undefined;
+    } | undefined;
+    deploymentStrategy?: {
+        type?: "rolling" | "canary" | "blue_green" | "recreate" | undefined;
+        canaryPercentage?: number | undefined;
+        healthCheckUrl?: string | undefined;
+        healthCheckTimeout?: number | undefined;
+        autoRollback?: boolean | undefined;
+        smokeTests?: string[] | undefined;
+    } | undefined;
+    selfIteration?: {
+        enabled?: boolean | undefined;
+        iterationFrequency?: string | undefined;
+        optimizationGoals?: ("documentation" | "security" | "performance" | "code_quality" | "test_coverage")[] | undefined;
+        learningMode?: "conservative" | "balanced" | "aggressive" | undefined;
+    } | undefined;
+}>;
 export type DevOpsAgent = z.infer<typeof DevOpsAgentSchema>;
 /**
  * DevOps Tools Extension
@@ -594,18 +2067,17 @@ export type DevOpsAgent = z.infer<typeof DevOpsAgentSchema>;
 export declare const DevOpsToolSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    type: z.ZodEnum<{
-        query: "query";
-        flow: "flow";
-        action: "action";
-        monitoring: "monitoring";
-        deployment: "deployment";
-        vector_search: "vector_search";
-        git_operation: "git_operation";
-        code_generation: "code_generation";
-        test_execution: "test_execution";
-    }>;
-}, z.core.$strip>;
+} & {
+    type: z.ZodEnum<["action", "flow", "query", "vector_search", "git_operation", "code_generation", "test_execution", "deployment", "monitoring"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "query" | "action" | "flow" | "monitoring" | "deployment" | "vector_search" | "git_operation" | "code_generation" | "test_execution";
+    name: string;
+    description?: string | undefined;
+}, {
+    type: "query" | "action" | "flow" | "monitoring" | "deployment" | "vector_search" | "git_operation" | "code_generation" | "test_execution";
+    name: string;
+    description?: string | undefined;
+}>;
 export type DevOpsTool = z.infer<typeof DevOpsToolSchema>;
 /**
  * Example: Full-Stack DevOps Agent