@objectstack/spec 0.9.2 → 1.0.0

package/dist/hub/hub-federation.zod.d.ts

@@ -20,745 +20,2411 @@ import { z } from 'zod';
  * Geographic Region
  */
 export declare const RegionSchema: z.ZodObject<{
+    /**
+     * Region identifier (e.g., us-east-1, eu-west-1, ap-southeast-1)
+     */
     id: z.ZodString;
+    /**
+     * Display name
+     */
     name: z.ZodString;
+    /**
+     * Geographic location
+     */
     location: z.ZodObject<{
-        continent: z.ZodEnum<{
-            NA: "NA";
-            SA: "SA";
-            EU: "EU";
-            AF: "AF";
-            AS: "AS";
-            OC: "OC";
-            AN: "AN";
-        }>;
+        continent: z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>;
         country: z.ZodString;
         city: z.ZodOptional<z.ZodString>;
         latitude: z.ZodOptional<z.ZodNumber>;
         longitude: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    }, {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    }>;
+    /**
+     * Cloud provider and region mapping
+     */
     provider: z.ZodOptional<z.ZodObject<{
-        name: z.ZodEnum<{
-            vercel: "vercel";
-            aws: "aws";
-            azure: "azure";
-            gcp: "gcp";
-            cloudflare: "cloudflare";
-            "self-hosted": "self-hosted";
-        }>;
+        name: z.ZodEnum<["aws", "azure", "gcp", "cloudflare", "vercel", "self-hosted"]>;
         region: z.ZodString;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+        region: string;
+    }, {
+        name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+        region: string;
+    }>>;
+    /**
+     * Region capabilities
+     */
     capabilities: z.ZodOptional<z.ZodObject<{
-        databases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            mysql: "mysql";
-            mongodb: "mongodb";
-            redis: "redis";
-            postgres: "postgres";
-        }>>>;
-        storage: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            s3: "s3";
-            gcs: "gcs";
-            "azure-blob": "azure-blob";
-        }>>>;
-        compute: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            vm: "vm";
-            containers: "containers";
-            serverless: "serverless";
-        }>>>;
+        databases: z.ZodDefault<z.ZodArray<z.ZodEnum<["postgres", "mysql", "mongodb", "redis"]>, "many">>;
+        storage: z.ZodDefault<z.ZodArray<z.ZodEnum<["s3", "azure-blob", "gcs"]>, "many">>;
+        compute: z.ZodDefault<z.ZodArray<z.ZodEnum<["containers", "serverless", "vm"]>, "many">>;
         cdn: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        hipaa: "hipaa";
-        gdpr: "gdpr";
-        soc2: "soc2";
-        iso27001: "iso27001";
-        "pci-dss": "pci-dss";
-    }>>>;
-    status: z.ZodDefault<z.ZodEnum<{
-        deprecated: "deprecated";
-        active: "active";
-        maintenance: "maintenance";
-        "read-only": "read-only";
+    }, "strip", z.ZodTypeAny, {
+        cdn: boolean;
+        storage: ("s3" | "gcs" | "azure-blob")[];
+        databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+        compute: ("vm" | "containers" | "serverless")[];
+    }, {
+        cdn?: boolean | undefined;
+        storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+        databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+        compute?: ("vm" | "containers" | "serverless")[] | undefined;
     }>>;
+    /**
+     * Compliance and certifications
+     */
+    compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<["gdpr", "hipaa", "soc2", "iso27001", "pci-dss"]>, "many">>;
+    /**
+     * Region status
+     */
+    status: z.ZodDefault<z.ZodEnum<["active", "read-only", "maintenance", "deprecated"]>>;
+    /**
+     * Resource limits for this region
+     */
     limits: z.ZodOptional<z.ZodObject<{
         maxSpaces: z.ZodOptional<z.ZodNumber>;
         maxTenants: z.ZodOptional<z.ZodNumber>;
         maxStorage: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        maxStorage?: number | undefined;
+        maxSpaces?: number | undefined;
+        maxTenants?: number | undefined;
+    }, {
+        maxStorage?: number | undefined;
+        maxSpaces?: number | undefined;
+        maxTenants?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "deprecated" | "maintenance" | "read-only";
+    location: {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    };
+    name: string;
+    id: string;
+    compliance: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[];
+    provider?: {
+        name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+        region: string;
+    } | undefined;
+    capabilities?: {
+        cdn: boolean;
+        storage: ("s3" | "gcs" | "azure-blob")[];
+        databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+        compute: ("vm" | "containers" | "serverless")[];
+    } | undefined;
+    limits?: {
+        maxStorage?: number | undefined;
+        maxSpaces?: number | undefined;
+        maxTenants?: number | undefined;
+    } | undefined;
+}, {
+    location: {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    };
+    name: string;
+    id: string;
+    status?: "active" | "deprecated" | "maintenance" | "read-only" | undefined;
+    provider?: {
+        name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+        region: string;
+    } | undefined;
+    capabilities?: {
+        cdn?: boolean | undefined;
+        storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+        databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+        compute?: ("vm" | "containers" | "serverless")[] | undefined;
+    } | undefined;
+    compliance?: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[] | undefined;
+    limits?: {
+        maxStorage?: number | undefined;
+        maxSpaces?: number | undefined;
+        maxTenants?: number | undefined;
+    } | undefined;
+}>;
 export type Region = z.infer<typeof RegionSchema>;
 /**
  * Hub Instance
  * Represents a single Hub deployment in a region
  */
 export declare const HubInstanceSchema: z.ZodObject<{
+    /**
+     * Instance identifier
+     */
     id: z.ZodString;
+    /**
+     * Region where this hub is deployed
+     */
     regionId: z.ZodString;
-    role: z.ZodEnum<{
-        primary: "primary";
-        secondary: "secondary";
-        edge: "edge";
-    }>;
+    /**
+     * Hub role in federation
+     */
+    role: z.ZodEnum<["primary", "secondary", "edge"]>;
+    /**
+     * Endpoint URLs
+     */
     endpoints: z.ZodObject<{
         api: z.ZodString;
         admin: z.ZodOptional<z.ZodString>;
         grpc: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        api: string;
+        admin?: string | undefined;
+        grpc?: string | undefined;
+    }, {
+        api: string;
+        admin?: string | undefined;
+        grpc?: string | undefined;
+    }>;
+    /**
+     * Replication configuration
+     */
     replication: z.ZodOptional<z.ZodObject<{
+        /**
+         * Source hub for replication (if this is a secondary)
+         */
         primaryHubId: z.ZodOptional<z.ZodString>;
+        /**
+         * Replication lag tolerance in seconds
+         */
         lagTolerance: z.ZodDefault<z.ZodNumber>;
-        mode: z.ZodDefault<z.ZodEnum<{
-            async: "async";
-            sync: "sync";
-            "semi-sync": "semi-sync";
-        }>>;
-    }, z.core.$strip>>;
+        /**
+         * Replication mode
+         */
+        mode: z.ZodDefault<z.ZodEnum<["sync", "async", "semi-sync"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "async" | "sync" | "semi-sync";
+        lagTolerance: number;
+        primaryHubId?: string | undefined;
+    }, {
+        mode?: "async" | "sync" | "semi-sync" | undefined;
+        primaryHubId?: string | undefined;
+        lagTolerance?: number | undefined;
+    }>>;
+    /**
+     * Health status
+     */
     health: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            healthy: "healthy";
-            degraded: "degraded";
-            unhealthy: "unhealthy";
-        }>;
+        status: z.ZodEnum<["healthy", "degraded", "unhealthy"]>;
         lastCheck: z.ZodString;
         uptime: z.ZodNumber;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "degraded" | "healthy" | "unhealthy";
+        uptime: number;
+        lastCheck: string;
+    }, {
+        status: "degraded" | "healthy" | "unhealthy";
+        uptime: number;
+        lastCheck: string;
+    }>>;
+    /**
+     * Version
+     */
     version: z.ZodString;
+    /**
+     * Metadata
+     */
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    id: string;
+    createdAt: string;
+    role: "primary" | "secondary" | "edge";
+    updatedAt: string;
+    endpoints: {
+        api: string;
+        admin?: string | undefined;
+        grpc?: string | undefined;
+    };
+    regionId: string;
+    replication?: {
+        mode: "async" | "sync" | "semi-sync";
+        lagTolerance: number;
+        primaryHubId?: string | undefined;
+    } | undefined;
+    health?: {
+        status: "degraded" | "healthy" | "unhealthy";
+        uptime: number;
+        lastCheck: string;
+    } | undefined;
+}, {
+    version: string;
+    id: string;
+    createdAt: string;
+    role: "primary" | "secondary" | "edge";
+    updatedAt: string;
+    endpoints: {
+        api: string;
+        admin?: string | undefined;
+        grpc?: string | undefined;
+    };
+    regionId: string;
+    replication?: {
+        mode?: "async" | "sync" | "semi-sync" | undefined;
+        primaryHubId?: string | undefined;
+        lagTolerance?: number | undefined;
+    } | undefined;
+    health?: {
+        status: "degraded" | "healthy" | "unhealthy";
+        uptime: number;
+        lastCheck: string;
+    } | undefined;
+}>;
 export type HubInstance = z.infer<typeof HubInstanceSchema>;
 /**
  * Federation Topology
  * Defines the global hub network architecture
  */
 export declare const FederationTopologySchema: z.ZodObject<{
+    /**
+     * Federation identifier
+     */
     id: z.ZodString;
+    /**
+     * Federation name
+     */
     name: z.ZodString;
+    /**
+     * Regions in this federation
+     */
     regions: z.ZodArray<z.ZodObject<{
+        /**
+         * Region identifier (e.g., us-east-1, eu-west-1, ap-southeast-1)
+         */
         id: z.ZodString;
+        /**
+         * Display name
+         */
         name: z.ZodString;
+        /**
+         * Geographic location
+         */
         location: z.ZodObject<{
-            continent: z.ZodEnum<{
-                NA: "NA";
-                SA: "SA";
-                EU: "EU";
-                AF: "AF";
-                AS: "AS";
-                OC: "OC";
-                AN: "AN";
-            }>;
+            continent: z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>;
             country: z.ZodString;
             city: z.ZodOptional<z.ZodString>;
             latitude: z.ZodOptional<z.ZodNumber>;
             longitude: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        }, {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        }>;
+        /**
+         * Cloud provider and region mapping
+         */
         provider: z.ZodOptional<z.ZodObject<{
-            name: z.ZodEnum<{
-                vercel: "vercel";
-                aws: "aws";
-                azure: "azure";
-                gcp: "gcp";
-                cloudflare: "cloudflare";
-                "self-hosted": "self-hosted";
-            }>;
+            name: z.ZodEnum<["aws", "azure", "gcp", "cloudflare", "vercel", "self-hosted"]>;
             region: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        }, {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        }>>;
+        /**
+         * Region capabilities
+         */
         capabilities: z.ZodOptional<z.ZodObject<{
-            databases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                mysql: "mysql";
-                mongodb: "mongodb";
-                redis: "redis";
-                postgres: "postgres";
-            }>>>;
-            storage: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                s3: "s3";
-                gcs: "gcs";
-                "azure-blob": "azure-blob";
-            }>>>;
-            compute: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                vm: "vm";
-                containers: "containers";
-                serverless: "serverless";
-            }>>>;
+            databases: z.ZodDefault<z.ZodArray<z.ZodEnum<["postgres", "mysql", "mongodb", "redis"]>, "many">>;
+            storage: z.ZodDefault<z.ZodArray<z.ZodEnum<["s3", "azure-blob", "gcs"]>, "many">>;
+            compute: z.ZodDefault<z.ZodArray<z.ZodEnum<["containers", "serverless", "vm"]>, "many">>;
             cdn: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            hipaa: "hipaa";
-            gdpr: "gdpr";
-            soc2: "soc2";
-            iso27001: "iso27001";
-            "pci-dss": "pci-dss";
-        }>>>;
-        status: z.ZodDefault<z.ZodEnum<{
-            deprecated: "deprecated";
-            active: "active";
-            maintenance: "maintenance";
-            "read-only": "read-only";
+        }, "strip", z.ZodTypeAny, {
+            cdn: boolean;
+            storage: ("s3" | "gcs" | "azure-blob")[];
+            databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+            compute: ("vm" | "containers" | "serverless")[];
+        }, {
+            cdn?: boolean | undefined;
+            storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+            databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+            compute?: ("vm" | "containers" | "serverless")[] | undefined;
         }>>;
+        /**
+         * Compliance and certifications
+         */
+        compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<["gdpr", "hipaa", "soc2", "iso27001", "pci-dss"]>, "many">>;
+        /**
+         * Region status
+         */
+        status: z.ZodDefault<z.ZodEnum<["active", "read-only", "maintenance", "deprecated"]>>;
+        /**
+         * Resource limits for this region
+         */
         limits: z.ZodOptional<z.ZodObject<{
             maxSpaces: z.ZodOptional<z.ZodNumber>;
             maxTenants: z.ZodOptional<z.ZodNumber>;
             maxStorage: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        }, {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "deprecated" | "maintenance" | "read-only";
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        name: string;
+        id: string;
+        compliance: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[];
+        provider?: {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        } | undefined;
+        capabilities?: {
+            cdn: boolean;
+            storage: ("s3" | "gcs" | "azure-blob")[];
+            databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+            compute: ("vm" | "containers" | "serverless")[];
+        } | undefined;
+        limits?: {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        } | undefined;
+    }, {
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        name: string;
+        id: string;
+        status?: "active" | "deprecated" | "maintenance" | "read-only" | undefined;
+        provider?: {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        } | undefined;
+        capabilities?: {
+            cdn?: boolean | undefined;
+            storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+            databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+            compute?: ("vm" | "containers" | "serverless")[] | undefined;
+        } | undefined;
+        compliance?: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[] | undefined;
+        limits?: {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        } | undefined;
+    }>, "many">;
+    /**
+     * Hub instances
+     */
     hubs: z.ZodArray<z.ZodObject<{
+        /**
+         * Instance identifier
+         */
         id: z.ZodString;
+        /**
+         * Region where this hub is deployed
+         */
         regionId: z.ZodString;
-        role: z.ZodEnum<{
-            primary: "primary";
-            secondary: "secondary";
-            edge: "edge";
-        }>;
+        /**
+         * Hub role in federation
+         */
+        role: z.ZodEnum<["primary", "secondary", "edge"]>;
+        /**
+         * Endpoint URLs
+         */
         endpoints: z.ZodObject<{
             api: z.ZodString;
             admin: z.ZodOptional<z.ZodString>;
             grpc: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        }, {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        }>;
+        /**
+         * Replication configuration
+         */
         replication: z.ZodOptional<z.ZodObject<{
+            /**
+             * Source hub for replication (if this is a secondary)
+             */
             primaryHubId: z.ZodOptional<z.ZodString>;
+            /**
+             * Replication lag tolerance in seconds
+             */
             lagTolerance: z.ZodDefault<z.ZodNumber>;
-            mode: z.ZodDefault<z.ZodEnum<{
-                async: "async";
-                sync: "sync";
-                "semi-sync": "semi-sync";
-            }>>;
-        }, z.core.$strip>>;
+            /**
+             * Replication mode
+             */
+            mode: z.ZodDefault<z.ZodEnum<["sync", "async", "semi-sync"]>>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "async" | "sync" | "semi-sync";
+            lagTolerance: number;
+            primaryHubId?: string | undefined;
+        }, {
+            mode?: "async" | "sync" | "semi-sync" | undefined;
+            primaryHubId?: string | undefined;
+            lagTolerance?: number | undefined;
+        }>>;
+        /**
+         * Health status
+         */
         health: z.ZodOptional<z.ZodObject<{
-            status: z.ZodEnum<{
-                healthy: "healthy";
-                degraded: "degraded";
-                unhealthy: "unhealthy";
-            }>;
+            status: z.ZodEnum<["healthy", "degraded", "unhealthy"]>;
             lastCheck: z.ZodString;
             uptime: z.ZodNumber;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        }, {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        }>>;
+        /**
+         * Version
+         */
         version: z.ZodString;
+        /**
+         * Metadata
+         */
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        id: string;
+        createdAt: string;
+        role: "primary" | "secondary" | "edge";
+        updatedAt: string;
+        endpoints: {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        };
+        regionId: string;
+        replication?: {
+            mode: "async" | "sync" | "semi-sync";
+            lagTolerance: number;
+            primaryHubId?: string | undefined;
+        } | undefined;
+        health?: {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        } | undefined;
+    }, {
+        version: string;
+        id: string;
+        createdAt: string;
+        role: "primary" | "secondary" | "edge";
+        updatedAt: string;
+        endpoints: {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        };
+        regionId: string;
+        replication?: {
+            mode?: "async" | "sync" | "semi-sync" | undefined;
+            primaryHubId?: string | undefined;
+            lagTolerance?: number | undefined;
+        } | undefined;
+        health?: {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        } | undefined;
+    }>, "many">;
+    /**
+     * Routing strategy
+     */
     routing: z.ZodObject<{
-        strategy: z.ZodDefault<z.ZodEnum<{
-            custom: "custom";
-            "geo-proximity": "geo-proximity";
-            "data-residency": "data-residency";
-            "least-loaded": "least-loaded";
-        }>>;
+        /**
+         * How to route tenant requests
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["geo-proximity", "data-residency", "least-loaded", "custom"]>>;
+        /**
+         * Failover behavior
+         */
         failover: z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             maxRetries: z.ZodDefault<z.ZodNumber>;
             timeout: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            timeout: number;
+            maxRetries: number;
+        }, {
+            enabled?: boolean | undefined;
+            timeout?: number | undefined;
+            maxRetries?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "custom" | "geo-proximity" | "data-residency" | "least-loaded";
+        failover: {
+            enabled: boolean;
+            timeout: number;
+            maxRetries: number;
+        };
+    }, {
+        failover: {
+            enabled?: boolean | undefined;
+            timeout?: number | undefined;
+            maxRetries?: number | undefined;
+        };
+        strategy?: "custom" | "geo-proximity" | "data-residency" | "least-loaded" | undefined;
+    }>;
+    /**
+     * Data synchronization settings
+     */
     synchronization: z.ZodObject<{
+        /**
+         * What data to sync across regions
+         */
         scope: z.ZodObject<{
+            /**
+             * Sync plugin registry
+             */
             plugins: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Sync tenant metadata (not data)
+             */
             tenants: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Sync spaces metadata
+             */
             spaces: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Sync licenses
+             */
             licenses: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>;
-        frequency: z.ZodDefault<z.ZodEnum<{
-            realtime: "realtime";
-            hourly: "hourly";
-            daily: "daily";
-        }>>;
-        conflictResolution: z.ZodDefault<z.ZodEnum<{
-            manual: "manual";
-            "last-write-wins": "last-write-wins";
-            "primary-wins": "primary-wins";
-        }>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            spaces: boolean;
+            plugins: boolean;
+            tenants: boolean;
+            licenses: boolean;
+        }, {
+            spaces?: boolean | undefined;
+            plugins?: boolean | undefined;
+            tenants?: boolean | undefined;
+            licenses?: boolean | undefined;
+        }>;
+        /**
+         * Sync frequency
+         */
+        frequency: z.ZodDefault<z.ZodEnum<["realtime", "hourly", "daily"]>>;
+        /**
+         * Conflict resolution
+         */
+        conflictResolution: z.ZodDefault<z.ZodEnum<["last-write-wins", "primary-wins", "manual"]>>;
+    }, "strip", z.ZodTypeAny, {
+        scope: {
+            spaces: boolean;
+            plugins: boolean;
+            tenants: boolean;
+            licenses: boolean;
+        };
+        conflictResolution: "manual" | "last-write-wins" | "primary-wins";
+        frequency: "hourly" | "daily" | "realtime";
+    }, {
+        scope: {
+            spaces?: boolean | undefined;
+            plugins?: boolean | undefined;
+            tenants?: boolean | undefined;
+            licenses?: boolean | undefined;
+        };
+        conflictResolution?: "manual" | "last-write-wins" | "primary-wins" | undefined;
+        frequency?: "hourly" | "daily" | "realtime" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    regions: {
+        status: "active" | "deprecated" | "maintenance" | "read-only";
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        name: string;
+        id: string;
+        compliance: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[];
+        provider?: {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        } | undefined;
+        capabilities?: {
+            cdn: boolean;
+            storage: ("s3" | "gcs" | "azure-blob")[];
+            databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+            compute: ("vm" | "containers" | "serverless")[];
+        } | undefined;
+        limits?: {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        } | undefined;
+    }[];
+    routing: {
+        strategy: "custom" | "geo-proximity" | "data-residency" | "least-loaded";
+        failover: {
+            enabled: boolean;
+            timeout: number;
+            maxRetries: number;
+        };
+    };
+    hubs: {
+        version: string;
+        id: string;
+        createdAt: string;
+        role: "primary" | "secondary" | "edge";
+        updatedAt: string;
+        endpoints: {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        };
+        regionId: string;
+        replication?: {
+            mode: "async" | "sync" | "semi-sync";
+            lagTolerance: number;
+            primaryHubId?: string | undefined;
+        } | undefined;
+        health?: {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        } | undefined;
+    }[];
+    synchronization: {
+        scope: {
+            spaces: boolean;
+            plugins: boolean;
+            tenants: boolean;
+            licenses: boolean;
+        };
+        conflictResolution: "manual" | "last-write-wins" | "primary-wins";
+        frequency: "hourly" | "daily" | "realtime";
+    };
+}, {
+    name: string;
+    id: string;
+    regions: {
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        name: string;
+        id: string;
+        status?: "active" | "deprecated" | "maintenance" | "read-only" | undefined;
+        provider?: {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        } | undefined;
+        capabilities?: {
+            cdn?: boolean | undefined;
+            storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+            databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+            compute?: ("vm" | "containers" | "serverless")[] | undefined;
+        } | undefined;
+        compliance?: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[] | undefined;
+        limits?: {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        } | undefined;
+    }[];
+    routing: {
+        failover: {
+            enabled?: boolean | undefined;
+            timeout?: number | undefined;
+            maxRetries?: number | undefined;
+        };
+        strategy?: "custom" | "geo-proximity" | "data-residency" | "least-loaded" | undefined;
+    };
+    hubs: {
+        version: string;
+        id: string;
+        createdAt: string;
+        role: "primary" | "secondary" | "edge";
+        updatedAt: string;
+        endpoints: {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        };
+        regionId: string;
+        replication?: {
+            mode?: "async" | "sync" | "semi-sync" | undefined;
+            primaryHubId?: string | undefined;
+            lagTolerance?: number | undefined;
+        } | undefined;
+        health?: {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        } | undefined;
+    }[];
+    synchronization: {
+        scope: {
+            spaces?: boolean | undefined;
+            plugins?: boolean | undefined;
+            tenants?: boolean | undefined;
+            licenses?: boolean | undefined;
+        };
+        conflictResolution?: "manual" | "last-write-wins" | "primary-wins" | undefined;
+        frequency?: "hourly" | "daily" | "realtime" | undefined;
+    };
+}>;
 export type FederationTopology = z.infer<typeof FederationTopologySchema>;
 /**
  * Tenant Placement Policy
  * Determines where a tenant's data and runtime reside
  */
 export declare const TenantPlacementPolicySchema: z.ZodObject<{
+    /**
+     * Tenant identifier
+     */
     tenantId: z.ZodString;
+    /**
+     * Primary region (where tenant data lives)
+     */
     primaryRegion: z.ZodString;
-    replicaRegions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /**
+     * Replica regions (for disaster recovery)
+     */
+    replicaRegions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Data residency constraints
+     */
     dataResidency: z.ZodOptional<z.ZodObject<{
-        allowedRegions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        prohibitedRegions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        continent: z.ZodOptional<z.ZodEnum<{
-            NA: "NA";
-            SA: "SA";
-            EU: "EU";
-            AF: "AF";
-            AS: "AS";
-            OC: "OC";
-            AN: "AN";
-        }>>;
-    }, z.core.$strip>>;
+        /**
+         * Allowed regions for data storage
+         */
+        allowedRegions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Prohibited regions
+         */
+        prohibitedRegions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Continent restriction
+         */
+        continent: z.ZodOptional<z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>>;
+    }, "strip", z.ZodTypeAny, {
+        prohibitedRegions: string[];
+        continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+        allowedRegions?: string[] | undefined;
+    }, {
+        continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+        allowedRegions?: string[] | undefined;
+        prohibitedRegions?: string[] | undefined;
+    }>>;
+    /**
+     * Failover policy
+     */
     failover: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable automatic failover
+         */
         enabled: z.ZodDefault<z.ZodBoolean>;
-        preferredOrder: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        /**
+         * Preferred failover order (region IDs)
+         */
+        preferredOrder: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Maximum acceptable latency for failover target (ms)
+         */
         maxLatency: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        preferredOrder: string[];
+        maxLatency: number;
+    }, {
+        enabled?: boolean | undefined;
+        preferredOrder?: string[] | undefined;
+        maxLatency?: number | undefined;
+    }>>;
+    /**
+     * Latency requirements
+     */
     latency: z.ZodOptional<z.ZodObject<{
+        /**
+         * Maximum acceptable latency for primary region (ms)
+         */
         maxPrimaryLatency: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Maximum acceptable latency for replicas (ms)
+         */
         maxReplicaLatency: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        maxPrimaryLatency: number;
+        maxReplicaLatency: number;
+    }, {
+        maxPrimaryLatency?: number | undefined;
+        maxReplicaLatency?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    tenantId: string;
+    primaryRegion: string;
+    replicaRegions: string[];
+    latency?: {
+        maxPrimaryLatency: number;
+        maxReplicaLatency: number;
+    } | undefined;
+    dataResidency?: {
+        prohibitedRegions: string[];
+        continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+        allowedRegions?: string[] | undefined;
+    } | undefined;
+    failover?: {
+        enabled: boolean;
+        preferredOrder: string[];
+        maxLatency: number;
+    } | undefined;
+}, {
+    tenantId: string;
+    primaryRegion: string;
+    latency?: {
+        maxPrimaryLatency?: number | undefined;
+        maxReplicaLatency?: number | undefined;
+    } | undefined;
+    dataResidency?: {
+        continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+        allowedRegions?: string[] | undefined;
+        prohibitedRegions?: string[] | undefined;
+    } | undefined;
+    failover?: {
+        enabled?: boolean | undefined;
+        preferredOrder?: string[] | undefined;
+        maxLatency?: number | undefined;
+    } | undefined;
+    replicaRegions?: string[] | undefined;
+}>;
 export type TenantPlacementPolicy = z.infer<typeof TenantPlacementPolicySchema>;
 /**
  * Cross-Region Replication Job
  */
 export declare const ReplicationJobSchema: z.ZodObject<{
+    /**
+     * Job identifier
+     */
     id: z.ZodString;
-    type: z.ZodEnum<{
-        "initial-sync": "initial-sync";
-        incremental: "incremental";
-        "conflict-resolution": "conflict-resolution";
-    }>;
+    /**
+     * Job type
+     */
+    type: z.ZodEnum<["initial-sync", "incremental", "conflict-resolution"]>;
+    /**
+     * Source hub
+     */
     sourceHubId: z.ZodString;
-    targetHubIds: z.ZodArray<z.ZodString>;
+    /**
+     * Target hub(s)
+     */
+    targetHubIds: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Resource scope
+     */
     scope: z.ZodObject<{
-        resourceType: z.ZodEnum<{
-            all: "all";
-            license: "license";
-            plugin: "plugin";
-            tenant: "tenant";
-            space: "space";
-        }>;
-        resourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>;
-    status: z.ZodEnum<{
-        pending: "pending";
-        completed: "completed";
-        failed: "failed";
-        running: "running";
-        cancelled: "cancelled";
+        /**
+         * Resource type
+         */
+        resourceType: z.ZodEnum<["plugin", "tenant", "space", "license", "all"]>;
+        /**
+         * Specific resource IDs (empty = all)
+         */
+        resourceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        resourceIds: string[];
+        resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+    }, {
+        resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+        resourceIds?: string[] | undefined;
     }>;
+    /**
+     * Job status
+     */
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+    /**
+     * Progress
+     */
     progress: z.ZodOptional<z.ZodObject<{
         total: z.ZodNumber;
         completed: z.ZodNumber;
         failed: z.ZodNumber;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        completed: number;
+        failed: number;
+    }, {
+        total: number;
+        completed: number;
+        failed: number;
+    }>>;
+    /**
+     * Timestamps
+     */
     createdAt: z.ZodString;
     startedAt: z.ZodOptional<z.ZodString>;
     completedAt: z.ZodOptional<z.ZodString>;
+    /**
+     * Errors
+     */
     errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
         timestamp: z.ZodString;
         resourceId: z.ZodString;
         error: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        timestamp: string;
+        resourceId: string;
+    }, {
+        error: string;
+        timestamp: string;
+        resourceId: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "initial-sync" | "incremental" | "conflict-resolution";
+    status: "running" | "completed" | "failed" | "cancelled" | "pending";
+    scope: {
+        resourceIds: string[];
+        resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+    };
+    id: string;
+    createdAt: string;
+    errors: {
+        error: string;
+        timestamp: string;
+        resourceId: string;
+    }[];
+    sourceHubId: string;
+    targetHubIds: string[];
+    progress?: {
+        total: number;
+        completed: number;
+        failed: number;
+    } | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+}, {
+    type: "initial-sync" | "incremental" | "conflict-resolution";
+    status: "running" | "completed" | "failed" | "cancelled" | "pending";
+    scope: {
+        resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+        resourceIds?: string[] | undefined;
+    };
+    id: string;
+    createdAt: string;
+    sourceHubId: string;
+    targetHubIds: string[];
+    progress?: {
+        total: number;
+        completed: number;
+        failed: number;
+    } | undefined;
+    errors?: {
+        error: string;
+        timestamp: string;
+        resourceId: string;
+    }[] | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+}>;
 export type ReplicationJob = z.infer<typeof ReplicationJobSchema>;
 /**
  * Global Registry Entry
  * Tracks where a resource exists across regions
  */
 export declare const GlobalRegistryEntrySchema: z.ZodObject<{
+    /**
+     * Resource identifier
+     */
     resourceId: z.ZodString;
-    resourceType: z.ZodEnum<{
-        license: "license";
-        plugin: "plugin";
-        tenant: "tenant";
-        space: "space";
-    }>;
+    /**
+     * Resource type
+     */
+    resourceType: z.ZodEnum<["plugin", "tenant", "space", "license"]>;
+    /**
+     * Regions where this resource exists
+     */
     locations: z.ZodArray<z.ZodObject<{
         regionId: z.ZodString;
         hubId: z.ZodString;
         isPrimary: z.ZodDefault<z.ZodBoolean>;
         lastSyncedAt: z.ZodOptional<z.ZodString>;
         version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        regionId: string;
+        hubId: string;
+        isPrimary: boolean;
+        version?: string | undefined;
+        lastSyncedAt?: string | undefined;
+    }, {
+        regionId: string;
+        hubId: string;
+        version?: string | undefined;
+        isPrimary?: boolean | undefined;
+        lastSyncedAt?: string | undefined;
+    }>, "many">;
+    /**
+     * Global version vector clock (for conflict detection)
+     */
     versionVector: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    locations: {
+        regionId: string;
+        hubId: string;
+        isPrimary: boolean;
+        version?: string | undefined;
+        lastSyncedAt?: string | undefined;
+    }[];
+    resourceType: "license" | "tenant" | "plugin" | "space";
+    resourceId: string;
+    versionVector?: Record<string, number> | undefined;
+}, {
+    locations: {
+        regionId: string;
+        hubId: string;
+        version?: string | undefined;
+        isPrimary?: boolean | undefined;
+        lastSyncedAt?: string | undefined;
+    }[];
+    resourceType: "license" | "tenant" | "plugin" | "space";
+    resourceId: string;
+    versionVector?: Record<string, number> | undefined;
+}>;
 export type GlobalRegistryEntry = z.infer<typeof GlobalRegistryEntrySchema>;
 /**
  * Edge Location
  * Represents a CDN/edge cache location
  */
 export declare const EdgeLocationSchema: z.ZodObject<{
+    /**
+     * Location identifier
+     */
     id: z.ZodString;
+    /**
+     * Parent region
+     */
     regionId: z.ZodString;
+    /**
+     * Location details
+     */
     location: z.ZodObject<{
-        continent: z.ZodEnum<{
-            NA: "NA";
-            SA: "SA";
-            EU: "EU";
-            AF: "AF";
-            AS: "AS";
-            OC: "OC";
-            AN: "AN";
-        }>;
+        continent: z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>;
         country: z.ZodString;
         city: z.ZodOptional<z.ZodString>;
         latitude: z.ZodOptional<z.ZodNumber>;
         longitude: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    }, {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    }>;
+    /**
+     * Caching configuration
+     */
     cache: z.ZodObject<{
-        resources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            plugins: "plugins";
-            "static-assets": "static-assets";
-            "api-responses": "api-responses";
-        }>>>;
+        /**
+         * What to cache at edge
+         */
+        resources: z.ZodDefault<z.ZodArray<z.ZodEnum<["plugins", "static-assets", "api-responses"]>, "many">>;
+        /**
+         * TTL in seconds
+         */
         ttl: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Cache size limit (bytes)
+         */
         maxSize: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    status: z.ZodDefault<z.ZodEnum<{
-        active: "active";
-        inactive: "inactive";
-    }>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        ttl: number;
+        resources: ("plugins" | "static-assets" | "api-responses")[];
+        maxSize?: number | undefined;
+    }, {
+        maxSize?: number | undefined;
+        ttl?: number | undefined;
+        resources?: ("plugins" | "static-assets" | "api-responses")[] | undefined;
+    }>;
+    /**
+     * Status
+     */
+    status: z.ZodDefault<z.ZodEnum<["active", "inactive"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "inactive";
+    location: {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    };
+    id: string;
+    cache: {
+        ttl: number;
+        resources: ("plugins" | "static-assets" | "api-responses")[];
+        maxSize?: number | undefined;
+    };
+    regionId: string;
+}, {
+    location: {
+        country: string;
+        continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        city?: string | undefined;
+    };
+    id: string;
+    cache: {
+        maxSize?: number | undefined;
+        ttl?: number | undefined;
+        resources?: ("plugins" | "static-assets" | "api-responses")[] | undefined;
+    };
+    regionId: string;
+    status?: "active" | "inactive" | undefined;
+}>;
 export type EdgeLocation = z.infer<typeof EdgeLocationSchema>;
 export declare const HubFederationProtocol: {
     readonly Region: z.ZodObject<{
+        /**
+         * Region identifier (e.g., us-east-1, eu-west-1, ap-southeast-1)
+         */
         id: z.ZodString;
+        /**
+         * Display name
+         */
         name: z.ZodString;
+        /**
+         * Geographic location
+         */
         location: z.ZodObject<{
-            continent: z.ZodEnum<{
-                NA: "NA";
-                SA: "SA";
-                EU: "EU";
-                AF: "AF";
-                AS: "AS";
-                OC: "OC";
-                AN: "AN";
-            }>;
+            continent: z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>;
             country: z.ZodString;
             city: z.ZodOptional<z.ZodString>;
             latitude: z.ZodOptional<z.ZodNumber>;
             longitude: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        }, {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        }>;
+        /**
+         * Cloud provider and region mapping
+         */
         provider: z.ZodOptional<z.ZodObject<{
-            name: z.ZodEnum<{
-                vercel: "vercel";
-                aws: "aws";
-                azure: "azure";
-                gcp: "gcp";
-                cloudflare: "cloudflare";
-                "self-hosted": "self-hosted";
-            }>;
+            name: z.ZodEnum<["aws", "azure", "gcp", "cloudflare", "vercel", "self-hosted"]>;
             region: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        }, {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        }>>;
+        /**
+         * Region capabilities
+         */
         capabilities: z.ZodOptional<z.ZodObject<{
-            databases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                mysql: "mysql";
-                mongodb: "mongodb";
-                redis: "redis";
-                postgres: "postgres";
-            }>>>;
-            storage: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                s3: "s3";
-                gcs: "gcs";
-                "azure-blob": "azure-blob";
-            }>>>;
-            compute: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                vm: "vm";
-                containers: "containers";
-                serverless: "serverless";
-            }>>>;
+            databases: z.ZodDefault<z.ZodArray<z.ZodEnum<["postgres", "mysql", "mongodb", "redis"]>, "many">>;
+            storage: z.ZodDefault<z.ZodArray<z.ZodEnum<["s3", "azure-blob", "gcs"]>, "many">>;
+            compute: z.ZodDefault<z.ZodArray<z.ZodEnum<["containers", "serverless", "vm"]>, "many">>;
             cdn: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            hipaa: "hipaa";
-            gdpr: "gdpr";
-            soc2: "soc2";
-            iso27001: "iso27001";
-            "pci-dss": "pci-dss";
-        }>>>;
-        status: z.ZodDefault<z.ZodEnum<{
-            deprecated: "deprecated";
-            active: "active";
-            maintenance: "maintenance";
-            "read-only": "read-only";
+        }, "strip", z.ZodTypeAny, {
+            cdn: boolean;
+            storage: ("s3" | "gcs" | "azure-blob")[];
+            databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+            compute: ("vm" | "containers" | "serverless")[];
+        }, {
+            cdn?: boolean | undefined;
+            storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+            databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+            compute?: ("vm" | "containers" | "serverless")[] | undefined;
         }>>;
+        /**
+         * Compliance and certifications
+         */
+        compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<["gdpr", "hipaa", "soc2", "iso27001", "pci-dss"]>, "many">>;
+        /**
+         * Region status
+         */
+        status: z.ZodDefault<z.ZodEnum<["active", "read-only", "maintenance", "deprecated"]>>;
+        /**
+         * Resource limits for this region
+         */
         limits: z.ZodOptional<z.ZodObject<{
             maxSpaces: z.ZodOptional<z.ZodNumber>;
             maxTenants: z.ZodOptional<z.ZodNumber>;
             maxStorage: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        }, {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "deprecated" | "maintenance" | "read-only";
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        name: string;
+        id: string;
+        compliance: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[];
+        provider?: {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        } | undefined;
+        capabilities?: {
+            cdn: boolean;
+            storage: ("s3" | "gcs" | "azure-blob")[];
+            databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+            compute: ("vm" | "containers" | "serverless")[];
+        } | undefined;
+        limits?: {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        } | undefined;
+    }, {
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        name: string;
+        id: string;
+        status?: "active" | "deprecated" | "maintenance" | "read-only" | undefined;
+        provider?: {
+            name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+            region: string;
+        } | undefined;
+        capabilities?: {
+            cdn?: boolean | undefined;
+            storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+            databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+            compute?: ("vm" | "containers" | "serverless")[] | undefined;
+        } | undefined;
+        compliance?: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[] | undefined;
+        limits?: {
+            maxStorage?: number | undefined;
+            maxSpaces?: number | undefined;
+            maxTenants?: number | undefined;
+        } | undefined;
+    }>;
     readonly HubInstance: z.ZodObject<{
+        /**
+         * Instance identifier
+         */
         id: z.ZodString;
+        /**
+         * Region where this hub is deployed
+         */
         regionId: z.ZodString;
-        role: z.ZodEnum<{
-            primary: "primary";
-            secondary: "secondary";
-            edge: "edge";
-        }>;
+        /**
+         * Hub role in federation
+         */
+        role: z.ZodEnum<["primary", "secondary", "edge"]>;
+        /**
+         * Endpoint URLs
+         */
         endpoints: z.ZodObject<{
             api: z.ZodString;
             admin: z.ZodOptional<z.ZodString>;
             grpc: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        }, {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        }>;
+        /**
+         * Replication configuration
+         */
         replication: z.ZodOptional<z.ZodObject<{
+            /**
+             * Source hub for replication (if this is a secondary)
+             */
             primaryHubId: z.ZodOptional<z.ZodString>;
+            /**
+             * Replication lag tolerance in seconds
+             */
             lagTolerance: z.ZodDefault<z.ZodNumber>;
-            mode: z.ZodDefault<z.ZodEnum<{
-                async: "async";
-                sync: "sync";
-                "semi-sync": "semi-sync";
-            }>>;
-        }, z.core.$strip>>;
+            /**
+             * Replication mode
+             */
+            mode: z.ZodDefault<z.ZodEnum<["sync", "async", "semi-sync"]>>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "async" | "sync" | "semi-sync";
+            lagTolerance: number;
+            primaryHubId?: string | undefined;
+        }, {
+            mode?: "async" | "sync" | "semi-sync" | undefined;
+            primaryHubId?: string | undefined;
+            lagTolerance?: number | undefined;
+        }>>;
+        /**
+         * Health status
+         */
         health: z.ZodOptional<z.ZodObject<{
-            status: z.ZodEnum<{
-                healthy: "healthy";
-                degraded: "degraded";
-                unhealthy: "unhealthy";
-            }>;
+            status: z.ZodEnum<["healthy", "degraded", "unhealthy"]>;
             lastCheck: z.ZodString;
             uptime: z.ZodNumber;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        }, {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        }>>;
+        /**
+         * Version
+         */
         version: z.ZodString;
+        /**
+         * Metadata
+         */
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        id: string;
+        createdAt: string;
+        role: "primary" | "secondary" | "edge";
+        updatedAt: string;
+        endpoints: {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        };
+        regionId: string;
+        replication?: {
+            mode: "async" | "sync" | "semi-sync";
+            lagTolerance: number;
+            primaryHubId?: string | undefined;
+        } | undefined;
+        health?: {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        } | undefined;
+    }, {
+        version: string;
+        id: string;
+        createdAt: string;
+        role: "primary" | "secondary" | "edge";
+        updatedAt: string;
+        endpoints: {
+            api: string;
+            admin?: string | undefined;
+            grpc?: string | undefined;
+        };
+        regionId: string;
+        replication?: {
+            mode?: "async" | "sync" | "semi-sync" | undefined;
+            primaryHubId?: string | undefined;
+            lagTolerance?: number | undefined;
+        } | undefined;
+        health?: {
+            status: "degraded" | "healthy" | "unhealthy";
+            uptime: number;
+            lastCheck: string;
+        } | undefined;
+    }>;
     readonly FederationTopology: z.ZodObject<{
+        /**
+         * Federation identifier
+         */
         id: z.ZodString;
+        /**
+         * Federation name
+         */
         name: z.ZodString;
+        /**
+         * Regions in this federation
+         */
         regions: z.ZodArray<z.ZodObject<{
+            /**
+             * Region identifier (e.g., us-east-1, eu-west-1, ap-southeast-1)
+             */
             id: z.ZodString;
+            /**
+             * Display name
+             */
             name: z.ZodString;
+            /**
+             * Geographic location
+             */
             location: z.ZodObject<{
-                continent: z.ZodEnum<{
-                    NA: "NA";
-                    SA: "SA";
-                    EU: "EU";
-                    AF: "AF";
-                    AS: "AS";
-                    OC: "OC";
-                    AN: "AN";
-                }>;
+                continent: z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>;
                 country: z.ZodString;
                 city: z.ZodOptional<z.ZodString>;
                 latitude: z.ZodOptional<z.ZodNumber>;
                 longitude: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                country: string;
+                continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+                latitude?: number | undefined;
+                longitude?: number | undefined;
+                city?: string | undefined;
+            }, {
+                country: string;
+                continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+                latitude?: number | undefined;
+                longitude?: number | undefined;
+                city?: string | undefined;
+            }>;
+            /**
+             * Cloud provider and region mapping
+             */
             provider: z.ZodOptional<z.ZodObject<{
-                name: z.ZodEnum<{
-                    vercel: "vercel";
-                    aws: "aws";
-                    azure: "azure";
-                    gcp: "gcp";
-                    cloudflare: "cloudflare";
-                    "self-hosted": "self-hosted";
-                }>;
+                name: z.ZodEnum<["aws", "azure", "gcp", "cloudflare", "vercel", "self-hosted"]>;
                 region: z.ZodString;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+                region: string;
+            }, {
+                name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+                region: string;
+            }>>;
+            /**
+             * Region capabilities
+             */
             capabilities: z.ZodOptional<z.ZodObject<{
-                databases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                    mysql: "mysql";
-                    mongodb: "mongodb";
-                    redis: "redis";
-                    postgres: "postgres";
-                }>>>;
-                storage: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                    s3: "s3";
-                    gcs: "gcs";
-                    "azure-blob": "azure-blob";
-                }>>>;
-                compute: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                    vm: "vm";
-                    containers: "containers";
-                    serverless: "serverless";
-                }>>>;
+                databases: z.ZodDefault<z.ZodArray<z.ZodEnum<["postgres", "mysql", "mongodb", "redis"]>, "many">>;
+                storage: z.ZodDefault<z.ZodArray<z.ZodEnum<["s3", "azure-blob", "gcs"]>, "many">>;
+                compute: z.ZodDefault<z.ZodArray<z.ZodEnum<["containers", "serverless", "vm"]>, "many">>;
                 cdn: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strip>>;
-            compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                hipaa: "hipaa";
-                gdpr: "gdpr";
-                soc2: "soc2";
-                iso27001: "iso27001";
-                "pci-dss": "pci-dss";
-            }>>>;
-            status: z.ZodDefault<z.ZodEnum<{
-                deprecated: "deprecated";
-                active: "active";
-                maintenance: "maintenance";
-                "read-only": "read-only";
+            }, "strip", z.ZodTypeAny, {
+                cdn: boolean;
+                storage: ("s3" | "gcs" | "azure-blob")[];
+                databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+                compute: ("vm" | "containers" | "serverless")[];
+            }, {
+                cdn?: boolean | undefined;
+                storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+                databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+                compute?: ("vm" | "containers" | "serverless")[] | undefined;
             }>>;
+            /**
+             * Compliance and certifications
+             */
+            compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<["gdpr", "hipaa", "soc2", "iso27001", "pci-dss"]>, "many">>;
+            /**
+             * Region status
+             */
+            status: z.ZodDefault<z.ZodEnum<["active", "read-only", "maintenance", "deprecated"]>>;
+            /**
+             * Resource limits for this region
+             */
             limits: z.ZodOptional<z.ZodObject<{
                 maxSpaces: z.ZodOptional<z.ZodNumber>;
                 maxTenants: z.ZodOptional<z.ZodNumber>;
                 maxStorage: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                maxStorage?: number | undefined;
+                maxSpaces?: number | undefined;
+                maxTenants?: number | undefined;
+            }, {
+                maxStorage?: number | undefined;
+                maxSpaces?: number | undefined;
+                maxTenants?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "active" | "deprecated" | "maintenance" | "read-only";
+            location: {
+                country: string;
+                continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+                latitude?: number | undefined;
+                longitude?: number | undefined;
+                city?: string | undefined;
+            };
+            name: string;
+            id: string;
+            compliance: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[];
+            provider?: {
+                name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+                region: string;
+            } | undefined;
+            capabilities?: {
+                cdn: boolean;
+                storage: ("s3" | "gcs" | "azure-blob")[];
+                databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+                compute: ("vm" | "containers" | "serverless")[];
+            } | undefined;
+            limits?: {
+                maxStorage?: number | undefined;
+                maxSpaces?: number | undefined;
+                maxTenants?: number | undefined;
+            } | undefined;
+        }, {
+            location: {
+                country: string;
+                continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+                latitude?: number | undefined;
+                longitude?: number | undefined;
+                city?: string | undefined;
+            };
+            name: string;
+            id: string;
+            status?: "active" | "deprecated" | "maintenance" | "read-only" | undefined;
+            provider?: {
+                name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+                region: string;
+            } | undefined;
+            capabilities?: {
+                cdn?: boolean | undefined;
+                storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+                databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+                compute?: ("vm" | "containers" | "serverless")[] | undefined;
+            } | undefined;
+            compliance?: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[] | undefined;
+            limits?: {
+                maxStorage?: number | undefined;
+                maxSpaces?: number | undefined;
+                maxTenants?: number | undefined;
+            } | undefined;
+        }>, "many">;
+        /**
+         * Hub instances
+         */
         hubs: z.ZodArray<z.ZodObject<{
+            /**
+             * Instance identifier
+             */
             id: z.ZodString;
+            /**
+             * Region where this hub is deployed
+             */
             regionId: z.ZodString;
-            role: z.ZodEnum<{
-                primary: "primary";
-                secondary: "secondary";
-                edge: "edge";
-            }>;
+            /**
+             * Hub role in federation
+             */
+            role: z.ZodEnum<["primary", "secondary", "edge"]>;
+            /**
+             * Endpoint URLs
+             */
             endpoints: z.ZodObject<{
                 api: z.ZodString;
                 admin: z.ZodOptional<z.ZodString>;
                 grpc: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                api: string;
+                admin?: string | undefined;
+                grpc?: string | undefined;
+            }, {
+                api: string;
+                admin?: string | undefined;
+                grpc?: string | undefined;
+            }>;
+            /**
+             * Replication configuration
+             */
             replication: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Source hub for replication (if this is a secondary)
+                 */
                 primaryHubId: z.ZodOptional<z.ZodString>;
+                /**
+                 * Replication lag tolerance in seconds
+                 */
                 lagTolerance: z.ZodDefault<z.ZodNumber>;
-                mode: z.ZodDefault<z.ZodEnum<{
-                    async: "async";
-                    sync: "sync";
-                    "semi-sync": "semi-sync";
-                }>>;
-            }, z.core.$strip>>;
+                /**
+                 * Replication mode
+                 */
+                mode: z.ZodDefault<z.ZodEnum<["sync", "async", "semi-sync"]>>;
+            }, "strip", z.ZodTypeAny, {
+                mode: "async" | "sync" | "semi-sync";
+                lagTolerance: number;
+                primaryHubId?: string | undefined;
+            }, {
+                mode?: "async" | "sync" | "semi-sync" | undefined;
+                primaryHubId?: string | undefined;
+                lagTolerance?: number | undefined;
+            }>>;
+            /**
+             * Health status
+             */
             health: z.ZodOptional<z.ZodObject<{
-                status: z.ZodEnum<{
-                    healthy: "healthy";
-                    degraded: "degraded";
-                    unhealthy: "unhealthy";
-                }>;
+                status: z.ZodEnum<["healthy", "degraded", "unhealthy"]>;
                 lastCheck: z.ZodString;
                 uptime: z.ZodNumber;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                status: "degraded" | "healthy" | "unhealthy";
+                uptime: number;
+                lastCheck: string;
+            }, {
+                status: "degraded" | "healthy" | "unhealthy";
+                uptime: number;
+                lastCheck: string;
+            }>>;
+            /**
+             * Version
+             */
             version: z.ZodString;
+            /**
+             * Metadata
+             */
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            id: string;
+            createdAt: string;
+            role: "primary" | "secondary" | "edge";
+            updatedAt: string;
+            endpoints: {
+                api: string;
+                admin?: string | undefined;
+                grpc?: string | undefined;
+            };
+            regionId: string;
+            replication?: {
+                mode: "async" | "sync" | "semi-sync";
+                lagTolerance: number;
+                primaryHubId?: string | undefined;
+            } | undefined;
+            health?: {
+                status: "degraded" | "healthy" | "unhealthy";
+                uptime: number;
+                lastCheck: string;
+            } | undefined;
+        }, {
+            version: string;
+            id: string;
+            createdAt: string;
+            role: "primary" | "secondary" | "edge";
+            updatedAt: string;
+            endpoints: {
+                api: string;
+                admin?: string | undefined;
+                grpc?: string | undefined;
+            };
+            regionId: string;
+            replication?: {
+                mode?: "async" | "sync" | "semi-sync" | undefined;
+                primaryHubId?: string | undefined;
+                lagTolerance?: number | undefined;
+            } | undefined;
+            health?: {
+                status: "degraded" | "healthy" | "unhealthy";
+                uptime: number;
+                lastCheck: string;
+            } | undefined;
+        }>, "many">;
+        /**
+         * Routing strategy
+         */
         routing: z.ZodObject<{
-            strategy: z.ZodDefault<z.ZodEnum<{
-                custom: "custom";
-                "geo-proximity": "geo-proximity";
-                "data-residency": "data-residency";
-                "least-loaded": "least-loaded";
-            }>>;
+            /**
+             * How to route tenant requests
+             */
+            strategy: z.ZodDefault<z.ZodEnum<["geo-proximity", "data-residency", "least-loaded", "custom"]>>;
+            /**
+             * Failover behavior
+             */
             failover: z.ZodObject<{
                 enabled: z.ZodDefault<z.ZodBoolean>;
                 maxRetries: z.ZodDefault<z.ZodNumber>;
                 timeout: z.ZodDefault<z.ZodNumber>;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                timeout: number;
+                maxRetries: number;
+            }, {
+                enabled?: boolean | undefined;
+                timeout?: number | undefined;
+                maxRetries?: number | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "custom" | "geo-proximity" | "data-residency" | "least-loaded";
+            failover: {
+                enabled: boolean;
+                timeout: number;
+                maxRetries: number;
+            };
+        }, {
+            failover: {
+                enabled?: boolean | undefined;
+                timeout?: number | undefined;
+                maxRetries?: number | undefined;
+            };
+            strategy?: "custom" | "geo-proximity" | "data-residency" | "least-loaded" | undefined;
+        }>;
+        /**
+         * Data synchronization settings
+         */
         synchronization: z.ZodObject<{
+            /**
+             * What data to sync across regions
+             */
             scope: z.ZodObject<{
+                /**
+                 * Sync plugin registry
+                 */
                 plugins: z.ZodDefault<z.ZodBoolean>;
+                /**
+                 * Sync tenant metadata (not data)
+                 */
                 tenants: z.ZodDefault<z.ZodBoolean>;
+                /**
+                 * Sync spaces metadata
+                 */
                 spaces: z.ZodDefault<z.ZodBoolean>;
+                /**
+                 * Sync licenses
+                 */
                 licenses: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strip>;
-            frequency: z.ZodDefault<z.ZodEnum<{
-                realtime: "realtime";
-                hourly: "hourly";
-                daily: "daily";
-            }>>;
-            conflictResolution: z.ZodDefault<z.ZodEnum<{
-                manual: "manual";
-                "last-write-wins": "last-write-wins";
-                "primary-wins": "primary-wins";
-            }>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                spaces: boolean;
+                plugins: boolean;
+                tenants: boolean;
+                licenses: boolean;
+            }, {
+                spaces?: boolean | undefined;
+                plugins?: boolean | undefined;
+                tenants?: boolean | undefined;
+                licenses?: boolean | undefined;
+            }>;
+            /**
+             * Sync frequency
+             */
+            frequency: z.ZodDefault<z.ZodEnum<["realtime", "hourly", "daily"]>>;
+            /**
+             * Conflict resolution
+             */
+            conflictResolution: z.ZodDefault<z.ZodEnum<["last-write-wins", "primary-wins", "manual"]>>;
+        }, "strip", z.ZodTypeAny, {
+            scope: {
+                spaces: boolean;
+                plugins: boolean;
+                tenants: boolean;
+                licenses: boolean;
+            };
+            conflictResolution: "manual" | "last-write-wins" | "primary-wins";
+            frequency: "hourly" | "daily" | "realtime";
+        }, {
+            scope: {
+                spaces?: boolean | undefined;
+                plugins?: boolean | undefined;
+                tenants?: boolean | undefined;
+                licenses?: boolean | undefined;
+            };
+            conflictResolution?: "manual" | "last-write-wins" | "primary-wins" | undefined;
+            frequency?: "hourly" | "daily" | "realtime" | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        regions: {
+            status: "active" | "deprecated" | "maintenance" | "read-only";
+            location: {
+                country: string;
+                continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+                latitude?: number | undefined;
+                longitude?: number | undefined;
+                city?: string | undefined;
+            };
+            name: string;
+            id: string;
+            compliance: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[];
+            provider?: {
+                name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+                region: string;
+            } | undefined;
+            capabilities?: {
+                cdn: boolean;
+                storage: ("s3" | "gcs" | "azure-blob")[];
+                databases: ("mysql" | "mongodb" | "redis" | "postgres")[];
+                compute: ("vm" | "containers" | "serverless")[];
+            } | undefined;
+            limits?: {
+                maxStorage?: number | undefined;
+                maxSpaces?: number | undefined;
+                maxTenants?: number | undefined;
+            } | undefined;
+        }[];
+        routing: {
+            strategy: "custom" | "geo-proximity" | "data-residency" | "least-loaded";
+            failover: {
+                enabled: boolean;
+                timeout: number;
+                maxRetries: number;
+            };
+        };
+        hubs: {
+            version: string;
+            id: string;
+            createdAt: string;
+            role: "primary" | "secondary" | "edge";
+            updatedAt: string;
+            endpoints: {
+                api: string;
+                admin?: string | undefined;
+                grpc?: string | undefined;
+            };
+            regionId: string;
+            replication?: {
+                mode: "async" | "sync" | "semi-sync";
+                lagTolerance: number;
+                primaryHubId?: string | undefined;
+            } | undefined;
+            health?: {
+                status: "degraded" | "healthy" | "unhealthy";
+                uptime: number;
+                lastCheck: string;
+            } | undefined;
+        }[];
+        synchronization: {
+            scope: {
+                spaces: boolean;
+                plugins: boolean;
+                tenants: boolean;
+                licenses: boolean;
+            };
+            conflictResolution: "manual" | "last-write-wins" | "primary-wins";
+            frequency: "hourly" | "daily" | "realtime";
+        };
+    }, {
+        name: string;
+        id: string;
+        regions: {
+            location: {
+                country: string;
+                continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+                latitude?: number | undefined;
+                longitude?: number | undefined;
+                city?: string | undefined;
+            };
+            name: string;
+            id: string;
+            status?: "active" | "deprecated" | "maintenance" | "read-only" | undefined;
+            provider?: {
+                name: "vercel" | "aws" | "azure" | "gcp" | "cloudflare" | "self-hosted";
+                region: string;
+            } | undefined;
+            capabilities?: {
+                cdn?: boolean | undefined;
+                storage?: ("s3" | "gcs" | "azure-blob")[] | undefined;
+                databases?: ("mysql" | "mongodb" | "redis" | "postgres")[] | undefined;
+                compute?: ("vm" | "containers" | "serverless")[] | undefined;
+            } | undefined;
+            compliance?: ("hipaa" | "gdpr" | "soc2" | "iso27001" | "pci-dss")[] | undefined;
+            limits?: {
+                maxStorage?: number | undefined;
+                maxSpaces?: number | undefined;
+                maxTenants?: number | undefined;
+            } | undefined;
+        }[];
+        routing: {
+            failover: {
+                enabled?: boolean | undefined;
+                timeout?: number | undefined;
+                maxRetries?: number | undefined;
+            };
+            strategy?: "custom" | "geo-proximity" | "data-residency" | "least-loaded" | undefined;
+        };
+        hubs: {
+            version: string;
+            id: string;
+            createdAt: string;
+            role: "primary" | "secondary" | "edge";
+            updatedAt: string;
+            endpoints: {
+                api: string;
+                admin?: string | undefined;
+                grpc?: string | undefined;
+            };
+            regionId: string;
+            replication?: {
+                mode?: "async" | "sync" | "semi-sync" | undefined;
+                primaryHubId?: string | undefined;
+                lagTolerance?: number | undefined;
+            } | undefined;
+            health?: {
+                status: "degraded" | "healthy" | "unhealthy";
+                uptime: number;
+                lastCheck: string;
+            } | undefined;
+        }[];
+        synchronization: {
+            scope: {
+                spaces?: boolean | undefined;
+                plugins?: boolean | undefined;
+                tenants?: boolean | undefined;
+                licenses?: boolean | undefined;
+            };
+            conflictResolution?: "manual" | "last-write-wins" | "primary-wins" | undefined;
+            frequency?: "hourly" | "daily" | "realtime" | undefined;
+        };
+    }>;
     readonly TenantPlacementPolicy: z.ZodObject<{
+        /**
+         * Tenant identifier
+         */
         tenantId: z.ZodString;
+        /**
+         * Primary region (where tenant data lives)
+         */
         primaryRegion: z.ZodString;
-        replicaRegions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        /**
+         * Replica regions (for disaster recovery)
+         */
+        replicaRegions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Data residency constraints
+         */
         dataResidency: z.ZodOptional<z.ZodObject<{
-            allowedRegions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            prohibitedRegions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            continent: z.ZodOptional<z.ZodEnum<{
-                NA: "NA";
-                SA: "SA";
-                EU: "EU";
-                AF: "AF";
-                AS: "AS";
-                OC: "OC";
-                AN: "AN";
-            }>>;
-        }, z.core.$strip>>;
+            /**
+             * Allowed regions for data storage
+             */
+            allowedRegions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Prohibited regions
+             */
+            prohibitedRegions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Continent restriction
+             */
+            continent: z.ZodOptional<z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>>;
+        }, "strip", z.ZodTypeAny, {
+            prohibitedRegions: string[];
+            continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+            allowedRegions?: string[] | undefined;
+        }, {
+            continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+            allowedRegions?: string[] | undefined;
+            prohibitedRegions?: string[] | undefined;
+        }>>;
+        /**
+         * Failover policy
+         */
         failover: z.ZodOptional<z.ZodObject<{
+            /**
+             * Enable automatic failover
+             */
             enabled: z.ZodDefault<z.ZodBoolean>;
-            preferredOrder: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            /**
+             * Preferred failover order (region IDs)
+             */
+            preferredOrder: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Maximum acceptable latency for failover target (ms)
+             */
             maxLatency: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            preferredOrder: string[];
+            maxLatency: number;
+        }, {
+            enabled?: boolean | undefined;
+            preferredOrder?: string[] | undefined;
+            maxLatency?: number | undefined;
+        }>>;
+        /**
+         * Latency requirements
+         */
         latency: z.ZodOptional<z.ZodObject<{
+            /**
+             * Maximum acceptable latency for primary region (ms)
+             */
             maxPrimaryLatency: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Maximum acceptable latency for replicas (ms)
+             */
             maxReplicaLatency: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            maxPrimaryLatency: number;
+            maxReplicaLatency: number;
+        }, {
+            maxPrimaryLatency?: number | undefined;
+            maxReplicaLatency?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        tenantId: string;
+        primaryRegion: string;
+        replicaRegions: string[];
+        latency?: {
+            maxPrimaryLatency: number;
+            maxReplicaLatency: number;
+        } | undefined;
+        dataResidency?: {
+            prohibitedRegions: string[];
+            continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+            allowedRegions?: string[] | undefined;
+        } | undefined;
+        failover?: {
+            enabled: boolean;
+            preferredOrder: string[];
+            maxLatency: number;
+        } | undefined;
+    }, {
+        tenantId: string;
+        primaryRegion: string;
+        latency?: {
+            maxPrimaryLatency?: number | undefined;
+            maxReplicaLatency?: number | undefined;
+        } | undefined;
+        dataResidency?: {
+            continent?: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN" | undefined;
+            allowedRegions?: string[] | undefined;
+            prohibitedRegions?: string[] | undefined;
+        } | undefined;
+        failover?: {
+            enabled?: boolean | undefined;
+            preferredOrder?: string[] | undefined;
+            maxLatency?: number | undefined;
+        } | undefined;
+        replicaRegions?: string[] | undefined;
+    }>;
     readonly ReplicationJob: z.ZodObject<{
+        /**
+         * Job identifier
+         */
         id: z.ZodString;
-        type: z.ZodEnum<{
-            "initial-sync": "initial-sync";
-            incremental: "incremental";
-            "conflict-resolution": "conflict-resolution";
-        }>;
+        /**
+         * Job type
+         */
+        type: z.ZodEnum<["initial-sync", "incremental", "conflict-resolution"]>;
+        /**
+         * Source hub
+         */
         sourceHubId: z.ZodString;
-        targetHubIds: z.ZodArray<z.ZodString>;
+        /**
+         * Target hub(s)
+         */
+        targetHubIds: z.ZodArray<z.ZodString, "many">;
+        /**
+         * Resource scope
+         */
         scope: z.ZodObject<{
-            resourceType: z.ZodEnum<{
-                all: "all";
-                license: "license";
-                plugin: "plugin";
-                tenant: "tenant";
-                space: "space";
-            }>;
-            resourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>;
-        status: z.ZodEnum<{
-            pending: "pending";
-            completed: "completed";
-            failed: "failed";
-            running: "running";
-            cancelled: "cancelled";
+            /**
+             * Resource type
+             */
+            resourceType: z.ZodEnum<["plugin", "tenant", "space", "license", "all"]>;
+            /**
+             * Specific resource IDs (empty = all)
+             */
+            resourceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            resourceIds: string[];
+            resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+        }, {
+            resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+            resourceIds?: string[] | undefined;
         }>;
+        /**
+         * Job status
+         */
+        status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+        /**
+         * Progress
+         */
         progress: z.ZodOptional<z.ZodObject<{
             total: z.ZodNumber;
             completed: z.ZodNumber;
             failed: z.ZodNumber;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            total: number;
+            completed: number;
+            failed: number;
+        }, {
+            total: number;
+            completed: number;
+            failed: number;
+        }>>;
+        /**
+         * Timestamps
+         */
         createdAt: z.ZodString;
         startedAt: z.ZodOptional<z.ZodString>;
         completedAt: z.ZodOptional<z.ZodString>;
+        /**
+         * Errors
+         */
         errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
             timestamp: z.ZodString;
             resourceId: z.ZodString;
             error: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            error: string;
+            timestamp: string;
+            resourceId: string;
+        }, {
+            error: string;
+            timestamp: string;
+            resourceId: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "initial-sync" | "incremental" | "conflict-resolution";
+        status: "running" | "completed" | "failed" | "cancelled" | "pending";
+        scope: {
+            resourceIds: string[];
+            resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+        };
+        id: string;
+        createdAt: string;
+        errors: {
+            error: string;
+            timestamp: string;
+            resourceId: string;
+        }[];
+        sourceHubId: string;
+        targetHubIds: string[];
+        progress?: {
+            total: number;
+            completed: number;
+            failed: number;
+        } | undefined;
+        startedAt?: string | undefined;
+        completedAt?: string | undefined;
+    }, {
+        type: "initial-sync" | "incremental" | "conflict-resolution";
+        status: "running" | "completed" | "failed" | "cancelled" | "pending";
+        scope: {
+            resourceType: "all" | "license" | "tenant" | "plugin" | "space";
+            resourceIds?: string[] | undefined;
+        };
+        id: string;
+        createdAt: string;
+        sourceHubId: string;
+        targetHubIds: string[];
+        progress?: {
+            total: number;
+            completed: number;
+            failed: number;
+        } | undefined;
+        errors?: {
+            error: string;
+            timestamp: string;
+            resourceId: string;
+        }[] | undefined;
+        startedAt?: string | undefined;
+        completedAt?: string | undefined;
+    }>;
     readonly GlobalRegistryEntry: z.ZodObject<{
+        /**
+         * Resource identifier
+         */
         resourceId: z.ZodString;
-        resourceType: z.ZodEnum<{
-            license: "license";
-            plugin: "plugin";
-            tenant: "tenant";
-            space: "space";
-        }>;
+        /**
+         * Resource type
+         */
+        resourceType: z.ZodEnum<["plugin", "tenant", "space", "license"]>;
+        /**
+         * Regions where this resource exists
+         */
         locations: z.ZodArray<z.ZodObject<{
             regionId: z.ZodString;
             hubId: z.ZodString;
             isPrimary: z.ZodDefault<z.ZodBoolean>;
             lastSyncedAt: z.ZodOptional<z.ZodString>;
             version: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            regionId: string;
+            hubId: string;
+            isPrimary: boolean;
+            version?: string | undefined;
+            lastSyncedAt?: string | undefined;
+        }, {
+            regionId: string;
+            hubId: string;
+            version?: string | undefined;
+            isPrimary?: boolean | undefined;
+            lastSyncedAt?: string | undefined;
+        }>, "many">;
+        /**
+         * Global version vector clock (for conflict detection)
+         */
         versionVector: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        locations: {
+            regionId: string;
+            hubId: string;
+            isPrimary: boolean;
+            version?: string | undefined;
+            lastSyncedAt?: string | undefined;
+        }[];
+        resourceType: "license" | "tenant" | "plugin" | "space";
+        resourceId: string;
+        versionVector?: Record<string, number> | undefined;
+    }, {
+        locations: {
+            regionId: string;
+            hubId: string;
+            version?: string | undefined;
+            isPrimary?: boolean | undefined;
+            lastSyncedAt?: string | undefined;
+        }[];
+        resourceType: "license" | "tenant" | "plugin" | "space";
+        resourceId: string;
+        versionVector?: Record<string, number> | undefined;
+    }>;
     readonly EdgeLocation: z.ZodObject<{
+        /**
+         * Location identifier
+         */
         id: z.ZodString;
+        /**
+         * Parent region
+         */
         regionId: z.ZodString;
+        /**
+         * Location details
+         */
         location: z.ZodObject<{
-            continent: z.ZodEnum<{
-                NA: "NA";
-                SA: "SA";
-                EU: "EU";
-                AF: "AF";
-                AS: "AS";
-                OC: "OC";
-                AN: "AN";
-            }>;
+            continent: z.ZodEnum<["NA", "SA", "EU", "AF", "AS", "OC", "AN"]>;
             country: z.ZodString;
             city: z.ZodOptional<z.ZodString>;
             latitude: z.ZodOptional<z.ZodNumber>;
             longitude: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        }, {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        }>;
+        /**
+         * Caching configuration
+         */
         cache: z.ZodObject<{
-            resources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                plugins: "plugins";
-                "static-assets": "static-assets";
-                "api-responses": "api-responses";
-            }>>>;
+            /**
+             * What to cache at edge
+             */
+            resources: z.ZodDefault<z.ZodArray<z.ZodEnum<["plugins", "static-assets", "api-responses"]>, "many">>;
+            /**
+             * TTL in seconds
+             */
             ttl: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Cache size limit (bytes)
+             */
             maxSize: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
-        status: z.ZodDefault<z.ZodEnum<{
-            active: "active";
-            inactive: "inactive";
-        }>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            ttl: number;
+            resources: ("plugins" | "static-assets" | "api-responses")[];
+            maxSize?: number | undefined;
+        }, {
+            maxSize?: number | undefined;
+            ttl?: number | undefined;
+            resources?: ("plugins" | "static-assets" | "api-responses")[] | undefined;
+        }>;
+        /**
+         * Status
+         */
+        status: z.ZodDefault<z.ZodEnum<["active", "inactive"]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "inactive";
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        id: string;
+        cache: {
+            ttl: number;
+            resources: ("plugins" | "static-assets" | "api-responses")[];
+            maxSize?: number | undefined;
+        };
+        regionId: string;
+    }, {
+        location: {
+            country: string;
+            continent: "NA" | "SA" | "EU" | "AF" | "AS" | "OC" | "AN";
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            city?: string | undefined;
+        };
+        id: string;
+        cache: {
+            maxSize?: number | undefined;
+            ttl?: number | undefined;
+            resources?: ("plugins" | "static-assets" | "api-responses")[] | undefined;
+        };
+        regionId: string;
+        status?: "active" | "inactive" | undefined;
+    }>;
 };
 //# sourceMappingURL=hub-federation.zod.d.ts.map