@objectstack/spec 0.3.0 → 0.3.1

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

@@ -0,0 +1,1151 @@
+import { z } from 'zod';
+/**
+ * Tenant Schema (Multi-Tenant Architecture)
+ *
+ * Defines the tenant/tenancy model for ObjectStack SaaS deployments.
+ * Supports different levels of data isolation to meet varying security,
+ * performance, and compliance requirements.
+ *
+ * Isolation Levels:
+ * - shared_schema: All tenants share the same database and schema (row-level isolation)
+ * - isolated_schema: Tenants have separate schemas within a shared database
+ * - isolated_db: Each tenant has a completely separate database
+ */
+/**
+ * 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 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;
+}>;
+export type TenantQuota = z.infer<typeof TenantQuotaSchema>;
+/**
+ * Tenant Schema
+ * Represents a tenant in a multi-tenant SaaS deployment
+ */
+export declare const TenantSchema: z.ZodObject<{
+    /**
+     * Unique tenant identifier
+     */
+    id: z.ZodString;
+    /**
+     * Tenant name (display name)
+     */
+    name: z.ZodString;
+    /**
+     * Data isolation level for this tenant
+     * Determines how tenant data is segregated from other tenants
+     */
+    isolationLevel: z.ZodEnum<["shared_schema", "isolated_schema", "isolated_db"]>;
+    /**
+     * Custom configurations and metadata specific to this tenant
+     * Can store tenant-specific settings, branding, features, etc.
+     */
+    customizations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /**
+     * Resource quotas and limits for this tenant
+     */
+    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;
+}>;
+export type Tenant = z.infer<typeof TenantSchema>;
+/**
+ * Tenant Isolation Strategy Documentation
+ *
+ * Comprehensive documentation of three isolation strategies for multi-tenant systems.
+ * Each strategy has different trade-offs in terms of security, cost, complexity, and compliance.
+ */
+/**
+ * Row-Level Isolation Strategy (shared_schema)
+ *
+ * Recommended for: Most SaaS applications, cost-sensitive deployments
+ *
+ * IMPLEMENTATION:
+ * - All tenants share the same database and schema
+ * - Each table includes a tenant_id column
+ * - PostgreSQL Row-Level Security (RLS) enforces isolation
+ * - Queries automatically filter by tenant_id via RLS policies
+ *
+ * ADVANTAGES:
+ * ✅ Simple backup and restore (single database)
+ * ✅ Cost-effective (shared resources, minimal overhead)
+ * ✅ Easy tenant migration (update tenant_id)
+ * ✅ Efficient resource utilization (connection pooling)
+ * ✅ Simple schema migrations (single schema to update)
+ * ✅ Lower operational complexity
+ *
+ * DISADVANTAGES:
+ * ❌ RLS misconfiguration can lead to data leakage
+ * ❌ Performance impact from RLS policy evaluation
+ * ❌ Noisy neighbor problem (one tenant can affect others)
+ * ❌ Cannot easily isolate tenant to different hardware
+ * ❌ Compliance challenges for regulated industries
+ *
+ * SECURITY CONSIDERATIONS:
+ * - Requires careful RLS policy configuration
+ * - Must validate tenant_id in all queries
+ * - Need comprehensive testing of RLS policies
+ * - Audit all database access patterns
+ * - Implement application-level validation as defense-in-depth
+ *
+ * EXAMPLE RLS POLICY (PostgreSQL):
+ * ```sql
+ * -- Example: Apply RLS policy to a table (e.g., "app_data")
+ * CREATE POLICY tenant_isolation ON app_data
+ *   USING (tenant_id = current_setting('app.current_tenant')::text);
+ *
+ * ALTER TABLE app_data ENABLE ROW LEVEL SECURITY;
+ * ```
+ */
+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
+         */
+        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
+     */
+    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;
+}>;
+export type RowLevelIsolationStrategy = z.infer<typeof RowLevelIsolationStrategySchema>;
+/**
+ * Schema-Level Isolation Strategy (isolated_schema)
+ *
+ * Recommended for: Enterprise SaaS, B2B platforms with compliance needs
+ *
+ * IMPLEMENTATION:
+ * - All tenants share the same database server
+ * - Each tenant has a separate database schema
+ * - Schema name typically: tenant_<tenant_id>
+ * - Application switches schema using SET search_path
+ *
+ * ADVANTAGES:
+ * ✅ Better isolation than row-level (schema boundaries)
+ * ✅ Easier to debug (separate schemas)
+ * ✅ Can grant different database permissions per schema
+ * ✅ Reduced risk of data leakage
+ * ✅ Performance isolation (indexes, statistics per schema)
+ * ✅ Simplified queries (no tenant_id filtering needed)
+ *
+ * DISADVANTAGES:
+ * ❌ More complex backups (must backup all schemas)
+ * ❌ Higher migration costs (schema changes across all tenants)
+ * ❌ Schema proliferation (PostgreSQL has limits)
+ * ❌ Connection overhead (switching schemas)
+ * ❌ More complex monitoring and maintenance
+ *
+ * SECURITY CONSIDERATIONS:
+ * - Ensure proper schema permissions (GRANT USAGE ON SCHEMA)
+ * - Validate schema name to prevent SQL injection
+ * - Implement connection-level schema switching
+ * - Audit schema access patterns
+ * - Prevent cross-schema queries in application
+ *
+ * EXAMPLE IMPLEMENTATION (PostgreSQL):
+ * ```sql
+ * -- Create tenant schema
+ * CREATE SCHEMA tenant_123;
+ *
+ * -- Grant access
+ * GRANT USAGE ON SCHEMA tenant_123 TO app_user;
+ *
+ * -- Switch to tenant schema
+ * SET search_path TO tenant_123, public;
+ * ```
+ */
+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
+     */
+    migrations: z.ZodOptional<z.ZodObject<{
+        /**
+         * Migration strategy
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["parallel", "sequential", "on_demand"]>>;
+        /**
+         * Maximum concurrent migrations
+         */
+        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
+     */
+    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;
+    performance?: {
+        poolPerSchema: boolean;
+        schemaCacheTTL: number;
+    } | undefined;
+    migrations?: {
+        strategy: "parallel" | "sequential" | "on_demand";
+        maxConcurrent: number;
+        rollbackOnError: boolean;
+    } | undefined;
+}, {
+    strategy: "isolated_schema";
+    schema?: {
+        namingPattern?: string | undefined;
+        includePublicSchema?: boolean | undefined;
+        sharedSchema?: string | undefined;
+        autoCreateSchema?: boolean | undefined;
+    } | undefined;
+    performance?: {
+        poolPerSchema?: boolean | undefined;
+        schemaCacheTTL?: number | undefined;
+    } | undefined;
+    migrations?: {
+        strategy?: "parallel" | "sequential" | "on_demand" | undefined;
+        maxConcurrent?: number | undefined;
+        rollbackOnError?: boolean | undefined;
+    } | undefined;
+}>;
+export type SchemaLevelIsolationStrategy = z.infer<typeof SchemaLevelIsolationStrategySchema>;
+/**
+ * Database-Level Isolation Strategy (isolated_db)
+ *
+ * Recommended for: Regulated industries (healthcare, finance), strict compliance requirements
+ *
+ * IMPLEMENTATION:
+ * - Each tenant has a completely separate database
+ * - Database name typically: tenant_<tenant_id>
+ * - Requires separate connection pool per tenant
+ * - Complete physical and logical isolation
+ *
+ * ADVANTAGES:
+ * ✅ Perfect data isolation (strongest security)
+ * ✅ Meets strict regulatory requirements (HIPAA, SOX, PCI-DSS)
+ * ✅ Complete performance isolation (no noisy neighbors)
+ * ✅ Can place databases on different hardware
+ * ✅ Easy to backup/restore individual tenant
+ * ✅ Simplified compliance auditing per tenant
+ * ✅ Can apply different encryption keys per database
+ *
+ * DISADVANTAGES:
+ * ❌ Most expensive option (resource overhead)
+ * ❌ Complex database server management (many databases)
+ * ❌ Connection pool limits (max connections per server)
+ * ❌ Difficult cross-tenant analytics
+ * ❌ Higher operational complexity
+ * ❌ Schema migrations take longer (many databases)
+ *
+ * SECURITY CONSIDERATIONS:
+ * - Each database can have separate credentials
+ * - Enables per-tenant encryption at rest
+ * - Simplifies compliance and audit trails
+ * - Prevents any cross-tenant data access
+ * - Supports tenant-specific backup schedules
+ *
+ * EXAMPLE IMPLEMENTATION (PostgreSQL):
+ * ```sql
+ * -- Create tenant database
+ * CREATE DATABASE tenant_123
+ *   WITH OWNER = tenant_123_user
+ *   ENCODING = 'UTF8'
+ *   LC_COLLATE = 'en_US.UTF-8'
+ *   LC_CTYPE = 'en_US.UTF-8';
+ *
+ * -- Connect to tenant database
+ * \c tenant_123
+ * ```
+ */
+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
+         */
+        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
+     */
+    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
+     */
+    backup: z.ZodOptional<z.ZodObject<{
+        /**
+         * Backup strategy per tenant
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["individual", "consolidated", "on_demand"]>>;
+        /**
+         * Backup frequency in hours
+         */
+        frequencyHours: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Retention period in days
+         */
+        retentionDays: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "on_demand" | "individual" | "consolidated";
+        frequencyHours: number;
+        retentionDays: number;
+    }, {
+        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
+        frequencyHours?: number | undefined;
+        retentionDays?: number | undefined;
+    }>>;
+    /**
+     * Encryption configuration
+     */
+    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, {
+        perTenantKeys: boolean;
+        algorithm: string;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    }, {
+        perTenantKeys?: boolean | undefined;
+        algorithm?: string | undefined;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "isolated_db";
+    encryption?: {
+        perTenantKeys: boolean;
+        algorithm: string;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    } | undefined;
+    database?: {
+        namingPattern: string;
+        serverStrategy: "shared" | "sharded" | "dedicated";
+        separateCredentials: boolean;
+        autoCreateDatabase: boolean;
+    } | undefined;
+    connectionPool?: {
+        idleTimeout: number;
+        poolSize: number;
+        maxActivePools: number;
+        usePooler: boolean;
+    } | undefined;
+    backup?: {
+        strategy: "on_demand" | "individual" | "consolidated";
+        frequencyHours: number;
+        retentionDays: number;
+    } | undefined;
+}, {
+    strategy: "isolated_db";
+    encryption?: {
+        perTenantKeys?: boolean | undefined;
+        algorithm?: string | undefined;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    } | undefined;
+    database?: {
+        namingPattern?: string | undefined;
+        serverStrategy?: "shared" | "sharded" | "dedicated" | undefined;
+        separateCredentials?: boolean | undefined;
+        autoCreateDatabase?: boolean | undefined;
+    } | undefined;
+    connectionPool?: {
+        idleTimeout?: number | undefined;
+        poolSize?: number | undefined;
+        maxActivePools?: number | undefined;
+        usePooler?: boolean | undefined;
+    } | undefined;
+    backup?: {
+        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
+        frequencyHours?: number | undefined;
+        retentionDays?: number | undefined;
+    } | undefined;
+}>;
+export type DatabaseLevelIsolationStrategy = z.infer<typeof DatabaseLevelIsolationStrategySchema>;
+/**
+ * Tenant Isolation Configuration Schema
+ *
+ * Complete configuration for tenant isolation strategy.
+ * Supports all three isolation levels with detailed configuration options.
+ */
+export declare const TenantIsolationConfigSchema: z.ZodDiscriminatedUnion<"strategy", [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
+         */
+        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
+     */
+    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<{
+    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
+     */
+    migrations: z.ZodOptional<z.ZodObject<{
+        /**
+         * Migration strategy
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["parallel", "sequential", "on_demand"]>>;
+        /**
+         * Maximum concurrent migrations
+         */
+        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
+     */
+    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;
+    performance?: {
+        poolPerSchema: boolean;
+        schemaCacheTTL: number;
+    } | undefined;
+    migrations?: {
+        strategy: "parallel" | "sequential" | "on_demand";
+        maxConcurrent: number;
+        rollbackOnError: boolean;
+    } | undefined;
+}, {
+    strategy: "isolated_schema";
+    schema?: {
+        namingPattern?: string | undefined;
+        includePublicSchema?: boolean | undefined;
+        sharedSchema?: string | undefined;
+        autoCreateSchema?: boolean | undefined;
+    } | undefined;
+    performance?: {
+        poolPerSchema?: boolean | undefined;
+        schemaCacheTTL?: number | undefined;
+    } | undefined;
+    migrations?: {
+        strategy?: "parallel" | "sequential" | "on_demand" | undefined;
+        maxConcurrent?: number | undefined;
+        rollbackOnError?: boolean | undefined;
+    } | undefined;
+}>, 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
+         */
+        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
+     */
+    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
+     */
+    backup: z.ZodOptional<z.ZodObject<{
+        /**
+         * Backup strategy per tenant
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["individual", "consolidated", "on_demand"]>>;
+        /**
+         * Backup frequency in hours
+         */
+        frequencyHours: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Retention period in days
+         */
+        retentionDays: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "on_demand" | "individual" | "consolidated";
+        frequencyHours: number;
+        retentionDays: number;
+    }, {
+        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
+        frequencyHours?: number | undefined;
+        retentionDays?: number | undefined;
+    }>>;
+    /**
+     * Encryption configuration
+     */
+    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, {
+        perTenantKeys: boolean;
+        algorithm: string;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    }, {
+        perTenantKeys?: boolean | undefined;
+        algorithm?: string | undefined;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "isolated_db";
+    encryption?: {
+        perTenantKeys: boolean;
+        algorithm: string;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    } | undefined;
+    database?: {
+        namingPattern: string;
+        serverStrategy: "shared" | "sharded" | "dedicated";
+        separateCredentials: boolean;
+        autoCreateDatabase: boolean;
+    } | undefined;
+    connectionPool?: {
+        idleTimeout: number;
+        poolSize: number;
+        maxActivePools: number;
+        usePooler: boolean;
+    } | undefined;
+    backup?: {
+        strategy: "on_demand" | "individual" | "consolidated";
+        frequencyHours: number;
+        retentionDays: number;
+    } | undefined;
+}, {
+    strategy: "isolated_db";
+    encryption?: {
+        perTenantKeys?: boolean | undefined;
+        algorithm?: string | undefined;
+        keyManagement?: "custom" | "aws_kms" | "azure_key_vault" | "gcp_kms" | "hashicorp_vault" | undefined;
+    } | undefined;
+    database?: {
+        namingPattern?: string | undefined;
+        serverStrategy?: "shared" | "sharded" | "dedicated" | undefined;
+        separateCredentials?: boolean | undefined;
+        autoCreateDatabase?: boolean | undefined;
+    } | undefined;
+    connectionPool?: {
+        idleTimeout?: number | undefined;
+        poolSize?: number | undefined;
+        maxActivePools?: number | undefined;
+        usePooler?: boolean | undefined;
+    } | undefined;
+    backup?: {
+        strategy?: "on_demand" | "individual" | "consolidated" | undefined;
+        frequencyHours?: number | undefined;
+        retentionDays?: number | undefined;
+    } | undefined;
+}>]>;
+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
+     */
+    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
+         */
+        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
+     */
+    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
+         */
+        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;
+    accessControl?: {
+        requireMFA: boolean;
+        requireSSO: boolean;
+        sessionTimeout: number;
+        ipWhitelist?: string[] | undefined;
+    } | 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;
+}, {
+    encryption?: {
+        atRest?: boolean | undefined;
+        inTransit?: boolean | undefined;
+        fieldLevel?: boolean | undefined;
+    } | undefined;
+    accessControl?: {
+        requireMFA?: boolean | undefined;
+        requireSSO?: boolean | undefined;
+        ipWhitelist?: string[] | undefined;
+        sessionTimeout?: number | 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;
+}>;
+export type TenantSecurityPolicy = z.infer<typeof TenantSecurityPolicySchema>;
+//# sourceMappingURL=tenant.zod.d.ts.map