@objectstack/spec 0.7.1 → 0.8.0

package/dist/hub/tenant.zod.d.ts

@@ -15,34 +15,21 @@ import { z } from 'zod';
  * Tenant Isolation Level Enum
  * Defines how tenant data is separated in the system
  */
-export declare const TenantIsolationLevel: z.ZodEnum<["shared_schema", "isolated_schema", "isolated_db"]>;
+export declare const TenantIsolationLevel: z.ZodEnum<{
+    shared_schema: "shared_schema";
+    isolated_schema: "isolated_schema";
+    isolated_db: "isolated_db";
+}>;
 export type TenantIsolationLevel = z.infer<typeof TenantIsolationLevel>;
 /**
  * Tenant Quota Schema
  * Defines resource limits and usage quotas for a tenant
  */
 export declare const TenantQuotaSchema: z.ZodObject<{
-    /**
-     * Maximum number of users allowed for this tenant
-     */
     maxUsers: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Maximum storage space in bytes
-     */
     maxStorage: z.ZodOptional<z.ZodNumber>;
-    /**
-     * API rate limit (requests per minute)
-     */
     apiRateLimit: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    maxUsers?: number | undefined;
-    maxStorage?: number | undefined;
-    apiRateLimit?: number | undefined;
-}, {
-    maxUsers?: number | undefined;
-    maxStorage?: number | undefined;
-    apiRateLimit?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type TenantQuota = z.infer<typeof TenantQuotaSchema>;
 /**
  * Tenant Schema
@@ -77,68 +64,20 @@ export type TenantQuota = z.infer<typeof TenantQuotaSchema>;
  * See HubSpaceSchema in space.zod.ts for the recommended approach.
  */
 export declare const TenantSchema: z.ZodObject<{
-    /**
-     * Unique tenant identifier
-     */
     id: z.ZodString;
-    /**
-     * Tenant display name
-     */
     name: z.ZodString;
-    /**
-     * Data isolation level
-     */
-    isolationLevel: z.ZodEnum<["shared_schema", "isolated_schema", "isolated_db"]>;
-    /**
-     * Custom configuration values
-     */
+    isolationLevel: z.ZodEnum<{
+        shared_schema: "shared_schema";
+        isolated_schema: "isolated_schema";
+        isolated_db: "isolated_db";
+    }>;
     customizations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    /**
-     * Resource quotas
-     */
     quotas: z.ZodOptional<z.ZodObject<{
-        /**
-         * Maximum number of users allowed for this tenant
-         */
         maxUsers: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Maximum storage space in bytes
-         */
         maxStorage: z.ZodOptional<z.ZodNumber>;
-        /**
-         * API rate limit (requests per minute)
-         */
         apiRateLimit: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        maxUsers?: number | undefined;
-        maxStorage?: number | undefined;
-        apiRateLimit?: number | undefined;
-    }, {
-        maxUsers?: number | undefined;
-        maxStorage?: number | undefined;
-        apiRateLimit?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: string;
-    isolationLevel: "shared_schema" | "isolated_schema" | "isolated_db";
-    customizations?: Record<string, any> | undefined;
-    quotas?: {
-        maxUsers?: number | undefined;
-        maxStorage?: number | undefined;
-        apiRateLimit?: number | undefined;
-    } | undefined;
-}, {
-    name: string;
-    id: string;
-    isolationLevel: "shared_schema" | "isolated_schema" | "isolated_db";
-    customizations?: Record<string, any> | undefined;
-    quotas?: {
-        maxUsers?: number | undefined;
-        maxStorage?: number | undefined;
-        apiRateLimit?: number | undefined;
-    } | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type Tenant = z.infer<typeof TenantSchema>;
 /**
  * Tenant Isolation Strategy Documentation
@@ -190,89 +129,22 @@ export type Tenant = z.infer<typeof TenantSchema>;
  */
 export declare const RowLevelIsolationStrategySchema: z.ZodObject<{
     strategy: z.ZodLiteral<"shared_schema">;
-    /**
-     * Database configuration for row-level isolation
-     */
     database: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to enable Row-Level Security (RLS)
-         */
         enableRLS: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Tenant context setting method
-         */
-        contextMethod: z.ZodDefault<z.ZodEnum<["session_variable", "search_path", "application_name"]>>;
-        /**
-         * Session variable name for tenant context
-         */
+        contextMethod: z.ZodDefault<z.ZodEnum<{
+            session_variable: "session_variable";
+            search_path: "search_path";
+            application_name: "application_name";
+        }>>;
         contextVariable: z.ZodDefault<z.ZodString>;
-        /**
-         * Whether to validate tenant_id at application level
-         */
         applicationValidation: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enableRLS: boolean;
-        contextMethod: "session_variable" | "search_path" | "application_name";
-        contextVariable: string;
-        applicationValidation: boolean;
-    }, {
-        enableRLS?: boolean | undefined;
-        contextMethod?: "session_variable" | "search_path" | "application_name" | undefined;
-        contextVariable?: string | undefined;
-        applicationValidation?: boolean | undefined;
-    }>>;
-    /**
-     * Performance optimization settings
-     */
+    }, z.core.$strip>>;
     performance: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to use partial indexes for tenant_id
-         */
         usePartialIndexes: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Whether to use table partitioning
-         */
         usePartitioning: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Connection pool size per tenant
-         */
         poolSizePerTenant: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        usePartialIndexes: boolean;
-        usePartitioning: boolean;
-        poolSizePerTenant?: number | undefined;
-    }, {
-        usePartialIndexes?: boolean | undefined;
-        usePartitioning?: boolean | undefined;
-        poolSizePerTenant?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    strategy: "shared_schema";
-    database?: {
-        enableRLS: boolean;
-        contextMethod: "session_variable" | "search_path" | "application_name";
-        contextVariable: string;
-        applicationValidation: boolean;
-    } | undefined;
-    performance?: {
-        usePartialIndexes: boolean;
-        usePartitioning: boolean;
-        poolSizePerTenant?: number | undefined;
-    } | undefined;
-}, {
-    strategy: "shared_schema";
-    database?: {
-        enableRLS?: boolean | undefined;
-        contextMethod?: "session_variable" | "search_path" | "application_name" | undefined;
-        contextVariable?: string | undefined;
-        applicationValidation?: boolean | undefined;
-    } | undefined;
-    performance?: {
-        usePartialIndexes?: boolean | undefined;
-        usePartitioning?: boolean | undefined;
-        poolSizePerTenant?: number | undefined;
-    } | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type RowLevelIsolationStrategy = z.infer<typeof RowLevelIsolationStrategySchema>;
 /**
  * Schema-Level Isolation Strategy (isolated_schema)
@@ -321,118 +193,26 @@ export type RowLevelIsolationStrategy = z.infer<typeof RowLevelIsolationStrategy
  */
 export declare const SchemaLevelIsolationStrategySchema: z.ZodObject<{
     strategy: z.ZodLiteral<"isolated_schema">;
-    /**
-     * Schema configuration
-     */
     schema: z.ZodOptional<z.ZodObject<{
-        /**
-         * Schema naming pattern
-         * Use {tenant_id} as placeholder (must contain only alphanumeric and underscores)
-         * The tenant_id will be sanitized before substitution to prevent SQL injection
-         */
         namingPattern: z.ZodDefault<z.ZodString>;
-        /**
-         * Whether to include public schema in search_path
-         */
         includePublicSchema: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Default schema for shared resources
-         */
         sharedSchema: z.ZodDefault<z.ZodString>;
-        /**
-         * Whether to automatically create schema on tenant creation
-         */
         autoCreateSchema: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        namingPattern: string;
-        includePublicSchema: boolean;
-        sharedSchema: string;
-        autoCreateSchema: boolean;
-    }, {
-        namingPattern?: string | undefined;
-        includePublicSchema?: boolean | undefined;
-        sharedSchema?: string | undefined;
-        autoCreateSchema?: boolean | undefined;
-    }>>;
-    /**
-     * Migration configuration
-     */
+    }, z.core.$strip>>;
     migrations: z.ZodOptional<z.ZodObject<{
-        /**
-         * Migration strategy
-         */
-        strategy: z.ZodDefault<z.ZodEnum<["parallel", "sequential", "on_demand"]>>;
-        /**
-         * Maximum concurrent migrations
-         */
+        strategy: z.ZodDefault<z.ZodEnum<{
+            parallel: "parallel";
+            sequential: "sequential";
+            on_demand: "on_demand";
+        }>>;
         maxConcurrent: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Whether to rollback on first failure
-         */
         rollbackOnError: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        strategy: "parallel" | "sequential" | "on_demand";
-        maxConcurrent: number;
-        rollbackOnError: boolean;
-    }, {
-        strategy?: "parallel" | "sequential" | "on_demand" | undefined;
-        maxConcurrent?: number | undefined;
-        rollbackOnError?: boolean | undefined;
-    }>>;
-    /**
-     * Performance optimization settings
-     */
+    }, z.core.$strip>>;
     performance: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to use connection pooling per schema
-         */
         poolPerSchema: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Schema cache TTL in seconds
-         */
         schemaCacheTTL: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        poolPerSchema: boolean;
-        schemaCacheTTL: number;
-    }, {
-        poolPerSchema?: boolean | undefined;
-        schemaCacheTTL?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    strategy: "isolated_schema";
-    schema?: {
-        namingPattern: string;
-        includePublicSchema: boolean;
-        sharedSchema: string;
-        autoCreateSchema: boolean;
-    } | undefined;
-    migrations?: {
-        strategy: "parallel" | "sequential" | "on_demand";
-        maxConcurrent: number;
-        rollbackOnError: boolean;
-    } | undefined;
-    performance?: {
-        poolPerSchema: boolean;
-        schemaCacheTTL: number;
-    } | undefined;
-}, {
-    strategy: "isolated_schema";
-    schema?: {
-        namingPattern?: string | undefined;
-        includePublicSchema?: boolean | undefined;
-        sharedSchema?: string | undefined;
-        autoCreateSchema?: boolean | undefined;
-    } | undefined;
-    migrations?: {
-        strategy?: "parallel" | "sequential" | "on_demand" | undefined;
-        maxConcurrent?: number | undefined;
-        rollbackOnError?: boolean | undefined;
-    } | undefined;
-    performance?: {
-        poolPerSchema?: boolean | undefined;
-        schemaCacheTTL?: number | undefined;
-    } | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type SchemaLevelIsolationStrategy = z.infer<typeof SchemaLevelIsolationStrategySchema>;
 /**
  * Database-Level Isolation Strategy (isolated_db)
@@ -484,169 +264,43 @@ export type SchemaLevelIsolationStrategy = z.infer<typeof SchemaLevelIsolationSt
  */
 export declare const DatabaseLevelIsolationStrategySchema: z.ZodObject<{
     strategy: z.ZodLiteral<"isolated_db">;
-    /**
-     * Database configuration
-     */
     database: z.ZodOptional<z.ZodObject<{
-        /**
-         * Database naming pattern
-         * Use {tenant_id} as placeholder (must contain only alphanumeric and underscores)
-         * The tenant_id will be sanitized before substitution to prevent SQL injection
-         */
         namingPattern: z.ZodDefault<z.ZodString>;
-        /**
-         * Database server/cluster assignment strategy
-         */
-        serverStrategy: z.ZodDefault<z.ZodEnum<["shared", "sharded", "dedicated"]>>;
-        /**
-         * Whether to use separate credentials per tenant
-         */
+        serverStrategy: z.ZodDefault<z.ZodEnum<{
+            shared: "shared";
+            sharded: "sharded";
+            dedicated: "dedicated";
+        }>>;
         separateCredentials: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Whether to automatically create database on tenant creation
-         */
         autoCreateDatabase: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        namingPattern: string;
-        serverStrategy: "shared" | "sharded" | "dedicated";
-        separateCredentials: boolean;
-        autoCreateDatabase: boolean;
-    }, {
-        namingPattern?: string | undefined;
-        serverStrategy?: "shared" | "sharded" | "dedicated" | undefined;
-        separateCredentials?: boolean | undefined;
-        autoCreateDatabase?: boolean | undefined;
-    }>>;
-    /**
-     * Connection pooling configuration
-     */
+    }, z.core.$strip>>;
     connectionPool: z.ZodOptional<z.ZodObject<{
-        /**
-         * Pool size per tenant database
-         */
         poolSize: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Maximum number of tenant pools to keep active
-         */
         maxActivePools: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Idle pool timeout in seconds
-         */
         idleTimeout: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Whether to use connection pooler (PgBouncer, etc.)
-         */
         usePooler: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        idleTimeout: number;
-        poolSize: number;
-        maxActivePools: number;
-        usePooler: boolean;
-    }, {
-        idleTimeout?: number | undefined;
-        poolSize?: number | undefined;
-        maxActivePools?: number | undefined;
-        usePooler?: boolean | undefined;
-    }>>;
-    /**
-     * Backup and restore configuration
-     */
+    }, z.core.$strip>>;
     backup: z.ZodOptional<z.ZodObject<{
-        /**
-         * Backup strategy per tenant
-         */
-        strategy: z.ZodDefault<z.ZodEnum<["individual", "consolidated", "on_demand"]>>;
-        /**
-         * Backup frequency in hours
-         */
+        strategy: z.ZodDefault<z.ZodEnum<{
+            on_demand: "on_demand";
+            individual: "individual";
+            consolidated: "consolidated";
+        }>>;
         frequencyHours: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Retention period in days
-         */
         retentionDays: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        strategy: "on_demand" | "individual" | "consolidated";
-        retentionDays: number;
-        frequencyHours: number;
-    }, {
-        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
-        retentionDays?: number | undefined;
-        frequencyHours?: number | undefined;
-    }>>;
-    /**
-     * Encryption configuration
-     */
+    }, z.core.$strip>>;
     encryption: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to use per-tenant encryption keys
-         */
         perTenantKeys: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Encryption algorithm
-         */
         algorithm: z.ZodDefault<z.ZodString>;
-        /**
-         * Key management service
-         */
-        keyManagement: z.ZodOptional<z.ZodEnum<["aws_kms", "azure_key_vault", "gcp_kms", "hashicorp_vault", "custom"]>>;
-    }, "strip", z.ZodTypeAny, {
-        algorithm: string;
-        perTenantKeys: boolean;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-    }, {
-        algorithm?: string | undefined;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-        perTenantKeys?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    strategy: "isolated_db";
-    database?: {
-        namingPattern: string;
-        serverStrategy: "shared" | "sharded" | "dedicated";
-        separateCredentials: boolean;
-        autoCreateDatabase: boolean;
-    } | undefined;
-    encryption?: {
-        algorithm: string;
-        perTenantKeys: boolean;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-    } | undefined;
-    backup?: {
-        strategy: "on_demand" | "individual" | "consolidated";
-        retentionDays: number;
-        frequencyHours: number;
-    } | undefined;
-    connectionPool?: {
-        idleTimeout: number;
-        poolSize: number;
-        maxActivePools: number;
-        usePooler: boolean;
-    } | undefined;
-}, {
-    strategy: "isolated_db";
-    database?: {
-        namingPattern?: string | undefined;
-        serverStrategy?: "shared" | "sharded" | "dedicated" | undefined;
-        separateCredentials?: boolean | undefined;
-        autoCreateDatabase?: boolean | undefined;
-    } | undefined;
-    encryption?: {
-        algorithm?: string | undefined;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-        perTenantKeys?: boolean | undefined;
-    } | undefined;
-    backup?: {
-        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
-        retentionDays?: number | undefined;
-        frequencyHours?: number | undefined;
-    } | undefined;
-    connectionPool?: {
-        idleTimeout?: number | undefined;
-        poolSize?: number | undefined;
-        maxActivePools?: number | undefined;
-        usePooler?: boolean | undefined;
-    } | undefined;
-}>;
+        keyManagement: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            aws_kms: "aws_kms";
+            azure_key_vault: "azure_key_vault";
+            gcp_kms: "gcp_kms";
+            hashicorp_vault: "hashicorp_vault";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type DatabaseLevelIsolationStrategy = z.infer<typeof DatabaseLevelIsolationStrategySchema>;
 /**
  * Tenant Isolation Configuration Schema
@@ -654,524 +308,116 @@ export type DatabaseLevelIsolationStrategy = z.infer<typeof DatabaseLevelIsolati
  * Complete configuration for tenant isolation strategy.
  * Supports all three isolation levels with detailed configuration options.
  */
-export declare const TenantIsolationConfigSchema: z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
+export declare const TenantIsolationConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     strategy: z.ZodLiteral<"shared_schema">;
-    /**
-     * Database configuration for row-level isolation
-     */
     database: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to enable Row-Level Security (RLS)
-         */
         enableRLS: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Tenant context setting method
-         */
-        contextMethod: z.ZodDefault<z.ZodEnum<["session_variable", "search_path", "application_name"]>>;
-        /**
-         * Session variable name for tenant context
-         */
+        contextMethod: z.ZodDefault<z.ZodEnum<{
+            session_variable: "session_variable";
+            search_path: "search_path";
+            application_name: "application_name";
+        }>>;
         contextVariable: z.ZodDefault<z.ZodString>;
-        /**
-         * Whether to validate tenant_id at application level
-         */
         applicationValidation: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enableRLS: boolean;
-        contextMethod: "session_variable" | "search_path" | "application_name";
-        contextVariable: string;
-        applicationValidation: boolean;
-    }, {
-        enableRLS?: boolean | undefined;
-        contextMethod?: "session_variable" | "search_path" | "application_name" | undefined;
-        contextVariable?: string | undefined;
-        applicationValidation?: boolean | undefined;
-    }>>;
-    /**
-     * Performance optimization settings
-     */
+    }, z.core.$strip>>;
     performance: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to use partial indexes for tenant_id
-         */
         usePartialIndexes: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Whether to use table partitioning
-         */
         usePartitioning: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Connection pool size per tenant
-         */
         poolSizePerTenant: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        usePartialIndexes: boolean;
-        usePartitioning: boolean;
-        poolSizePerTenant?: number | undefined;
-    }, {
-        usePartialIndexes?: boolean | undefined;
-        usePartitioning?: boolean | undefined;
-        poolSizePerTenant?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    strategy: "shared_schema";
-    database?: {
-        enableRLS: boolean;
-        contextMethod: "session_variable" | "search_path" | "application_name";
-        contextVariable: string;
-        applicationValidation: boolean;
-    } | undefined;
-    performance?: {
-        usePartialIndexes: boolean;
-        usePartitioning: boolean;
-        poolSizePerTenant?: number | undefined;
-    } | undefined;
-}, {
-    strategy: "shared_schema";
-    database?: {
-        enableRLS?: boolean | undefined;
-        contextMethod?: "session_variable" | "search_path" | "application_name" | undefined;
-        contextVariable?: string | undefined;
-        applicationValidation?: boolean | undefined;
-    } | undefined;
-    performance?: {
-        usePartialIndexes?: boolean | undefined;
-        usePartitioning?: boolean | undefined;
-        poolSizePerTenant?: number | undefined;
-    } | undefined;
-}>, z.ZodObject<{
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
     strategy: z.ZodLiteral<"isolated_schema">;
-    /**
-     * Schema configuration
-     */
     schema: z.ZodOptional<z.ZodObject<{
-        /**
-         * Schema naming pattern
-         * Use {tenant_id} as placeholder (must contain only alphanumeric and underscores)
-         * The tenant_id will be sanitized before substitution to prevent SQL injection
-         */
         namingPattern: z.ZodDefault<z.ZodString>;
-        /**
-         * Whether to include public schema in search_path
-         */
         includePublicSchema: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Default schema for shared resources
-         */
         sharedSchema: z.ZodDefault<z.ZodString>;
-        /**
-         * Whether to automatically create schema on tenant creation
-         */
         autoCreateSchema: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        namingPattern: string;
-        includePublicSchema: boolean;
-        sharedSchema: string;
-        autoCreateSchema: boolean;
-    }, {
-        namingPattern?: string | undefined;
-        includePublicSchema?: boolean | undefined;
-        sharedSchema?: string | undefined;
-        autoCreateSchema?: boolean | undefined;
-    }>>;
-    /**
-     * Migration configuration
-     */
+    }, z.core.$strip>>;
     migrations: z.ZodOptional<z.ZodObject<{
-        /**
-         * Migration strategy
-         */
-        strategy: z.ZodDefault<z.ZodEnum<["parallel", "sequential", "on_demand"]>>;
-        /**
-         * Maximum concurrent migrations
-         */
+        strategy: z.ZodDefault<z.ZodEnum<{
+            parallel: "parallel";
+            sequential: "sequential";
+            on_demand: "on_demand";
+        }>>;
         maxConcurrent: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Whether to rollback on first failure
-         */
         rollbackOnError: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        strategy: "parallel" | "sequential" | "on_demand";
-        maxConcurrent: number;
-        rollbackOnError: boolean;
-    }, {
-        strategy?: "parallel" | "sequential" | "on_demand" | undefined;
-        maxConcurrent?: number | undefined;
-        rollbackOnError?: boolean | undefined;
-    }>>;
-    /**
-     * Performance optimization settings
-     */
+    }, z.core.$strip>>;
     performance: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to use connection pooling per schema
-         */
         poolPerSchema: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Schema cache TTL in seconds
-         */
         schemaCacheTTL: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        poolPerSchema: boolean;
-        schemaCacheTTL: number;
-    }, {
-        poolPerSchema?: boolean | undefined;
-        schemaCacheTTL?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    strategy: "isolated_schema";
-    schema?: {
-        namingPattern: string;
-        includePublicSchema: boolean;
-        sharedSchema: string;
-        autoCreateSchema: boolean;
-    } | undefined;
-    migrations?: {
-        strategy: "parallel" | "sequential" | "on_demand";
-        maxConcurrent: number;
-        rollbackOnError: boolean;
-    } | undefined;
-    performance?: {
-        poolPerSchema: boolean;
-        schemaCacheTTL: number;
-    } | undefined;
-}, {
-    strategy: "isolated_schema";
-    schema?: {
-        namingPattern?: string | undefined;
-        includePublicSchema?: boolean | undefined;
-        sharedSchema?: string | undefined;
-        autoCreateSchema?: boolean | undefined;
-    } | undefined;
-    migrations?: {
-        strategy?: "parallel" | "sequential" | "on_demand" | undefined;
-        maxConcurrent?: number | undefined;
-        rollbackOnError?: boolean | undefined;
-    } | undefined;
-    performance?: {
-        poolPerSchema?: boolean | undefined;
-        schemaCacheTTL?: number | undefined;
-    } | undefined;
-}>, z.ZodObject<{
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
     strategy: z.ZodLiteral<"isolated_db">;
-    /**
-     * Database configuration
-     */
     database: z.ZodOptional<z.ZodObject<{
-        /**
-         * Database naming pattern
-         * Use {tenant_id} as placeholder (must contain only alphanumeric and underscores)
-         * The tenant_id will be sanitized before substitution to prevent SQL injection
-         */
         namingPattern: z.ZodDefault<z.ZodString>;
-        /**
-         * Database server/cluster assignment strategy
-         */
-        serverStrategy: z.ZodDefault<z.ZodEnum<["shared", "sharded", "dedicated"]>>;
-        /**
-         * Whether to use separate credentials per tenant
-         */
+        serverStrategy: z.ZodDefault<z.ZodEnum<{
+            shared: "shared";
+            sharded: "sharded";
+            dedicated: "dedicated";
+        }>>;
         separateCredentials: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Whether to automatically create database on tenant creation
-         */
         autoCreateDatabase: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        namingPattern: string;
-        serverStrategy: "shared" | "sharded" | "dedicated";
-        separateCredentials: boolean;
-        autoCreateDatabase: boolean;
-    }, {
-        namingPattern?: string | undefined;
-        serverStrategy?: "shared" | "sharded" | "dedicated" | undefined;
-        separateCredentials?: boolean | undefined;
-        autoCreateDatabase?: boolean | undefined;
-    }>>;
-    /**
-     * Connection pooling configuration
-     */
+    }, z.core.$strip>>;
     connectionPool: z.ZodOptional<z.ZodObject<{
-        /**
-         * Pool size per tenant database
-         */
         poolSize: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Maximum number of tenant pools to keep active
-         */
         maxActivePools: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Idle pool timeout in seconds
-         */
         idleTimeout: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Whether to use connection pooler (PgBouncer, etc.)
-         */
         usePooler: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        idleTimeout: number;
-        poolSize: number;
-        maxActivePools: number;
-        usePooler: boolean;
-    }, {
-        idleTimeout?: number | undefined;
-        poolSize?: number | undefined;
-        maxActivePools?: number | undefined;
-        usePooler?: boolean | undefined;
-    }>>;
-    /**
-     * Backup and restore configuration
-     */
+    }, z.core.$strip>>;
     backup: z.ZodOptional<z.ZodObject<{
-        /**
-         * Backup strategy per tenant
-         */
-        strategy: z.ZodDefault<z.ZodEnum<["individual", "consolidated", "on_demand"]>>;
-        /**
-         * Backup frequency in hours
-         */
+        strategy: z.ZodDefault<z.ZodEnum<{
+            on_demand: "on_demand";
+            individual: "individual";
+            consolidated: "consolidated";
+        }>>;
         frequencyHours: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Retention period in days
-         */
         retentionDays: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        strategy: "on_demand" | "individual" | "consolidated";
-        retentionDays: number;
-        frequencyHours: number;
-    }, {
-        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
-        retentionDays?: number | undefined;
-        frequencyHours?: number | undefined;
-    }>>;
-    /**
-     * Encryption configuration
-     */
+    }, z.core.$strip>>;
     encryption: z.ZodOptional<z.ZodObject<{
-        /**
-         * Whether to use per-tenant encryption keys
-         */
         perTenantKeys: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Encryption algorithm
-         */
         algorithm: z.ZodDefault<z.ZodString>;
-        /**
-         * Key management service
-         */
-        keyManagement: z.ZodOptional<z.ZodEnum<["aws_kms", "azure_key_vault", "gcp_kms", "hashicorp_vault", "custom"]>>;
-    }, "strip", z.ZodTypeAny, {
-        algorithm: string;
-        perTenantKeys: boolean;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-    }, {
-        algorithm?: string | undefined;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-        perTenantKeys?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    strategy: "isolated_db";
-    database?: {
-        namingPattern: string;
-        serverStrategy: "shared" | "sharded" | "dedicated";
-        separateCredentials: boolean;
-        autoCreateDatabase: boolean;
-    } | undefined;
-    encryption?: {
-        algorithm: string;
-        perTenantKeys: boolean;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-    } | undefined;
-    backup?: {
-        strategy: "on_demand" | "individual" | "consolidated";
-        retentionDays: number;
-        frequencyHours: number;
-    } | undefined;
-    connectionPool?: {
-        idleTimeout: number;
-        poolSize: number;
-        maxActivePools: number;
-        usePooler: boolean;
-    } | undefined;
-}, {
-    strategy: "isolated_db";
-    database?: {
-        namingPattern?: string | undefined;
-        serverStrategy?: "shared" | "sharded" | "dedicated" | undefined;
-        separateCredentials?: boolean | undefined;
-        autoCreateDatabase?: boolean | undefined;
-    } | undefined;
-    encryption?: {
-        algorithm?: string | undefined;
-        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
-        perTenantKeys?: boolean | undefined;
-    } | undefined;
-    backup?: {
-        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
-        retentionDays?: number | undefined;
-        frequencyHours?: number | undefined;
-    } | undefined;
-    connectionPool?: {
-        idleTimeout?: number | undefined;
-        poolSize?: number | undefined;
-        maxActivePools?: number | undefined;
-        usePooler?: boolean | undefined;
-    } | undefined;
-}>]>;
+        keyManagement: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            aws_kms: "aws_kms";
+            azure_key_vault: "azure_key_vault";
+            gcp_kms: "gcp_kms";
+            hashicorp_vault: "hashicorp_vault";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "strategy">;
 export type TenantIsolationConfig = z.infer<typeof TenantIsolationConfigSchema>;
 /**
  * Tenant Security Policy Schema
  * Defines security policies and compliance requirements for tenants
  */
 export declare const TenantSecurityPolicySchema: z.ZodObject<{
-    /**
-     * Encryption requirements
-     */
     encryption: z.ZodOptional<z.ZodObject<{
-        /**
-         * Require encryption at rest
-         */
         atRest: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Require encryption in transit
-         */
         inTransit: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Require field-level encryption for sensitive data
-         */
         fieldLevel: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        atRest: boolean;
-        inTransit: boolean;
-        fieldLevel: boolean;
-    }, {
-        atRest?: boolean | undefined;
-        inTransit?: boolean | undefined;
-        fieldLevel?: boolean | undefined;
-    }>>;
-    /**
-     * Access control requirements
-     */
+    }, z.core.$strip>>;
     accessControl: z.ZodOptional<z.ZodObject<{
-        /**
-         * Require multi-factor authentication
-         */
         requireMFA: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Require SSO/SAML authentication
-         */
         requireSSO: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * IP whitelist
-         */
-        ipWhitelist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /**
-         * Session timeout in seconds
-         */
+        ipWhitelist: z.ZodOptional<z.ZodArray<z.ZodString>>;
         sessionTimeout: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        requireMFA: boolean;
-        requireSSO: boolean;
-        sessionTimeout: number;
-        ipWhitelist?: string[] | undefined;
-    }, {
-        requireMFA?: boolean | undefined;
-        requireSSO?: boolean | undefined;
-        ipWhitelist?: string[] | undefined;
-        sessionTimeout?: number | undefined;
-    }>>;
-    /**
-     * Audit and compliance requirements
-     */
+    }, z.core.$strip>>;
     compliance: z.ZodOptional<z.ZodObject<{
-        /**
-         * Compliance standards to enforce
-         */
-        standards: z.ZodOptional<z.ZodArray<z.ZodEnum<["sox", "hipaa", "gdpr", "pci_dss", "iso_27001", "fedramp"]>, "many">>;
-        /**
-         * Require audit logging for all operations
-         */
+        standards: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            sox: "sox";
+            hipaa: "hipaa";
+            gdpr: "gdpr";
+            pci_dss: "pci_dss";
+            iso_27001: "iso_27001";
+            fedramp: "fedramp";
+        }>>>;
         requireAuditLog: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Audit log retention period in days
-         */
         auditRetentionDays: z.ZodDefault<z.ZodNumber>;
-        /**
-         * Data residency requirements
-         */
         dataResidency: z.ZodOptional<z.ZodObject<{
-            /**
-             * Required geographic region
-             */
             region: z.ZodOptional<z.ZodString>;
-            /**
-             * Prohibited regions
-             */
-            excludeRegions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            region?: string | undefined;
-            excludeRegions?: string[] | undefined;
-        }, {
-            region?: string | undefined;
-            excludeRegions?: string[] | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        requireAuditLog: boolean;
-        auditRetentionDays: number;
-        standards?: ("sox" | "hipaa" | "gdpr" | "pci_dss" | "iso_27001" | "fedramp")[] | undefined;
-        dataResidency?: {
-            region?: string | undefined;
-            excludeRegions?: string[] | undefined;
-        } | undefined;
-    }, {
-        standards?: ("sox" | "hipaa" | "gdpr" | "pci_dss" | "iso_27001" | "fedramp")[] | undefined;
-        requireAuditLog?: boolean | undefined;
-        auditRetentionDays?: number | undefined;
-        dataResidency?: {
-            region?: string | undefined;
-            excludeRegions?: string[] | undefined;
-        } | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    encryption?: {
-        atRest: boolean;
-        inTransit: boolean;
-        fieldLevel: boolean;
-    } | undefined;
-    compliance?: {
-        requireAuditLog: boolean;
-        auditRetentionDays: number;
-        standards?: ("sox" | "hipaa" | "gdpr" | "pci_dss" | "iso_27001" | "fedramp")[] | undefined;
-        dataResidency?: {
-            region?: string | undefined;
-            excludeRegions?: string[] | undefined;
-        } | undefined;
-    } | undefined;
-    accessControl?: {
-        requireMFA: boolean;
-        requireSSO: boolean;
-        sessionTimeout: number;
-        ipWhitelist?: string[] | undefined;
-    } | undefined;
-}, {
-    encryption?: {
-        atRest?: boolean | undefined;
-        inTransit?: boolean | undefined;
-        fieldLevel?: boolean | undefined;
-    } | undefined;
-    compliance?: {
-        standards?: ("sox" | "hipaa" | "gdpr" | "pci_dss" | "iso_27001" | "fedramp")[] | undefined;
-        requireAuditLog?: boolean | undefined;
-        auditRetentionDays?: number | undefined;
-        dataResidency?: {
-            region?: string | undefined;
-            excludeRegions?: string[] | undefined;
-        } | undefined;
-    } | undefined;
-    accessControl?: {
-        requireMFA?: boolean | undefined;
-        requireSSO?: boolean | undefined;
-        ipWhitelist?: string[] | undefined;
-        sessionTimeout?: number | undefined;
-    } | undefined;
-}>;
+            excludeRegions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type TenantSecurityPolicy = z.infer<typeof TenantSecurityPolicySchema>;
 //# sourceMappingURL=tenant.zod.d.ts.map