uni-types 1.4.0 → 1.5.0

package/dist/index.d.mts

@@ -221,6 +221,293 @@ interface AsyncFailure<E = Error> {
   error: E;
 }
 //#endregion
+//#region src/auth/index.d.ts
+/**
+ * Authorization & Permissions Types
+ *
+ * Types for authorization and permission management.
+ */
+/**
+ * Permission type
+ */
+interface Permission<T = string> {
+  name: T;
+  description?: string;
+  resource?: string;
+  action?: Action;
+  conditions?: PermissionCondition[];
+}
+/**
+ * Permission set
+ */
+type PermissionSet<T = string> = Set<T> | T[];
+/**
+ * Permission grant
+ */
+interface PermissionGrant<T = string> {
+  permission: T;
+  granted: true;
+  grantedBy: string;
+  grantedAt: Date;
+  expiresAt?: Date;
+  conditions?: PermissionCondition[];
+}
+/**
+ * Permission deny
+ */
+interface PermissionDeny<T = string> {
+  permission: T;
+  granted: false;
+  deniedBy: string;
+  deniedAt: Date;
+  reason?: string;
+}
+/**
+ * Permission condition
+ */
+interface PermissionCondition<T = unknown> {
+  attribute: string;
+  operator: ConditionOperator;
+  value: T;
+}
+/**
+ * Condition operator
+ */
+type ConditionOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'contains' | 'startsWith' | 'endsWith' | 'exists' | 'notExists';
+/**
+ * Permission check result
+ */
+type PermissionCheckResult = {
+  allowed: true;
+  reason?: string;
+} | {
+  allowed: false;
+  reason: string;
+  missingPermissions?: string[];
+};
+/**
+ * Role type
+ */
+interface Role<T = string> {
+  name: T;
+  description?: string;
+  permissions: PermissionSet;
+  inherits?: T[];
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+/**
+ * Role set
+ */
+type RoleSet<T = string> = Set<T> | T[];
+/**
+ * Role permission mapping
+ */
+interface RolePermission<R = string, P = string> {
+  role: R;
+  permissions: P[];
+  grantedAt?: Date;
+  grantedBy?: string;
+}
+/**
+ * Role hierarchy
+ */
+interface RoleHierarchy<T = string> {
+  role: T;
+  parent?: T;
+  children?: T[];
+  level: number;
+}
+/**
+ * Policy type
+ */
+interface Policy {
+  id: string;
+  name: string;
+  description?: string;
+  effect: PolicyEffect;
+  principals: string[];
+  actions: Action[];
+  resources: string[];
+  conditions?: PolicyCondition[];
+  version?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+/**
+ * Policy rule
+ */
+interface PolicyRule<T = unknown> {
+  effect: PolicyEffect;
+  action: Action | Action[];
+  resource: string | string[];
+  condition?: PolicyCondition<T>[];
+  description?: string;
+}
+/**
+ * Policy effect
+ */
+type PolicyEffect = 'allow' | 'deny';
+/**
+ * Policy condition
+ */
+interface PolicyCondition<T = unknown> {
+  key: string;
+  operator: ConditionOperator;
+  value: T;
+  description?: string;
+}
+/**
+ * Policy evaluation context
+ */
+interface PolicyContext<T = unknown> {
+  principal: string;
+  action: Action;
+  resource: string;
+  environment?: Record<string, unknown>;
+  context?: T;
+}
+/**
+ * Policy evaluation result
+ */
+interface PolicyResult {
+  effect: PolicyEffect;
+  matchedPolicies: string[];
+  deniedBy?: string[];
+  allowedBy?: string[];
+}
+/**
+ * Access control type
+ */
+interface AccessControl<T = unknown> {
+  check: (context: PolicyContext<T>) => PolicyResult;
+  grant: (principal: string, permission: string) => void;
+  revoke: (principal: string, permission: string) => void;
+  getPermissions: (principal: string) => PermissionSet;
+}
+/**
+ * ACL (Access Control List)
+ */
+interface ACL {
+  entries: ACLEntry[];
+  getEntry: (principal: string, resource: string) => ACLEntry | undefined;
+  addEntry: (entry: ACLEntry) => void;
+  removeEntry: (principal: string, resource: string) => void;
+  check: (principal: string, resource: string, action: Action) => boolean;
+}
+/**
+ * ACL entry
+ */
+interface ACLEntry {
+  principal: string;
+  resource: string;
+  actions: Action[];
+  effect: PolicyEffect;
+  conditions?: PolicyCondition[];
+}
+/**
+ * Resource type
+ */
+interface Resource<T = unknown> {
+  type: string;
+  id: string;
+  attributes?: T;
+  owner?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+/**
+ * Action type
+ */
+type Action = 'create' | 'read' | 'update' | 'delete' | 'list' | 'execute' | 'admin' | string;
+/**
+ * RBAC (Role-Based Access Control)
+ */
+interface RBAC<R extends string = string, P extends string = string> {
+  roles: Map<R, Role<R>>;
+  rolePermissions: Map<R, P[]>;
+  userRoles: Map<string, R[]>;
+  assignRole: (userId: string, role: R) => void;
+  revokeRole: (userId: string, role: R) => void;
+  getUserRoles: (userId: string) => R[];
+  getUserPermissions: (userId: string) => P[];
+  checkPermission: (userId: string, permission: P) => boolean;
+  addRole: (role: Role<R>) => void;
+  removeRole: (roleName: R) => void;
+  getRole: (roleName: R) => Role<R> | undefined;
+}
+/**
+ * RBAC configuration
+ */
+interface RBACConfig<R = string, P = string> {
+  roles: Role<R>[];
+  rolePermissions: RolePermission<R, P>[];
+  userRoleAssignments: {
+    userId: string;
+    roles: R[];
+  }[];
+  defaultRole?: R;
+  superAdminRole?: R;
+}
+/**
+ * ABAC (Attribute-Based Access Control)
+ */
+interface ABAC<T = unknown> {
+  policies: Policy[];
+  addPolicy: (policy: Policy) => void;
+  removePolicy: (policyId: string) => void;
+  getPolicy: (policyId: string) => Policy | undefined;
+  evaluate: (context: PolicyContext<T>) => PolicyResult;
+  getApplicablePolicies: (context: PolicyContext<T>) => Policy[];
+}
+/**
+ * Attribute type
+ */
+interface Attribute<T = unknown> {
+  name: string;
+  value: T;
+  type: 'string' | 'number' | 'boolean' | 'date' | 'list' | 'map';
+  description?: string;
+}
+/**
+ * Attribute value
+ */
+interface AttributeValue<T = unknown> {
+  attribute: string;
+  value: T;
+  source: 'user' | 'resource' | 'environment' | 'context';
+}
+/**
+ * ABAC configuration
+ */
+interface ABACConfig {
+  policies: Policy[];
+  defaultDecision: PolicyEffect;
+  attributeResolvers?: Record<string, (context: PolicyContext) => AttributeValue>;
+}
+/**
+ * Authorization provider
+ */
+interface AuthorizationProvider<T = unknown> {
+  initialize: () => Promise<void>;
+  checkPermission: (userId: string, permission: string, context?: T) => Promise<PermissionCheckResult>;
+  getUserPermissions: (userId: string) => Promise<PermissionSet>;
+  getUserRoles: (userId: string) => Promise<RoleSet>;
+  grantPermission: (userId: string, permission: string) => Promise<void>;
+  revokePermission: (userId: string, permission: string) => Promise<void>;
+  assignRole: (userId: string, role: string) => Promise<void>;
+  revokeRole: (userId: string, role: string) => Promise<void>;
+}
+/**
+ * Authorization options
+ */
+interface AuthorizationOptions {
+  cache: boolean;
+  cacheTTL: number;
+  throwOnDenied: boolean;
+  logDecisions: boolean;
+}
+//#endregion
 //#region src/brand/index.d.ts
 /**
  * Brand/Opaque types for nominal typing
@@ -260,6 +547,264 @@ type Unbrand<T> = T extends Brand<infer U, infer _> ? U : T;
 type BrandedString<B extends string> = Brand<string, B>;
 type BrandedNumber<B extends string> = Brand<number, B>;
 //#endregion
+//#region src/cache/index.d.ts
+/**
+ * Caching Strategies Types
+ *
+ * Types for caching patterns and implementations.
+ */
+/**
+ * Cache type
+ */
+interface Cache<T = unknown> {
+  get: (key: string) => Promise<T | undefined>;
+  set: (key: string, value: T, options?: CacheOptions) => Promise<void>;
+  has: (key: string) => Promise<boolean>;
+  delete: (key: string) => Promise<boolean>;
+  clear: () => Promise<void>;
+  keys: () => Promise<string[]>;
+  getMany: (keys: string[]) => Promise<(T | undefined)[]>;
+  setMany: (entries: CacheEntry<T>[]) => Promise<void>;
+  deleteMany: (keys: string[]) => Promise<number>;
+}
+/**
+ * Cache entry
+ */
+interface CacheEntry<T = unknown> {
+  key: string;
+  value: T;
+  ttl?: number;
+  createdAt?: Date;
+  updatedAt?: Date;
+  tags?: string[];
+}
+/**
+ * Cache key type
+ */
+type CacheKey = string | CacheKeyBuilder;
+/**
+ * Cache key builder
+ */
+type CacheKeyBuilder = (params: unknown) => string;
+/**
+ * Cache value
+ */
+type CacheValue<T = unknown> = T;
+/**
+ * Cache options
+ */
+interface CacheOptions {
+  ttl?: number;
+  tags?: string[];
+  version?: number;
+  noEvict?: boolean;
+  priority?: number;
+}
+/**
+ * Cache statistics
+ */
+interface CacheStats {
+  hits: number;
+  misses: number;
+  hitRate: number;
+  missRate: number;
+  size: number;
+  maxSize?: number;
+  evictions: number;
+  memoryUsage?: number;
+  uptime: number;
+}
+/**
+ * Hit rate type
+ */
+type HitRate = number;
+/**
+ * Miss rate type
+ */
+type MissRate = number;
+/**
+ * Cache strategy
+ */
+type CacheStrategy = 'lru' | 'lfu' | 'fifo' | 'ttl' | 'arc' | 'lfru' | '2q';
+/**
+ * LRU Cache
+ */
+type LRUCache<T = unknown> = Cache<T> & {
+  readonly maxSize: number;
+  readonly currentSize: number;
+  peek: (key: string) => T | undefined;
+  dump: () => CacheEntry<T>[];
+  restore: (entries: CacheEntry<T>[]) => void;
+  prune: () => void;
+};
+/**
+ * LFU Cache
+ */
+type LFUCache<T = unknown> = Cache<T> & {
+  readonly maxSize: number;
+  getFrequency: (key: string) => number;
+};
+/**
+ * TTL Cache
+ */
+type TTLCache<T = unknown> = Cache<T> & {
+  readonly defaultTTL: number;
+  getRemainingTTL: (key: string) => number;
+  refresh: (key: string) => boolean;
+};
+/**
+ * FIFO Cache
+ */
+type FIFOCache<T = unknown> = Cache<T> & {
+  readonly maxSize: number;
+  readonly currentSize: number;
+};
+/**
+ * ARC Cache (Adaptive Replacement Cache)
+ */
+type ARCCache<T = unknown> = Cache<T> & {
+  readonly p: number;
+  readonly recentKeys: Set<string>;
+  readonly frequentKeys: Set<string>;
+};
+/**
+ * Cache invalidation
+ */
+interface CacheInvalidation<T = unknown> {
+  invalidate: (key: string) => Promise<void>;
+  invalidateByTag: (tag: string) => Promise<void>;
+  invalidateByPattern: (pattern: string | RegExp) => Promise<void>;
+  invalidateAll: () => Promise<void>;
+  onInvalidation?: (event: InvalidationEvent<T>) => void;
+}
+/**
+ * Invalidation rule
+ */
+interface InvalidationRule<T = unknown> {
+  type: 'key' | 'tag' | 'pattern' | 'custom';
+  pattern?: string | RegExp;
+  tags?: string[];
+  custom?: (entry: CacheEntry<T>) => boolean;
+  debounce?: number;
+}
+/**
+ * Invalidation strategy
+ */
+type InvalidationStrategy = 'time-based' | 'event-based' | 'manual' | 'write-through' | 'write-behind';
+/**
+ * Invalidation event
+ */
+interface InvalidationEvent<T = unknown> {
+  type: InvalidationStrategy;
+  keys: string[];
+  timestamp: Date;
+  reason?: string;
+  entry?: CacheEntry<T>;
+}
+/**
+ * Distributed cache
+ */
+type DistributedCache<T = unknown> = Cache<T> & {
+  nodes: CacheNode[];
+  consistentHash: ConsistentHash;
+  replicate: (key: string, value: T) => Promise<void>;
+  failover: (failedNode: string) => Promise<void>;
+  sync: () => Promise<void>;
+};
+/**
+ * Cache cluster
+ */
+interface CacheCluster {
+  nodes: CacheNode[];
+  strategy: 'replicated' | 'partitioned' | 'consistent-hashing';
+  replicationFactor: number;
+  partitioner?: (key: string) => string;
+}
+/**
+ * Cache node
+ */
+interface CacheNode {
+  id: string;
+  host: string;
+  port: number;
+  status: 'online' | 'offline' | 'syncing' | 'degraded';
+  weight: number;
+  tags?: string[];
+}
+/**
+ * Consistent hash
+ */
+interface ConsistentHash {
+  addNode: (node: CacheNode) => void;
+  removeNode: (nodeId: string) => void;
+  getNode: (key: string) => CacheNode | undefined;
+  getNodes: (key: string, count?: number) => CacheNode[];
+}
+/**
+ * Cache decorator options
+ */
+interface CacheDecoratorOptions {
+  key: string | ((...args: unknown[]) => string);
+  ttl?: number;
+  tags?: string[];
+  condition?: (...args: unknown[]) => boolean;
+  refresh?: boolean;
+}
+/**
+ * Cache aside pattern
+ */
+interface CacheAside<T = unknown> {
+  get: (key: string, loader: () => Promise<T>) => Promise<T>;
+  set: (key: string, value: T) => Promise<void>;
+  invalidate: (key: string) => Promise<void>;
+}
+/**
+ * Read through cache
+ */
+interface ReadThroughCache<T = unknown> {
+  get: (key: string) => Promise<T | undefined>;
+  set: (key: string, value: T) => Promise<void>;
+  invalidate: (key: string) => Promise<void>;
+  loader: (key: string) => Promise<T>;
+}
+/**
+ * Write through cache
+ */
+interface WriteThroughCache<T = unknown> {
+  set: (key: string, value: T) => Promise<void>;
+  get: (key: string) => Promise<T | undefined>;
+  delete: (key: string) => Promise<void>;
+  writer: (key: string, value: T) => Promise<void>;
+}
+/**
+ * Write behind cache
+ */
+interface WriteBehindCache<T = unknown> {
+  set: (key: string, value: T) => Promise<void>;
+  get: (key: string) => Promise<T | undefined>;
+  delete: (key: string) => Promise<void>;
+  flush: () => Promise<void>;
+  writer: (entries: CacheEntry<T>[]) => Promise<void>;
+  writeDelay: number;
+  batchSize: number;
+}
+/**
+ * Cache serializer
+ */
+interface CacheSerializer<T = unknown> {
+  serialize: (value: T) => string;
+  deserialize: (data: string) => T;
+}
+/**
+ * Cache compression options
+ */
+interface CacheCompressionOptions {
+  enabled: boolean;
+  threshold: number;
+  algorithm: 'gzip' | 'deflate' | 'brotli';
+  level?: number;
+}
+//#endregion
 //#region src/collection/index.d.ts
 /**
  * Type-level collection utilities
@@ -819,80 +1364,317 @@ type Or<A extends boolean, B extends boolean> = A extends true ? true : B;
  */
 type Assert<T, U extends T> = T extends U ? T : never;
 //#endregion
-//#region src/core/omit.d.ts
+//#region src/config/index.d.ts
 /**
- * Make all properties required except specified ones
- *
- * @example
- * ```ts
- * interface User {
- *   name?: string
- *   age?: number
- *   email?: string
- * }
- *
- * type RequiredExceptName = OmitRequired<User, 'name'>
- * // { name?: string; age: number; email: string }
- * ```
+ * Configuration Management Types
  *
- * @see PickRequired - Direct selection
- * @see OmitPartial - Opposite operation
+ * Types for configuration and environment management.
  */
-type OmitRequired<T, K extends keyof T> = { [P in K]: T[P] } & Omit<Required<T>, K>;
 /**
- * Make all properties optional except specified ones
- *
- * @example
- * ```ts
- * interface User {
- *   name: string
- *   age: number
- *   email: string
- * }
- *
- * type OptionalExceptName = OmitPartial<User, 'name'>
- * // { name: string; age?: number; email?: string }
- * ```
- *
- * @see PickPartial - Direct selection
- * @see OmitRequired - Opposite operation
+ * Configuration type
  */
-type OmitPartial<T, K extends keyof T> = { [P in K]: T[P] } & Omit<Partial<T>, K>;
-//#endregion
-//#region src/core/pick.d.ts
+type Config<T = unknown> = {
+  [key: string]: T;
+} & {
+  __config?: true;
+};
 /**
- * Make specified properties required
- *
- * @template T - Target type
- * @template K - Property keys to make required
- *
- * @example
- * ```ts
- * interface User {
- *   name?: string
- *   age?: number
- *   email: string
- * }
- *
- * type RequiredName = PickRequired<User, 'name'>
- * // { name: string; age?: number; email: string }
- * ```
- *
- * @see PickPartial - Opposite operation
- * @see OmitRequired - Inverse selection
+ * Configuration schema type
  */
-type PickRequired<T, K extends keyof T> = { [P in K]-?: T[P] } & Omit<T, K>;
+type ConfigSchema<T = unknown> = { [K in keyof T]: ConfigField<T[K]> };
 /**
- * Make specified properties optional
- *
- * @example
- * ```ts
- * interface User {
- *   name: string
- *   age: number
- *   email: string
- * }
- *
+ * Configuration field
+ */
+interface ConfigField<T = unknown> {
+  type: ConfigFieldType;
+  required?: boolean;
+  default?: T;
+  validator?: (value: T) => boolean;
+  transform?: (value: unknown) => T;
+  description?: string;
+  env?: string;
+  sensitive?: boolean;
+}
+/**
+ * Configuration field types
+ */
+type ConfigFieldType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'json';
+/**
+ * Configuration value
+ */
+type ConfigValue<T = unknown> = T | undefined;
+/**
+ * Configuration source
+ */
+type ConfigSource = 'file' | 'env' | 'remote' | 'default' | 'cli' | 'inline';
+/**
+ * Configuration source priority
+ */
+type ConfigPriority = Record<ConfigSource, number>;
+/**
+ * Environment type
+ */
+type Environment$1 = 'development' | 'staging' | 'production' | 'test' | 'local';
+/**
+ * Environment variable type
+ */
+interface EnvVar<T = unknown> {
+  value: T;
+  source: ConfigSource;
+  required: boolean;
+  default?: T;
+  description?: string;
+}
+/**
+ * Environment configuration
+ */
+interface EnvConfig<T = unknown> {
+  env: Environment$1;
+  config: T;
+  sources: Record<string, ConfigSource>;
+}
+/**
+ * Environment variable mapping
+ */
+type EnvMapping<T = unknown> = { [K in keyof T]?: string };
+/**
+ * Parse environment result
+ */
+type ParseEnvResult<T = unknown> = {
+  success: true;
+  config: T;
+} | {
+  success: false;
+  errors: ConfigError[];
+};
+/**
+ * Configuration validator
+ */
+interface ConfigValidator<T = unknown> {
+  validate: (config: T) => Promise<ConfigValidationResult<T>>;
+  schema: ConfigSchema<T>;
+}
+/**
+ * Configuration validation result
+ */
+type ConfigValidationResult<T = unknown> = {
+  success: true;
+  config: T;
+} | {
+  success: false;
+  errors: ConfigError[];
+};
+/**
+ * Configuration error
+ */
+interface ConfigError {
+  path: string;
+  message: string;
+  value?: unknown;
+  expected?: string;
+}
+/**
+ * Configuration warnings
+ */
+interface ConfigWarning {
+  path: string;
+  message: string;
+  value?: unknown;
+  suggestion?: string;
+}
+/**
+ * Secret type
+ */
+interface Secret<T = string> {
+  __secret: true;
+  value: T;
+  expiresAt?: Date;
+  rotatedAt?: Date;
+  version?: number;
+}
+/**
+ * Secret provider
+ */
+interface SecretProvider<T = string> {
+  get: (key: string) => Promise<Secret<T>>;
+  set: (key: string, value: T, options?: SecretOptions) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+  rotate: (key: string) => Promise<Secret<T>>;
+}
+/**
+ * Secret configuration
+ */
+interface SecretConfig<T = string> {
+  provider: 'env' | 'file' | 'vault' | 'aws-secrets' | 'azure-keyvault' | 'gcp-secret';
+  prefix?: string;
+  cache?: boolean;
+  cacheTTL?: number;
+  transform?: (value: string) => T;
+}
+/**
+ * Secret options
+ */
+interface SecretOptions {
+  expiresIn?: number;
+  tags?: Record<string, string>;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Feature flag type
+ */
+interface FeatureFlag<T = boolean> {
+  name: string;
+  enabled: T;
+  description?: string;
+  variants?: FeatureFlagVariant<T>[];
+  targeting?: FeatureTargeting[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+/**
+ * Feature flag variant
+ */
+interface FeatureFlagVariant<T = unknown> {
+  name: string;
+  value: T;
+  weight?: number;
+  description?: string;
+}
+/**
+ * Feature targeting
+ */
+interface FeatureTargeting {
+  attribute: string;
+  operator: TargetingOperator;
+  values: unknown[];
+  variant?: string;
+}
+/**
+ * Targeting operator
+ */
+type TargetingOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'startsWith' | 'endsWith' | 'matches' | 'in' | 'notIn';
+/**
+ * Feature flags collection
+ */
+type FeatureFlags<T = Record<string, boolean>> = { [K in keyof T]: FeatureFlag<T[K]> };
+/**
+ * Feature flag configuration
+ */
+interface FeatureFlagConfig<T = Record<string, boolean>> {
+  flags: FeatureFlags<T>;
+  defaultValue: boolean;
+  refreshInterval?: number;
+  provider?: 'local' | 'launchdarkly' | 'optimizely' | 'split' | 'custom';
+  onChange?: (flag: string, value: boolean) => void;
+}
+/**
+ * Config loader type
+ */
+interface ConfigLoader<T = unknown> {
+  load: () => Promise<T>;
+  reload: () => Promise<T>;
+  watch: (callback: (config: T) => void) => () => void;
+}
+/**
+ * Config loader options
+ */
+interface ConfigLoaderOptions {
+  sources: ConfigSource[];
+  priority?: ConfigPriority;
+  env?: Environment$1;
+  envPrefix?: string;
+  configPath?: string;
+  validate?: boolean;
+  schema?: ConfigSchema;
+}
+/**
+ * Config file format
+ */
+type ConfigFileFormat = 'json' | 'yaml' | 'toml' | 'ini' | 'env';
+/**
+ * Remote config provider
+ */
+interface RemoteConfigProvider {
+  get: (key: string) => Promise<ConfigValue>;
+  set: (key: string, value: unknown) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+  watch: (key: string, callback: (value: ConfigValue) => void) => () => void;
+}
+//#endregion
+//#region src/core/omit.d.ts
+/**
+ * Make all properties required except specified ones
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name?: string
+ *   age?: number
+ *   email?: string
+ * }
+ *
+ * type RequiredExceptName = OmitRequired<User, 'name'>
+ * // { name?: string; age: number; email: string }
+ * ```
+ *
+ * @see PickRequired - Direct selection
+ * @see OmitPartial - Opposite operation
+ */
+type OmitRequired<T, K extends keyof T> = { [P in K]: T[P] } & Omit<Required<T>, K>;
+/**
+ * Make all properties optional except specified ones
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
+ *   age: number
+ *   email: string
+ * }
+ *
+ * type OptionalExceptName = OmitPartial<User, 'name'>
+ * // { name: string; age?: number; email?: string }
+ * ```
+ *
+ * @see PickPartial - Direct selection
+ * @see OmitRequired - Opposite operation
+ */
+type OmitPartial<T, K extends keyof T> = { [P in K]: T[P] } & Omit<Partial<T>, K>;
+//#endregion
+//#region src/core/pick.d.ts
+/**
+ * Make specified properties required
+ *
+ * @template T - Target type
+ * @template K - Property keys to make required
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name?: string
+ *   age?: number
+ *   email: string
+ * }
+ *
+ * type RequiredName = PickRequired<User, 'name'>
+ * // { name: string; age?: number; email: string }
+ * ```
+ *
+ * @see PickPartial - Opposite operation
+ * @see OmitRequired - Inverse selection
+ */
+type PickRequired<T, K extends keyof T> = { [P in K]-?: T[P] } & Omit<T, K>;
+/**
+ * Make specified properties optional
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
+ *   age: number
+ *   email: string
+ * }
+ *
  * type OptionalName = PickPartial<User, 'name'>
  * // { name?: string; age: number; email: string }
  * ```
@@ -2608,6 +3390,244 @@ interface VueComponentInstance<P = unknown, S = unknown> {
   $emit: (event: string, ...args: unknown[]) => void;
 }
 //#endregion
+//#region src/event/index.d.ts
+/**
+ * Event-Driven Architecture Types
+ *
+ * Types for event-driven patterns and architectures.
+ */
+/**
+ * Event bus type
+ */
+interface EventBus<T extends Record<string, unknown> = Record<string, unknown>> {
+  publish: <E extends keyof T>(event: E, data: T[E]) => void;
+  subscribe: <E extends keyof T>(event: E, handler: (data: T[E]) => void | Promise<void>) => () => void;
+  unsubscribe: <E extends keyof T>(event: E, handler: (data: T[E]) => void | Promise<void>) => void;
+  emit: <E extends keyof T>(event: E, data: T[E]) => Promise<void>;
+}
+/**
+ * Event bus configuration
+ */
+interface EventBusConfig<T extends Record<string, unknown> = Record<string, unknown>> {
+  handlers?: { [E in keyof T]?: ((data: T[E]) => void | Promise<void>)[] };
+  middleware?: EventBusMiddleware<T>;
+  errorHandler?: (error: Error, event: keyof T, data: unknown) => void;
+}
+/**
+ * Event bus handler
+ */
+type EventBusHandler<T, E extends keyof T = keyof T> = (data: T[E]) => void | Promise<void>;
+/**
+ * Event bus middleware
+ */
+type EventBusMiddleware<T extends Record<string, unknown>> = (event: keyof T, data: T[keyof T], next: () => Promise<void>) => Promise<void>;
+/**
+ * Event store type
+ */
+interface EventStore<E = unknown> {
+  append: (event: E) => Promise<void>;
+  getEvents: (aggregateId: string) => Promise<E[]>;
+  getAllEvents: () => Promise<E[]>;
+  subscribe: (handler: (event: E) => void) => () => void;
+}
+/**
+ * Event stream type
+ */
+type EventStream<E = unknown> = AsyncIterable<E> & {
+  subscribe: (handler: (event: E) => void) => () => void;
+  pipe: <R>(transform: (event: E) => R) => EventStream<R>;
+};
+/**
+ * Event version
+ */
+type EventVersion = number;
+/**
+ * Event timestamp
+ */
+type EventTimestamp = number | string | Date;
+/**
+ * Base event type
+ */
+interface BaseEvent<T = string, P = unknown> {
+  type: T;
+  payload: P;
+  timestamp: EventTimestamp;
+  version: EventVersion;
+  aggregateId?: string;
+  correlationId?: string;
+  causationId?: string;
+}
+/**
+ * Aggregate events
+ */
+type AggregateEvents<T extends Record<string, unknown>> = { [K in keyof T]: BaseEvent<K, T[K]> }[keyof T];
+/**
+ * Command type
+ */
+interface Command<T = string, P = unknown> {
+  type: T;
+  payload: P;
+  timestamp: EventTimestamp;
+  commandId: string;
+  aggregateId?: string;
+}
+/**
+ * Command handler type
+ */
+type CommandHandler<C extends Command, R = void> = (command: C) => R | Promise<R>;
+/**
+ * Query type
+ */
+interface Query<T = string, R = unknown> {
+  type: T;
+  params: R;
+  timestamp: EventTimestamp;
+  queryId: string;
+}
+/**
+ * Query handler type
+ */
+type QueryHandler<Q extends Query, R> = (query: Q) => R | Promise<R>;
+/**
+ * Command result type
+ */
+type CommandResult<T = unknown> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: Error;
+};
+/**
+ * Query result type
+ */
+type QueryResult<T = unknown> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: Error;
+};
+/**
+ * Command bus type
+ */
+interface CommandBus {
+  dispatch: <C extends Command>(command: C) => Promise<CommandResult>;
+  register: <C extends Command>(commandType: C['type'], handler: CommandHandler<C>) => void;
+}
+/**
+ * Query bus type
+ */
+interface QueryBus {
+  execute: <Q extends Query, R>(query: Q) => Promise<QueryResult<R>>;
+  register: <Q extends Query, R>(queryType: Q['type'], handler: QueryHandler<Q, R>) => void;
+}
+/**
+ * Saga type
+ */
+interface Saga<T = unknown> {
+  sagaId: string;
+  steps: SagaStep[];
+  currentStep: number;
+  status: SagaStatus;
+  context: T;
+  compensations: SagaCompensation[];
+}
+/**
+ * Saga step type
+ */
+interface SagaStep<T = unknown> {
+  stepId: string;
+  name: string;
+  execute: (context: T) => Promise<T>;
+  compensate?: (context: T) => Promise<void>;
+  status: StepStatus;
+  error?: Error;
+}
+/**
+ * Saga compensation type
+ */
+interface SagaCompensation<T = unknown> {
+  stepId: string;
+  compensate: (context: T) => Promise<void>;
+  executed: boolean;
+}
+/**
+ * Saga result type
+ */
+type SagaResult<T = unknown> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: Error;
+  compensatedSteps: string[];
+};
+/**
+ * Saga status
+ */
+type SagaStatus = 'pending' | 'running' | 'completed' | 'failed' | 'compensating' | 'compensated';
+/**
+ * Step status
+ */
+type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'compensated';
+/**
+ * Message queue type
+ */
+interface MessageQueue<M = unknown> {
+  publish: (message: M) => Promise<void>;
+  consume: (handler: (message: M) => Promise<void>) => void;
+  ack: (messageId: string) => Promise<void>;
+  nack: (messageId: string, reason?: string) => Promise<void>;
+  close: () => Promise<void>;
+}
+/**
+ * Queue message type
+ */
+interface QueueMessage<T = unknown> {
+  id: string;
+  payload: T;
+  timestamp: EventTimestamp;
+  retryCount: number;
+  maxRetries: number;
+  delay?: number;
+  priority?: number;
+}
+/**
+ * Queue consumer type
+ */
+interface QueueConsumer<T = unknown> {
+  id: string;
+  handler: (message: QueueMessage<T>) => Promise<void>;
+  concurrency: number;
+  prefetch: number;
+}
+/**
+ * Queue producer type
+ */
+interface QueueProducer<T = unknown> {
+  publish: (payload: T, options?: PublishOptions) => Promise<string>;
+  publishBatch: (payloads: T[], options?: PublishOptions) => Promise<string[]>;
+}
+/**
+ * Publish options
+ */
+interface PublishOptions {
+  delay?: number;
+  priority?: number;
+  expiresAt?: Date | number;
+  retryCount?: number;
+  maxRetries?: number;
+}
+/**
+ * Dead letter queue type
+ */
+interface DeadLetterQueue<T = unknown> {
+  publish: (message: QueueMessage<T>, reason: string) => Promise<void>;
+  getMessages: () => Promise<QueueMessage<T>[]>;
+  retry: (messageId: string) => Promise<void>;
+}
+//#endregion
 //#region src/functions/index.d.ts
 /**
  * Function type utilities
@@ -2725,7 +3745,156 @@ type AppendParameter<T, P> = T extends ((...args: infer A) => infer R) ? (...arg
  */
 type PrependParameter<T, P> = T extends ((...args: infer A) => infer R) ? (...args: [P, ...A]) => R : never;
 //#endregion
-//#region src/guards/index.d.ts
+//#region src/graphql/index.d.ts
+/**
+ * GraphQL Integration Types
+ *
+ * Type utilities for GraphQL schemas and operations.
+ */
+/**
+ * GraphQL schema type representation
+ */
+interface GraphQLSchema<T> {
+  query: T;
+  mutation?: T;
+  subscription?: T;
+  types: Record<string, GraphQLType<any>>;
+}
+/**
+ * GraphQL scalar and object types
+ */
+type GraphQLType<T> = GraphQLScalarType | GraphQLObjectType<T> | GraphQLEnumType | GraphQLInputObjectType<T> | GraphQLUnionType | GraphQLInterfaceType<T>;
+/**
+ * GraphQL scalar types
+ */
+type GraphQLScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'DateTime' | 'JSON';
+/**
+ * GraphQL object type
+ */
+type GraphQLObjectType<T> = {
+  __typename?: string;
+} & T;
+/**
+ * GraphQL enum type
+ */
+type GraphQLEnumType = string;
+/**
+ * GraphQL input object type
+ */
+type GraphQLInputObjectType<T> = T;
+/**
+ * GraphQL union type
+ */
+type GraphQLUnionType = string;
+/**
+ * GraphQL interface type
+ */
+type GraphQLInterfaceType<T> = T;
+/**
+ * GraphQL input type
+ */
+type GraphQLInputType<T> = T extends GraphQLScalarType ? T : T extends object ? GraphQLInputObjectType<T> : never;
+/**
+ * GraphQL output type
+ */
+type GraphQLOutputType<T> = T extends GraphQLScalarType ? T : T extends object ? GraphQLObjectType<T> : never;
+/**
+ * GraphQL query type
+ */
+interface GraphQLQuery<T, V = Record<string, never>> {
+  __query?: string;
+  variables: V;
+  return: T;
+}
+/**
+ * GraphQL mutation type
+ */
+interface GraphQLMutation<T, V = Record<string, never>> {
+  __mutation?: string;
+  variables: V;
+  return: T;
+}
+/**
+ * GraphQL subscription type
+ */
+interface GraphQLSubscription<T, V = Record<string, never>> {
+  __subscription?: string;
+  variables: V;
+  return: T;
+}
+/**
+ * GraphQL fragment type
+ */
+type GraphQLFragment<T, N extends string> = {
+  __fragment: N;
+  __typename?: string;
+} & T;
+/**
+ * GraphQL resolver function type
+ */
+type GraphQLResolver<T, C = unknown, A = Record<string, unknown>> = (parent: unknown, args: A, context: C, info: GraphQLResolveInfo) => T | Promise<T>;
+/**
+ * GraphQL field resolver type
+ */
+type GraphQLFieldResolver<T, Args = Record<string, unknown>, C = unknown> = (source: unknown, args: Args, context: C, info: GraphQLResolveInfo) => T | Promise<T>;
+/**
+ * GraphQL context type
+ */
+type GraphQLContext<T = Record<string, unknown>> = T & {
+  __graphqlContext?: true;
+};
+/**
+ * GraphQL resolve info
+ */
+interface GraphQLResolveInfo {
+  fieldName: string;
+  fieldNodes: unknown[];
+  returnType: unknown;
+  parentType: unknown;
+  path: {
+    key: string | number;
+    prev: unknown;
+  };
+  schema: unknown;
+  fragments: Record<string, unknown>;
+  rootValue: unknown;
+  operation: unknown;
+  variableValues: Record<string, unknown>;
+}
+/**
+ * GraphQL selection
+ */
+type GraphQLSelection<T> = { [K in keyof T]: T[K] extends object ? GraphQLSelection<T[K]> : boolean };
+/**
+ * GraphQL selection set
+ */
+type GraphQLSelectionSet<T> = GraphQLSelection<T>;
+/**
+ * GraphQL flat selection (flattened field names)
+ */
+type GraphQLFlatSelection<T, Prefix extends string = ''> = T extends object ? { [K in keyof T]: T[K] extends object ? GraphQLFlatSelection<T[K], `${Prefix}${K & string}.`> : `${Prefix}${K & string}` }[keyof T] : never;
+/**
+ * Convert GraphQL type to TypeScript type
+ */
+type GraphQLToType<T> = T extends 'String' ? string : T extends 'Int' | 'Float' ? number : T extends 'Boolean' ? boolean : T extends 'ID' ? string : T extends 'DateTime' ? Date : T extends 'JSON' ? unknown : T;
+/**
+ * Convert TypeScript type to GraphQL type
+ */
+type TypeToGraphQL<T> = T extends string ? 'String' : T extends number ? 'Int' : T extends boolean ? 'Boolean' : T extends Date ? 'DateTime' : 'JSON';
+/**
+ * Extract field types from GraphQL object
+ */
+type GraphQLFieldTypes<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => infer R) ? R : T[K] };
+/**
+ * GraphQL argument types
+ */
+type GraphQLArgs<T> = T extends ((...args: infer A) => any) ? A[0] : never;
+/**
+ * GraphQL return type
+ */
+type GraphQLReturn<T> = T extends ((...args: any[]) => infer R) ? R : never;
+//#endregion
+//#region src/guards/index.d.ts
 /**
  * Check if type is an array
  *
@@ -2787,7 +3956,7 @@ type IsUnknown<T> = IsEqual<T, unknown> extends true ? IsAny<T> extends true ? f
  * type Method = HTTPMethod  // 'GET' | 'POST' | ...
  * ```
  */
-type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+type HTTPMethod$1 = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
 /**
  * HTTP status codes
  *
@@ -2797,15 +3966,6 @@ type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTION
  * ```
  */
 type HTTPStatus = 200 | 201 | 202 | 204 | 206 | 301 | 302 | 303 | 304 | 307 | 308 | 400 | 401 | 403 | 404 | 405 | 406 | 408 | 409 | 410 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 422 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 511;
-/**
- * HTTP status categories
- *
- * @example
- * ```ts
- * type Category = HTTPStatusCategory<404>  // 'client_error'
- * ```
- */
-type HTTPStatusCategory<S extends HTTPStatus> = S extends 200 | 201 | 202 | 204 | 206 ? 'success' : S extends 301 | 302 | 303 | 304 | 307 | 308 ? 'redirect' : S extends 400 | 401 | 403 | 404 | 405 | 406 | 408 | 409 | 410 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 422 | 425 | 426 | 428 | 429 | 431 | 451 ? 'client_error' : 'server_error';
 /**
  * HTTP headers type
  *
@@ -2832,15 +3992,6 @@ type HTTPHeaders<T extends Record<string, string> = Record<string, never>> = T &
    */
   'User-Agent'?: string;
 };
-/**
- * Content-Type values
- *
- * @example
- * ```ts
- * type JsonContentType = ContentType  // 'application/json'
- * ```
- */
-type ContentType = 'application/json' | 'application/xml' | 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/html' | 'text/plain' | 'text/css' | 'text/javascript' | 'image/jpeg' | 'image/png' | 'image/gif' | 'image/svg+xml';
 /**
  * Define a route
  *
@@ -2849,105 +4000,12 @@ type ContentType = 'application/json' | 'application/xml' | 'application/x-www-f
  * type UserRoute = Route<'/users/:id', 'GET', User>
  * ```
  */
-interface Route<Path extends string, Method extends HTTPMethod, Response, Request = never> {
+interface Route<Path extends string, Method extends HTTPMethod$1, Response, Request = never> {
   path: Path;
   method: Method;
   response: Response;
   request: Request;
 }
-/**
- * Extract path params from route path
- *
- * @example
- * ```ts
- * RouteParams<'/users/:id/posts/:postId'>  // { id: string; postId: string }
- * ```
- */
-type RouteParams<Path extends string> = ExtractParams<Path>;
-type ExtractParams<Path extends string, Acc extends Record<string, string> = Record<string, never>> = Path extends `/:${infer Param}/${infer Rest}` ? ExtractParams<Rest, Acc & { [K in Param]: string }> : Path extends `/:${infer Param}` ? Acc & { [K in Param]: string } : Acc;
-/**
- * Extract query params type
- *
- * @example
- * ```ts
- * RouteQuery<{ page: number; limit: number }>  // { page?: string; limit?: string }
- * ```
- */
-type RouteQuery<Q extends Record<string, any>> = { [K in keyof Q]?: string };
-/**
- * Router type
- *
- * @example
- * ```ts
- * type MyRouter = Router<{
- *   '/users': { GET: User[]; POST: User }
- *   '/users/:id': { GET: User; DELETE: void }
- * }>
- * ```
- */
-type Router<Routes extends Record<string, Record<HTTPMethod, {
-  response: any;
-  request?: any;
-}>>> = Routes;
-/**
- * API endpoint type
- *
- * @example
- * ```ts
- * type Endpoint = APIEndpoint<{
- *   method: 'GET'
- *   path: '/users'
- *   response: User[]
- * }>
- * ```
- */
-type APIEndpoint<Config extends {
-  method: HTTPMethod;
-  path: string;
-  response: any;
-  request?: any;
-  headers?: HTTPHeaders;
-}> = Config;
-/**
- * API request type
- *
- * @example
- * ```ts
- * type Request = APIRequest<{ body: CreateUserInput }>
- * ```
- */
-type APIRequest<T extends {
-  body?: any;
-  headers?: HTTPHeaders;
-  params?: Record<string, string>;
-  query?: Record<string, string>;
-}> = T;
-/**
- * API response type
- *
- * @example
- * ```ts
- * type Response = APIResponse<{ data: User; status: 200 }>
- * ```
- */
-type APIResponse<T extends {
-  data: any;
-  status?: HTTPStatus;
-  headers?: HTTPHeaders;
-}> = T;
-/**
- * API error type
- *
- * @example
- * ```ts
- * type Error = APIError<{ message: string; code: 'INVALID_INPUT' }>
- * ```
- */
-type APIError<T extends {
-  message: string;
-  code?: string;
-  status?: HTTPStatus;
-}> = T;
 /**
  * Middleware function type
  *
@@ -2967,7 +4025,7 @@ type Middleware<C extends Record<string, any> = object> = (ctx: Context<C>, next
  */
 interface Context<C extends Record<string, any> = object> {
   request: {
-    method: HTTPMethod;
+    method: HTTPMethod$1;
     path: string;
     headers: HTTPHeaders;
     body?: unknown;
@@ -2981,86 +4039,6 @@ interface Context<C extends Record<string, any> = object> {
   };
   state: C;
 }
-/**
- * Middleware chain type
- *
- * @example
- * ```ts
- * type Chain = MiddlewareChain<[AuthMiddleware, LoggingMiddleware]>
- * ```
- */
-type MiddlewareChain<M extends Middleware<any>[] = []> = M;
-/**
- * Compose middleware chain
- *
- * @example
- * ```ts
- * type Composed = ComposeMiddleware<[AuthMiddleware]>
- * ```
- */
-type ComposeMiddleware<M extends Middleware<any>[] = []> = (ctx: Context<ExtractContextFromMiddleware<M>>) => Promise<void>;
-type ExtractContextFromMiddleware<M extends Middleware<any>[] = []> = M extends [infer _First extends Middleware<infer C>, ...infer Rest extends Middleware<any>[]] ? C & ExtractContextFromMiddleware<Rest> : Record<string, never>;
-/**
- * Build request options type
- *
- * @example
- * ```ts
- * type Options = RequestOptions<{ timeout: 5000 }>
- * ```
- */
-type RequestOptions<T extends {
-  timeout?: number;
-  retries?: number;
-  headers?: HTTPHeaders;
-}> = T;
-/**
- * Parse response type
- *
- * @example
- * ```ts
- * type Data = ParseResponse<{ data: User }>
- * ```
- */
-type ParseResponse<R extends {
-  data?: any;
-}> = R['data'];
-/**
- * REST collection endpoints
- *
- * @example
- * ```ts
- * type UserEndpoints = RESTCollection<User, CreateUserInput>
- * ```
- */
-interface RESTCollection<Resource, CreateInput = Partial<Resource>, UpdateInput = Partial<Resource>> {
-  list: Route<'/', 'GET', Resource[]>;
-  create: Route<'/', 'POST', Resource, CreateInput>;
-  show: Route<'/:id', 'GET', Resource>;
-  update: Route<'/:id', 'PUT', Resource, UpdateInput>;
-  delete: Route<'/:id', 'DELETE', void>;
-}
-/**
- * REST resource endpoints
- *
- * @example
- * ```ts
- * type UserResource = RESTResource<User>
- * ```
- */
-interface RESTResource<Resource> {
-  show: Route<'/:id', 'GET', Resource>;
-  update: Route<'/:id', 'PUT', Resource>;
-  delete: Route<'/:id', 'DELETE', void>;
-}
-/**
- * CRUD operation types
- *
- * @example
- * ```ts
- * type Op = CRUDOperation  // 'create' | 'read' | ...
- * ```
- */
-type CRUDOperation = 'create' | 'read' | 'update' | 'delete';
 //#endregion
 //#region src/infer/index.d.ts
 /**
@@ -3620,224 +4598,857 @@ type KeysByValueType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyo
  */
 type FilterKeys<T, P extends string> = keyof T extends infer K ? K extends P ? K : never : never;
 //#endregion
-//#region src/numeric/index.d.ts
+//#region src/logging/index.d.ts
 /**
- * Numeric type operations for compile-time arithmetic
+ * Logging & Observability Types
+ *
+ * Types for logging and monitoring systems.
  */
-type NumberToArray<N extends number, Acc extends 0[] = []> = Acc['length'] extends N ? Acc : NumberToArray<N, [...Acc, 0]>;
 /**
- * Increment number type
- *
- * @example
- * ```ts
- * Inc<5>   // 6
- * Inc<0>   // 1
- * ```
+ * Logger type
  */
-type Inc<N extends number> = [...NumberToArray<N>, 0]['length'];
+interface Logger<T = Record<string, unknown>> {
+  trace: (message: string, context?: T) => void;
+  debug: (message: string, context?: T) => void;
+  info: (message: string, context?: T) => void;
+  warn: (message: string, context?: T) => void;
+  error: (message: string, error?: Error, context?: T) => void;
+  fatal: (message: string, error?: Error, context?: T) => void;
+  child: (context: Partial<T>) => Logger<T>;
+}
 /**
- * Decrement number type
- *
- * @example
- * ```ts
- * Dec<5>   // 4
- * Dec<1>   // 0
- * Dec<0>   // 0 (clamped)
- * ```
+ * Log level
  */
-type Dec<N extends number> = N extends 0 ? 0 : NumberToArray<N> extends [0, ...infer Rest] ? Rest['length'] : 0;
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 /**
- * Add two number types
- *
- * @example
- * ```ts
- * Add<3, 4>   // 7
- * Add<0, 5>   // 5
- * ```
+ * Log entry
  */
-type Add<A extends number, B extends number> = [...NumberToArray<A>, ...NumberToArray<B>]['length'];
+interface LogEntry<T = Record<string, unknown>> {
+  level: LogLevel;
+  message: string;
+  timestamp: Date;
+  context?: T;
+  error?: {
+    message: string;
+    stack?: string;
+    name: string;
+  };
+  traceId?: string;
+  spanId?: string;
+  service?: string;
+  version?: string;
+  hostname?: string;
+}
 /**
- * Subtract two number types
- *
- * @example
- * ```ts
- * Subtract<10, 3>  // 7
- * Subtract<5, 10>  // 0 (clamped)
- * ```
+ * Log context
  */
-type Subtract<A extends number, B extends number> = NumberToArray<B> extends [...number[], ...NumberToArray<A>] ? 0 : NumberToArray<A> extends [...NumberToArray<B>, ...infer Rest] ? Rest['length'] : 0;
+type LogContext<T = Record<string, unknown>> = T & {
+  traceId?: string;
+  spanId?: string;
+  userId?: string;
+  requestId?: string;
+  sessionId?: string;
+};
 /**
- * Range of numbers from start to end (inclusive)
- * Note: Limited to small ranges due to TypeScript recursion limits
- *
- * @example
- * ```ts
- * Range<1, 5>  // 1 | 2 | 3 | 4 | 5
- * Range<0, 3>  // 0 | 1 | 2 | 3
- * ```
+ * Logger configuration
  */
-type Range<From extends number, To extends number, Acc extends number = From> = From extends To ? Acc : From extends To ? Acc : never;
+interface LoggerConfig<T = Record<string, unknown>> {
+  level: LogLevel;
+  format: 'json' | 'pretty' | 'simple';
+  transports: LogTransport[];
+  context?: T;
+  redact?: string[];
+}
 /**
- * Check if A is greater than B
- *
- * @example
- * ```ts
- * GreaterThan<5, 3>  // true
- * GreaterThan<3, 5>  // false
- * ```
+ * Log transport
  */
-type GreaterThan<A extends number, B extends number> = Subtract<A, B> extends 0 ? false : true;
+interface LogTransport {
+  type: 'console' | 'file' | 'http' | 'stream';
+  options?: Record<string, unknown>;
+}
 /**
- * Check if A is less than B
- *
- * @example
- * ```ts
- * LessThan<3, 5>  // true
- * LessThan<5, 3>  // false
- * ```
+ * Metric type
  */
-type LessThan<A extends number, B extends number> = Subtract<B, A> extends 0 ? false : true;
+interface Metric<T = number> {
+  name: string;
+  value: T;
+  timestamp: Date;
+  labels?: Record<string, string>;
+  help?: string;
+  type: MetricType;
+}
 /**
- * Maximum of two numbers
- *
- * @example
- * ```ts
- * Max<3, 5>  // 5
- * Max<5, 3>  // 5
- * ```
+ * Metric type enumeration
  */
-type Max<A extends number, B extends number> = GreaterThan<A, B> extends true ? A : B;
+type MetricType = 'counter' | 'gauge' | 'histogram' | 'summary';
 /**
- * Minimum of two numbers
- *
- * @example
- * ```ts
- * Min<3, 5>  // 3
- * Min<5, 3>  // 3
- * ```
+ * Counter metric
  */
-type Min<A extends number, B extends number> = LessThan<A, B> extends true ? A : B;
+interface Counter<T = number> {
+  inc: (value?: T) => void;
+  dec: (value?: T) => void;
+  reset: () => void;
+  getValue: () => T;
+}
+/**
+ * Gauge metric
+ */
+interface Gauge<T = number> {
+  set: (value: T) => void;
+  inc: (value?: T) => void;
+  dec: (value?: T) => void;
+  reset: () => void;
+  getValue: () => T | undefined;
+}
+/**
+ * Histogram metric
+ */
+interface Histogram {
+  observe: (value: number) => void;
+  reset: () => void;
+  getBuckets: () => Record<string, number>;
+  getSum: () => number;
+  getCount: () => number;
+}
+/**
+ * Summary metric
+ */
+interface Summary {
+  observe: (value: number) => void;
+  reset: () => void;
+  getQuantiles: () => Record<string, number>;
+  getSum: () => number;
+  getCount: () => number;
+}
+/**
+ * Metrics registry
+ */
+interface MetricsRegistry {
+  register: <T extends Metric>(metric: T) => void;
+  unregister: (name: string) => void;
+  getMetric: (name: string) => Metric | undefined;
+  getAllMetrics: () => Metric[];
+  export: () => string;
+}
+/**
+ * Span type
+ */
+interface Span {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  name: string;
+  kind: SpanKind;
+  startTime: Date;
+  endTime?: Date;
+  status: SpanStatus;
+  attributes: Record<string, unknown>;
+  events: SpanEvent[];
+}
+/**
+ * Span kind
+ */
+type SpanKind = 'client' | 'server' | 'producer' | 'consumer' | 'internal';
+/**
+ * Span status
+ */
+type SpanStatus = 'unset' | 'ok' | 'error';
+/**
+ * Span event
+ */
+interface SpanEvent {
+  name: string;
+  timestamp: Date;
+  attributes?: Record<string, unknown>;
+}
+/**
+ * Trace type
+ */
+interface Trace<T = unknown> {
+  traceId: string;
+  spans: Span[];
+  rootSpan: Span;
+  startTime: Date;
+  endTime?: Date;
+  duration?: number;
+  status: TraceStatus;
+  metadata?: T;
+}
+/**
+ * Trace status
+ */
+type TraceStatus = 'in-progress' | 'completed' | 'failed';
+/**
+ * Trace context
+ */
+interface TraceContext {
+  traceId: string;
+  spanId: string;
+  traceFlags: number;
+  traceState?: string;
+}
+/**
+ * Tracer type
+ */
+interface Tracer {
+  startSpan: (name: string, options?: SpanOptions) => Span;
+  getCurrentSpan: () => Span | undefined;
+  setCurrentSpan: (span: Span) => void;
+  withSpan: <T>(span: Span, fn: () => T) => T;
+}
+/**
+ * Span options
+ */
+interface SpanOptions {
+  kind?: SpanKind;
+  attributes?: Record<string, unknown>;
+  parent?: Span;
+  links?: SpanLink[];
+  startTime?: Date;
+}
+/**
+ * Span link
+ */
+interface SpanLink {
+  traceId: string;
+  spanId: string;
+  attributes?: Record<string, unknown>;
+}
+/**
+ * Monitor type
+ */
+interface Monitor {
+  name: string;
+  check: () => Promise<MonitorResult>;
+  interval: number;
+  timeout: number;
+  status: MonitorStatus;
+  lastCheck?: Date;
+}
+/**
+ * Monitor status
+ */
+type MonitorStatus = 'healthy' | 'unhealthy' | 'degraded' | 'unknown';
+/**
+ * Monitor result
+ */
+interface MonitorResult<T = unknown> {
+  status: MonitorStatus;
+  message: string;
+  timestamp: Date;
+  duration: number;
+  details?: T;
+}
+/**
+ * Alert type
+ */
+interface Alert<T = unknown> {
+  id: string;
+  name: string;
+  severity: AlertSeverity;
+  status: AlertStatus;
+  message: string;
+  timestamp: Date;
+  resolvedAt?: Date;
+  labels: Record<string, string>;
+  annotations: Record<string, string>;
+  details?: T;
+}
+/**
+ * Alert severity
+ */
+type AlertSeverity = 'info' | 'warning' | 'critical' | 'error';
+/**
+ * Alert status
+ */
+type AlertStatus = 'firing' | 'resolved' | 'silenced' | 'inhibited';
+/**
+ * Alert rule
+ */
+interface AlertRule<T = unknown> {
+  name: string;
+  expression: string;
+  duration: number;
+  severity: AlertSeverity;
+  labels: Record<string, string>;
+  annotations: Record<string, string>;
+  for?: number;
+  handler?: (alert: Alert<T>) => void;
+}
+/**
+ * Alert configuration
+ */
+interface AlertConfig {
+  rules: AlertRule[];
+  receivers: AlertReceiver[];
+  route: AlertRoute;
+  inhibitRules?: InhibitRule[];
+}
+/**
+ * Alert receiver
+ */
+interface AlertReceiver {
+  name: string;
+  type: 'email' | 'slack' | 'pagerduty' | 'webhook' | 'opsgenie' | 'victorops';
+  config: Record<string, unknown>;
+}
+/**
+ * Alert route
+ */
+interface AlertRoute {
+  receiver: string;
+  match?: Record<string, string>;
+  continue?: boolean;
+  routes?: AlertRoute[];
+}
+/**
+ * Inhibit rule
+ */
+interface InhibitRule {
+  sourceMatch: Record<string, string>;
+  targetMatch: Record<string, string>;
+  equal: string[];
+}
+/**
+ * Health indicator
+ */
+interface HealthIndicator<T = unknown> {
+  name: string;
+  check: () => Promise<HealthCheckResult<T>>;
+  critical: boolean;
+}
+/**
+ * Health check result
+ */
+interface HealthCheckResult<T = unknown> {
+  status: 'healthy' | 'unhealthy' | 'degraded';
+  message?: string;
+  timestamp: Date;
+  duration?: number;
+  details?: T;
+}
+/**
+ * Liveness check
+ */
+interface LivenessCheck {
+  check: () => Promise<boolean>;
+  timeout: number;
+}
+/**
+ * Readiness check
+ */
+interface ReadinessCheck {
+  check: () => Promise<boolean>;
+  timeout: number;
+  dependencies: string[];
+}
 //#endregion
-//#region src/object/index.d.ts
+//#region src/microservice/index.d.ts
 /**
- * Advanced object type operations
+ * Microservices Architecture Types
  *
- * This module provides advanced object manipulation types:
- * - Object transformations: ObjectMap, ObjectFilter, ObjectPickByType
- * - Object merging: DeepMerge, DeepAssign, DeepDefaults
- * - Object validation: HasProperty, HasProperties, HasMethod
+ * Types for microservices patterns and communication.
  */
 /**
- * Map over object values with transformation function
+ * Microservice type
  */
-type ObjectMap<T extends Record<string, any>, F> = { [K in keyof T]: F extends ((x: T[K]) => infer R) ? R : never };
+interface Microservice<T = unknown> {
+  name: string;
+  version: string;
+  config: ServiceConfig<T>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  health: () => Promise<HealthReport>;
+}
 /**
- * Filter object properties by predicate
+ * Service configuration
  */
-type ObjectFilter<T extends Record<string, any>, P> = { [K in keyof T as T[K] extends P ? K : never]: T[K] };
+interface ServiceConfig<T = unknown> {
+  name: string;
+  version: string;
+  port: number;
+  host: string;
+  env: Environment;
+  options?: T;
+  dependencies?: string[];
+  timeouts?: {
+    start?: number;
+    stop?: number;
+    request?: number;
+  };
+}
 /**
- * Pick properties by value type
+ * Service registry type
  */
-type ObjectPickByType<T extends Record<string, any>, U> = { [K in keyof T as T[K] extends U ? K : never]: T[K] };
+interface ServiceRegistry<S = unknown> {
+  register: (service: S) => Promise<void>;
+  deregister: (serviceName: string) => Promise<void>;
+  getService: (serviceName: string) => Promise<ServiceInstance | undefined>;
+  getAllServices: () => Promise<ServiceInstance[]>;
+  heartbeat: (serviceName: string, instanceId: string) => Promise<void>;
+}
 /**
- * Omit properties by value type
+ * Service discovery type
  */
-type ObjectOmitByType<T extends Record<string, any>, U> = { [K in keyof T as T[K] extends U ? never : K]: T[K] };
+interface ServiceDiscovery {
+  discover: (serviceName: string) => Promise<ServiceInstance[]>;
+  watch: (serviceName: string, callback: (instances: ServiceInstance[]) => void) => () => void;
+  getInstance: (serviceName: string, strategy?: LoadBalancerStrategy) => Promise<ServiceInstance | undefined>;
+}
 /**
- * Invert object (swap keys and values)
+ * Service client type
  */
-type ObjectInvert<T extends Record<string, string | number>> = { [K in T[keyof T]]: { [P in keyof T]: T[P] extends K ? P : never }[keyof T] };
+interface ServiceClient<T = unknown> {
+  call: <R>(method: string, params: T) => Promise<ServiceResponse<R>>;
+  callStream: <R>(method: string, params: T) => AsyncIterable<R>;
+  close: () => Promise<void>;
+}
 /**
- * Get object entries as tuple union
+ * Service request type
  */
-type ObjectEntries<T extends Record<string, any>> = { [K in keyof T]: [K, T[K]] }[keyof T];
+interface ServiceRequest<T = unknown> {
+  id: string;
+  service: string;
+  method: string;
+  params: T;
+  timestamp: number;
+  timeout?: number;
+  headers?: Record<string, string>;
+  traceId?: string;
+}
 /**
- * Deep merge two objects (B takes precedence)
+ * Service response type
  */
-type DeepMerge<A, B> = A extends object ? B extends object ? { [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? DeepMerge<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never } : B : B;
+type ServiceResponse<T = unknown> = {
+  success: true;
+  data: T;
+  timestamp: number;
+  duration: number;
+} | ServiceError;
 /**
- * Merge multiple objects (right to left precedence)
+ * Service error type
  */
-type MergeAllObjects<T extends object[], Acc extends object = object> = T extends [infer First extends object, ...infer Rest extends object[]] ? MergeAllObjects<Rest, Acc & First> : Acc;
+interface ServiceError {
+  success: false;
+  error: {
+    code: string;
+    message: string;
+    details?: unknown;
+    stack?: string;
+  };
+  timestamp: number;
+  duration: number;
+}
 /**
- * Check if object has a property
+ * API Gateway type
  */
-type HasProperty<T, K extends PropertyKey> = K extends keyof T ? true : false;
+interface APIGateway {
+  routes: GatewayRoute[];
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  addRoute: (route: GatewayRoute) => void;
+  removeRoute: (path: string) => void;
+}
 /**
- * Check if object has multiple properties
+ * Gateway route type
  */
-type HasProperties<T, K extends PropertyKey> = K extends keyof T ? true : false;
+interface GatewayRoute {
+  path: string;
+  method: HTTPMethod | HTTPMethod[];
+  service: string;
+  servicePath?: string;
+  timeout?: number;
+  retryPolicy?: RetryPolicy;
+  rateLimit?: RateLimit;
+  auth?: AuthConfig;
+  cors?: CORSConfig;
+}
 /**
- * Check if object has a method
+ * Gateway configuration
  */
-type HasMethod<T, K extends keyof T> = T[K] extends ((...args: any[]) => any) ? true : false;
+interface GatewayConfig {
+  port: number;
+  host: string;
+  routes: GatewayRoute[];
+  middleware?: GatewayMiddleware[];
+  errorHandler?: (error: Error) => ServiceResponse;
+}
 /**
- * Check if object is empty
+ * Gateway middleware
  */
-type IsEmptyObject<T> = keyof T extends never ? true : false;
+type GatewayMiddleware = (request: ServiceRequest, next: () => Promise<ServiceResponse>) => Promise<ServiceResponse>;
 /**
- * Get keys of specific type
+ * Retry policy
  */
-type KeysOfType<T extends Record<string, any>, U> = { [K in keyof T]: T[K] extends U ? K : never }[keyof T];
+interface RetryPolicy {
+  maxRetries: number;
+  backoff: 'fixed' | 'exponential' | 'linear';
+  initialDelay: number;
+  maxDelay: number;
+  retryableErrors?: string[];
+}
 /**
- * Get value at path (with default)
+ * Rate limit configuration
  */
-type ObjectPath<T, P extends string, Default = never> = P extends `${infer First}.${infer Rest}` ? First extends keyof T ? ObjectPath<T[First], Rest, Default> : Default : P extends keyof T ? T[P] : Default;
+interface RateLimit {
+  windowMs: number;
+  max: number;
+  keyGenerator?: (request: ServiceRequest) => string;
+  skip?: (request: ServiceRequest) => boolean;
+}
 /**
- * Check if path exists
+ * Auth configuration
  */
-type PathExists<T, P extends string> = P extends `${infer First}.${infer Rest}` ? First extends keyof T ? PathExists<T[First], Rest> : false : P extends keyof T ? true : false;
+interface AuthConfig {
+  type: 'jwt' | 'apikey' | 'oauth2' | 'basic';
+  required: boolean;
+  validate: (token: string) => Promise<boolean>;
+}
+/**
+ * CORS configuration
+ */
+interface CORSConfig {
+  origin: string | string[] | boolean;
+  methods?: HTTPMethod[];
+  allowedHeaders?: string[];
+  exposedHeaders?: string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+/**
+ * Circuit breaker type
+ */
+interface CircuitBreaker<T = unknown> {
+  execute: (fn: () => Promise<T>) => Promise<T>;
+  getState: () => CircuitBreakerState;
+  getStats: () => CircuitBreakerStats;
+  reset: () => void;
+  open: () => void;
+  close: () => void;
+}
+/**
+ * Circuit breaker state
+ */
+type CircuitBreakerState = 'closed' | 'open' | 'half-open';
+/**
+ * Circuit breaker configuration
+ */
+interface CircuitBreakerConfig {
+  failureThreshold: number;
+  successThreshold: number;
+  timeout: number;
+  resetTimeout: number;
+  volumeThreshold?: number;
+  onStateChange?: (oldState: CircuitBreakerState, newState: CircuitBreakerState) => void;
+  onFailure?: (error: Error) => void;
+  onSuccess?: () => void;
+}
+/**
+ * Circuit breaker stats
+ */
+interface CircuitBreakerStats {
+  state: CircuitBreakerState;
+  failures: number;
+  successes: number;
+  rejects: number;
+  timeouts: number;
+  lastFailure?: Date;
+  lastSuccess?: Date;
+}
+/**
+ * Load balancer type
+ */
+interface LoadBalancer {
+  select: (instances: ServiceInstance[]) => ServiceInstance | undefined;
+  getStrategy: () => LoadBalancerStrategy;
+  setStrategy: (strategy: LoadBalancerStrategy) => void;
+}
+/**
+ * Load balancer strategy
+ */
+type LoadBalancerStrategy = 'round-robin' | 'least-connections' | 'random' | 'weighted' | 'ip-hash';
+/**
+ * Service instance type
+ */
+interface ServiceInstance {
+  id: string;
+  name: string;
+  host: string;
+  port: number;
+  version: string;
+  status: InstanceStatus;
+  metadata?: Record<string, unknown>;
+  weight?: number;
+  connections?: number;
+  lastHeartbeat?: Date;
+}
+/**
+ * Instance status
+ */
+type InstanceStatus = 'healthy' | 'unhealthy' | 'draining' | 'starting' | 'stopping';
+/**
+ * Health check type
+ */
+interface HealthCheck {
+  name: string;
+  check: () => Promise<HealthCheckResult$1>;
+  interval?: number;
+  timeout?: number;
+  critical?: boolean;
+}
+/**
+ * Health status
+ */
+type HealthStatus = 'healthy' | 'unhealthy' | 'degraded';
+/**
+ * Health report type
+ */
+interface HealthReport<T = unknown> {
+  status: HealthStatus;
+  timestamp: Date;
+  service: string;
+  version: string;
+  uptime: number;
+  checks: Record<string, HealthCheckResult$1>;
+  details?: T;
+}
+/**
+ * Health check result
+ */
+interface HealthCheckResult$1 {
+  status: HealthStatus;
+  message?: string;
+  timestamp: Date;
+  duration?: number;
+  details?: unknown;
+}
+/**
+ * Environment type
+ */
+type Environment = 'development' | 'staging' | 'production' | 'test';
+/**
+ * HTTP method
+ */
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
 //#endregion
-//#region src/parsers/index.d.ts
+//#region src/numeric/index.d.ts
 /**
- * Type-level parsing utilities
- *
- * This module provides type-level parsers for:
- * - JSON: ParseJSON, StringifyJSON, IsValidJSON
- * - URL: ParseURL, QueryParams, PathParams
- * - CSV: ParseCSV
+ * Numeric type operations for compile-time arithmetic
  */
+type NumberToArray<N extends number, Acc extends 0[] = []> = Acc['length'] extends N ? Acc : NumberToArray<N, [...Acc, 0]>;
 /**
- * Check if string is valid JSON
+ * Increment number type
  *
  * @example
  * ```ts
- * IsValidJSON<'{"name": "test"}'>  // true
+ * Inc<5>   // 6
+ * Inc<0>   // 1
  * ```
  */
-type IsValidJSON<S extends string> = S extends `{}` ? true : S extends `[]` ? true : S extends `"${string}"` ? true : S extends `${number}` ? true : S extends 'true' | 'false' | 'null' ? true : S extends `{${string}}` ? true : S extends `[${string}]` ? true : false;
+type Inc<N extends number> = [...NumberToArray<N>, 0]['length'];
 /**
- * Parse JSON string to type (limited support)
+ * Decrement number type
  *
  * @example
  * ```ts
- * ParseJSON<'"hello"'>  // 'hello'
- * ParseJSON<'123'>  // 123
+ * Dec<5>   // 4
+ * Dec<1>   // 0
+ * Dec<0>   // 0 (clamped)
  * ```
  */
-type ParseJSON<S extends string> = S extends `"${infer Content}"` ? Content : S extends `${infer N extends number}` ? N : S extends 'true' ? true : S extends 'false' ? false : S extends 'null' ? null : S extends `{}` ? Record<string, never> : S extends `[]` ? [] : S extends `{${string}}` ? Record<string, unknown> : S extends `[${string}]` ? unknown[] : never;
+type Dec<N extends number> = N extends 0 ? 0 : NumberToArray<N> extends [0, ...infer Rest] ? Rest['length'] : 0;
 /**
- * Stringify type to JSON string representation
+ * Add two number types
  *
  * @example
  * ```ts
- * StringifyJSON<'hello'>  // '"hello"'
- * StringifyJSON<123>  // '123'
+ * Add<3, 4>   // 7
+ * Add<0, 5>   // 5
  * ```
  */
-type StringifyJSON<T> = T extends string ? `"${T}"` : T extends number ? `${T}` : T extends boolean ? `${T}` : T extends null ? 'null' : T extends undefined ? 'null' : T extends unknown[] ? StringifyArray<T> : T extends object ? '{}' : never;
-type StringifyArray<T extends unknown[]> = T extends [] ? '[]' : T extends [infer First, ...infer Rest] ? Rest extends [] ? `[${StringifyJSON<First>}]` : `[${StringifyJSON<First>}, ${StringifyArray<Rest>}]` : never;
+type Add<A extends number, B extends number> = [...NumberToArray<A>, ...NumberToArray<B>]['length'];
 /**
- * Parse URL string into components
+ * Subtract two number types
  *
  * @example
  * ```ts
- * ParseURL<'https://example.com/path?q=1'>
- * // { protocol: 'https'; host: 'example.com'; pathname: '/path'; search: '?q=1' }
+ * Subtract<10, 3>  // 7
+ * Subtract<5, 10>  // 0 (clamped)
  * ```
  */
-type ParseURL<S extends string> = S extends `${infer Protocol}://${infer Rest}` ? ParseURLRest<Protocol, Rest> : never;
-type ParseURLRest<Protocol extends string, Rest extends string> = Rest extends `${infer Host}/${infer Path}` ? ParseURLPath<Protocol, Host, Path> : Rest extends `${infer Host}?${infer Search}` ? {
+type Subtract<A extends number, B extends number> = NumberToArray<B> extends [...number[], ...NumberToArray<A>] ? 0 : NumberToArray<A> extends [...NumberToArray<B>, ...infer Rest] ? Rest['length'] : 0;
+/**
+ * Range of numbers from start to end (inclusive)
+ * Note: Limited to small ranges due to TypeScript recursion limits
+ *
+ * @example
+ * ```ts
+ * Range<1, 5>  // 1 | 2 | 3 | 4 | 5
+ * Range<0, 3>  // 0 | 1 | 2 | 3
+ * ```
+ */
+type Range<From extends number, To extends number, Acc extends number = From> = From extends To ? Acc : From extends To ? Acc : never;
+/**
+ * Check if A is greater than B
+ *
+ * @example
+ * ```ts
+ * GreaterThan<5, 3>  // true
+ * GreaterThan<3, 5>  // false
+ * ```
+ */
+type GreaterThan<A extends number, B extends number> = Subtract<A, B> extends 0 ? false : true;
+/**
+ * Check if A is less than B
+ *
+ * @example
+ * ```ts
+ * LessThan<3, 5>  // true
+ * LessThan<5, 3>  // false
+ * ```
+ */
+type LessThan<A extends number, B extends number> = Subtract<B, A> extends 0 ? false : true;
+/**
+ * Maximum of two numbers
+ *
+ * @example
+ * ```ts
+ * Max<3, 5>  // 5
+ * Max<5, 3>  // 5
+ * ```
+ */
+type Max<A extends number, B extends number> = GreaterThan<A, B> extends true ? A : B;
+/**
+ * Minimum of two numbers
+ *
+ * @example
+ * ```ts
+ * Min<3, 5>  // 3
+ * Min<5, 3>  // 3
+ * ```
+ */
+type Min<A extends number, B extends number> = LessThan<A, B> extends true ? A : B;
+//#endregion
+//#region src/object/index.d.ts
+/**
+ * Advanced object type operations
+ *
+ * This module provides advanced object manipulation types:
+ * - Object transformations: ObjectMap, ObjectFilter, ObjectPickByType
+ * - Object merging: DeepMerge, DeepAssign, DeepDefaults
+ * - Object validation: HasProperty, HasProperties, HasMethod
+ */
+/**
+ * Map over object values with transformation function
+ */
+type ObjectMap<T extends Record<string, any>, F> = { [K in keyof T]: F extends ((x: T[K]) => infer R) ? R : never };
+/**
+ * Filter object properties by predicate
+ */
+type ObjectFilter<T extends Record<string, any>, P> = { [K in keyof T as T[K] extends P ? K : never]: T[K] };
+/**
+ * Pick properties by value type
+ */
+type ObjectPickByType<T extends Record<string, any>, U> = { [K in keyof T as T[K] extends U ? K : never]: T[K] };
+/**
+ * Omit properties by value type
+ */
+type ObjectOmitByType<T extends Record<string, any>, U> = { [K in keyof T as T[K] extends U ? never : K]: T[K] };
+/**
+ * Invert object (swap keys and values)
+ */
+type ObjectInvert<T extends Record<string, string | number>> = { [K in T[keyof T]]: { [P in keyof T]: T[P] extends K ? P : never }[keyof T] };
+/**
+ * Get object entries as tuple union
+ */
+type ObjectEntries<T extends Record<string, any>> = { [K in keyof T]: [K, T[K]] }[keyof T];
+/**
+ * Deep merge two objects (B takes precedence)
+ */
+type DeepMerge<A, B> = A extends object ? B extends object ? { [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? DeepMerge<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never } : B : B;
+/**
+ * Merge multiple objects (right to left precedence)
+ */
+type MergeAllObjects<T extends object[], Acc extends object = object> = T extends [infer First extends object, ...infer Rest extends object[]] ? MergeAllObjects<Rest, Acc & First> : Acc;
+/**
+ * Check if object has a property
+ */
+type HasProperty<T, K extends PropertyKey> = K extends keyof T ? true : false;
+/**
+ * Check if object has multiple properties
+ */
+type HasProperties<T, K extends PropertyKey> = K extends keyof T ? true : false;
+/**
+ * Check if object has a method
+ */
+type HasMethod<T, K extends keyof T> = T[K] extends ((...args: any[]) => any) ? true : false;
+/**
+ * Check if object is empty
+ */
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+/**
+ * Get keys of specific type
+ */
+type KeysOfType<T extends Record<string, any>, U> = { [K in keyof T]: T[K] extends U ? K : never }[keyof T];
+/**
+ * Get value at path (with default)
+ */
+type ObjectPath<T, P extends string, Default = never> = P extends `${infer First}.${infer Rest}` ? First extends keyof T ? ObjectPath<T[First], Rest, Default> : Default : P extends keyof T ? T[P] : Default;
+/**
+ * Check if path exists
+ */
+type PathExists<T, P extends string> = P extends `${infer First}.${infer Rest}` ? First extends keyof T ? PathExists<T[First], Rest> : false : P extends keyof T ? true : false;
+//#endregion
+//#region src/parsers/index.d.ts
+/**
+ * Type-level parsing utilities
+ *
+ * This module provides type-level parsers for:
+ * - JSON: ParseJSON, StringifyJSON, IsValidJSON
+ * - URL: ParseURL, QueryParams, PathParams
+ * - CSV: ParseCSV
+ */
+/**
+ * Check if string is valid JSON
+ *
+ * @example
+ * ```ts
+ * IsValidJSON<'{"name": "test"}'>  // true
+ * ```
+ */
+type IsValidJSON<S extends string> = S extends `{}` ? true : S extends `[]` ? true : S extends `"${string}"` ? true : S extends `${number}` ? true : S extends 'true' | 'false' | 'null' ? true : S extends `{${string}}` ? true : S extends `[${string}]` ? true : false;
+/**
+ * Parse JSON string to type (limited support)
+ *
+ * @example
+ * ```ts
+ * ParseJSON<'"hello"'>  // 'hello'
+ * ParseJSON<'123'>  // 123
+ * ```
+ */
+type ParseJSON<S extends string> = S extends `"${infer Content}"` ? Content : S extends `${infer N extends number}` ? N : S extends 'true' ? true : S extends 'false' ? false : S extends 'null' ? null : S extends `{}` ? Record<string, never> : S extends `[]` ? [] : S extends `{${string}}` ? Record<string, unknown> : S extends `[${string}]` ? unknown[] : never;
+/**
+ * Stringify type to JSON string representation
+ *
+ * @example
+ * ```ts
+ * StringifyJSON<'hello'>  // '"hello"'
+ * StringifyJSON<123>  // '123'
+ * ```
+ */
+type StringifyJSON<T> = T extends string ? `"${T}"` : T extends number ? `${T}` : T extends boolean ? `${T}` : T extends null ? 'null' : T extends undefined ? 'null' : T extends unknown[] ? StringifyArray<T> : T extends object ? '{}' : never;
+type StringifyArray<T extends unknown[]> = T extends [] ? '[]' : T extends [infer First, ...infer Rest] ? Rest extends [] ? `[${StringifyJSON<First>}]` : `[${StringifyJSON<First>}, ${StringifyArray<Rest>}]` : never;
+/**
+ * Parse URL string into components
+ *
+ * @example
+ * ```ts
+ * ParseURL<'https://example.com/path?q=1'>
+ * // { protocol: 'https'; host: 'example.com'; pathname: '/path'; search: '?q=1' }
+ * ```
+ */
+type ParseURL<S extends string> = S extends `${infer Protocol}://${infer Rest}` ? ParseURLRest<Protocol, Rest> : never;
+type ParseURLRest<Protocol extends string, Rest extends string> = Rest extends `${infer Host}/${infer Path}` ? ParseURLPath<Protocol, Host, Path> : Rest extends `${infer Host}?${infer Search}` ? {
   protocol: Protocol;
   host: Host;
   pathname: '/';
@@ -4184,20 +5795,6 @@ type CachedKeyOf<T> = Cached<keyof T>;
  * Cached property access
  */
 type CachedProperty<T, K extends keyof T> = Cached<T[K]>;
-/**
- * Type computation cache key
- */
-type CacheKey<T> = symbol & {
-  __cacheKey: T;
-};
-/**
- * Cache entry
- */
-interface CacheEntry<K, V> {
-  key: K;
-  value: V;
-  timestamp: number;
-}
 /**
  * Type cache structure
  */
@@ -5759,4 +7356,871 @@ type MarkType<T, Tag extends string> = T & {
   __tag: Tag;
 };
 //#endregion
-export { APIEndpoint, APIError, APIRequest, APIResponse, Add, AddStage, And, AnyGuard, AppendParameter, ArrayElement, ArrayElementGuard, ArrayPaths, Assert, AssertEqual, AssertExtends, AssertHasProperty, AssertKeyof, AssertNotNil, AssertType, AssertionFunction, AsyncFailure, AsyncParameters, AsyncResult, AsyncReturnType, AsyncReturnTypeFromPromise, AsyncSuccess, AtLeastOne, Awaited, Between, BinaryTreeNode, Brand, BrandCache, BrandedNumber, BrandedString, BuildStateMachine, Bulkhead, CRUDOperation, CacheEntry, CacheKey, Cached, CachedIntersection, CachedKeyOf, CachedProperty, CachedUnion, CachedValue, CamelCase, CamelCaseKeys, CanTransition, CapitalizeAll, Case, ChangeEventHandler, ColumnOptions, CombinedGuard, Compact, CompatibilityReport, CompatibleIntersection, CompatibleKeys, CompatibleMerge, CompatibleWith, ComponentProps, ComponentPropsWithRef, ComposeMiddleware, CompositeGuard, CompositeIndex, ConstantCase, ContentType, Context, ConversionMap, ConvertFrom, ConvertTo, CreateTable, CurrentState, DataOnly, DatabaseConfig, Debounce, DebounceOptions, DebugType, Dec, DeepMerge, DeepMutable, DeepNonNullable, DeepNullable, DeepOmit, DeepOmitPaths, DeepOptional, DeepPartial, DeepPick, DeepPickPaths, DeepReadonly, DeepRequired, DeepRequiredProperties, DeepSimplify, Default, Deferred, DeleteQuery, Dequeue, DotCase, EndsWith, Enqueue, EvaluateExpression, EventHandler, Exact, ExactType, Exclusive, ExpandType, ExpectAny, ExpectEqual, ExpectExtends, ExpectFalse, ExpectNever, ExpectNotExtends, ExpectTrue, ExpectUnknown, ExtractPropTypes, ExtractVueProps, FilterKeys, type Find, type FindIndex, FirstParameter, type Flatten, type FlattenDeep, FlattenType, FlushCache, FocusEventHandler, ForEach, ForceEvaluate, FormEventHandler, ForwardRefProps, FromTsToolbelt, FromTypeFest, FromUtilityTypes, Front, FunctionKeys, FunctionOnly, GenericTree, Graph, GraphEdge, GraphEdges, GraphHasCycle, GraphNode, GraphNodes, GraphPath, GreaterThan, GuardedType, HTTPHeaders, HTTPMethod, HTTPStatus, HTTPStatusCategory, HasExactKeys, HasKeys, HasMethod, HasProperties, HasProperty, HasRuntimeCheck, Head$1 as Head, If, Immutable, Inc, type Includes, IncompatibleKeys, Index, type IndexOf, Init, InsertQuery, InspectType, IsAny, IsArray, IsAsyncFunction, IsCompatible, IsEmail, IsEmptyObject, IsEmptyQueue, IsEmptyStack, IsEmptyString, IsEmptyTuple, IsEqual, IsFunction, IsIntersection, IsNever, IsNumeric, IsPromise, IsTerminal, IsTuple, IsURL, IsUUID, IsUnion, IsUnknown, IsValidJSON, IsYupNullable, IsYupOptional, IsYupSchema, IsZodNullable, IsZodOptional, IsZodSchema, Iterate, Join, JoinQuery, KebabCase, KeyboardEventHandler, Keys, KeysByValueType, KeysOfType, Last$1 as Last, Lazy, LazyArrayElement, LazyAwaited, LazyChain, LazyConditional, LazyKey, LazyMap, LazyParameters, LazyReturnType, LeafPaths, LessThan, LibraryFeatures, LinkedList, type ListConcat, type ListFilter, type ListFind, ListHead, type ListIncludes, type ListLength, ListNode, type ListReverse, ListTail, Literal$1 as Literal, LiteralBoolean, LiteralNumber, LiteralString, LockAcquisition, type LongestCommonPrefix, LoosePartial, LowerCase, MachineConfig, MakeAsync, MakeOptional, type MapDelete, type MapGet, type MapHas, type MapKeys, type MapSet, type MapValues, MarkType, Match, Max, Maybe, Memoized, Merge, MergeAll, MergeAllObjects, MergeDefaultProps, Middleware, MiddlewareChain, Migration, MigrationDown, MigrationHistory, MigrationUp, Min, MouseEventHandler, Mutable, MutexState, NegateGuard, NextState, NoNullish, NonFunctionKeys, NonNullable$1 as NonNullable, Normalize, NormalizeVueProps, Not, NthParameter, NullGuard, Nullable, NullishGuard, ObjectEntries, ObjectFilter, ObjectInvert, ObjectMap, ObjectOmitByType, ObjectPath, ObjectPickByType, OmitPartial, OmitRequired, OmitThisParameter, Optional, OptionalKeys, OptionalParameters, OptionalProps, OptionalVueProp, Optionalize, Or, OrderClause, PadEnd, PadStart, Parameters, ParentPath, ParseCSV, ParseExpression, ParseJSON, ParseResponse, ParseURL, PascalCase, PascalCaseKeys, PathExists, PathLeaf, PathLength, PathParams, PathValue, Paths, Peek, PickNonNullable, PickNullable, PickPartial, PickRequired, Pipeline, PipelineRun, PipelineStage, Pop, PrefixKeys, PrependParameter, PrettyType, PrimitiveGuard, PrimitiveGuardMap, PriorityQueue, PrismaAggregateArgs, PrismaCountArgs, PrismaCreateArgs, PrismaCreateInput, PrismaDeleteArgs, PrismaFindFirstArgs, PrismaFindManyArgs, PrismaFindUniqueArgs, PrismaGroupByArgs, PrismaInclude, PrismaModel, PrismaOrderByInput, PrismaPagination, PrismaRelationFields, PrismaScalarFields, PrismaSelect, PrismaUniqueWhere, PrismaUpdateArgs, PrismaUpdateInput, PrismaUpsertArgs, PrismaWhereInput, PromiseFulfilledResult, PromiseRejectedResult, PromiseResult, PromiseSettledResult, PromiseValue, PropsWithChildren, PropsWithClassName, PropsWithStyle, PropsWithStyleAndClassName, PropsWithoutChildren, Push, QueryBuilder, QueryParams, QueryState, Queue, QueueSize, RESTCollection, RESTResource, Range, RateLimiter, ReadonlyKeys, Reduce, ReduceIntersection, ReduceUnion, RemoveSpaces, RenameKeys, Repeat, Replace, ReplaceAll, RequestOptions, RequireArray, RequireAtLeastOne, RequireExactlyOne, RequireFunction, RequireKeys, RequireNotNullish, Required$1 as Required, RequiredKeys, RequiredProps, RequiredVueProp, ResolveBrandCache, ReturnType$1 as ReturnType, type Reverse, ReverseString, Route, RouteParams, RouteQuery, Router, RunTypeTest, RuntimeGuard, SQLColumn, SQLType, ScheduleOptions, ScheduledJob, Scheduler, SelectQuery, Semaphore, SendEvent, type SetAdd, type SetDifference, type SetHas, type SetIntersection, type SetIsEmpty, type SetIsSubset, type SetRemove, type SetUnion, Simplify, SkipTest, SnakeCase, SnakeCaseKeys, Split, SplitByComma, SplitPath, Stack, StackSize, StageResult, StartsWith, State, StateHistory, StateMachine, StrictExclude, StrictExtract, StringLength, StringToArray, StringifyCSV, StringifyJSON, StripNever, StripNull, StripUndefined, Subtract, SuffixKeys, TRPCCallerRouter, TRPCClient, TRPCContext, TRPCErrorShape, TRPCExtractProcedureType, TRPCMergeRouters, TRPCMiddleware, TRPCMutations, TRPCProcedureBuilder, TRPCProcedureCaller, TRPCProcedureInput, TRPCProcedureOutput, TRPCProcedureType, TRPCQueries, TRPCRouterRecord, TRPCRouterShape, TRPCSubscriptions, TRPSCaller, Tail$1 as Tail, Task, TaskError, TaskOptions, TaskPriority, TaskResult, TaskStatus, ThisParameterType, Throttle, ThrottleOptions, Thunk, ToTsToolbelt, ToTypeFest, ToUtilityTypes, ToolbeltDeepPartial, ToolbeltUnionExclude, ToolbeltUnionPick, Transaction, Transition, Tree, TreeDepth, TreeFlatten, TreeLeaves, TreeNode, TreePath, Trim, TrimLeft, TrimRight, TupleLength, TypeCache, TypeCategory, TypeComplexity, TypeCoverage, TypeEq, TypeEvery, TypeFestCamelCase, TypeFestSnakeCase, TypeFilter, TypeFind, TypeIdentity, TypeIncludes, TypeInfo, type TypeMap, TypePredicate, type TypeSet, TypeSome, TypeTest, TypeTestResult, TypeTestSuite, TypeToGuardKey, Unbrand, UncapitalizeAll, UncoveredTypes, UndefinedGuard, UnionGuard, UnionToIntersection, UnionToTuple, type Unique, UniqueIndex, UnwrapPromise, UpdateQuery, UpperCase, UtilityDeepPartial, UtilityDeepReadonly, UtilityMap, ValidPath, ValidTransitions, ValueOf, VueComponentInstance, VueComputed, VueEmitType, VueExpose, VueInjectionKey, VueModelProps, VuePropConstructor, VuePropType, VuePropWithDefault, VuePropsToType, VueProvideInjectPair, VueRawProps, VueReactive, VueRef, VueSlot, VueSlots, WhereBuilder, WhereClause, Worker, WorkerOptions, WorkerPool, WorkerTask, WrapPromise, WritableKeys, YupArrayElement, YupErrorType, YupFields, YupInput, YupOptionalKeys, YupOutput, YupRequiredKeys, YupSchemaStub, YupTestConfig, YupToType, YupTransform, YupTypeNames, YupUnwrapOptional, ZodArrayElement, ZodDeepPartialInput, ZodErrorType, ZodInput, ZodMapEntry, ZodObjectShapeStub, ZodOmit, ZodOptionalKeys, ZodOutput, ZodPick, ZodRecordValue, ZodRequiredKeys, ZodShape, ZodToType, ZodTypeNames, ZodTypeStub, ZodUnwrapNullable, ZodUnwrapOptional };
+//#region src/validation/index.d.ts
+/**
+ * Validation Rules Types
+ *
+ * Types for validation and sanitization.
+ */
+/**
+ * Validator type
+ */
+interface Validator<T = unknown> {
+  validate: (value: unknown) => ValidatorResult<T>;
+  optional: () => Validator<T | undefined>;
+  nullable: () => Validator<T | null>;
+}
+/**
+ * Validator result
+ */
+type ValidatorResult<T = unknown> = {
+  success: true;
+  value: T;
+} | {
+  success: false;
+  errors: ValidationError[];
+};
+/**
+ * Validation error
+ */
+interface ValidationError {
+  path: string;
+  message: string;
+  code: string;
+  value?: unknown;
+  constraints?: Record<string, unknown>;
+}
+/**
+ * Validation rule
+ */
+interface ValidationRule<T = unknown> {
+  name: string;
+  validate: (value: T) => boolean;
+  message: string | ((value: T) => string);
+}
+/**
+ * String field validator
+ */
+type StringFieldValidator<T = string> = Validator<T> & {
+  minLength: (length: number) => StringFieldValidator<T>;
+  maxLength: (length: number) => StringFieldValidator<T>;
+  length: (min: number, max?: number) => StringFieldValidator<T>;
+  pattern: (regex: RegExp) => StringFieldValidator<T>;
+  email: () => StringFieldValidator<T>;
+  url: () => StringFieldValidator<T>;
+  uuid: () => StringFieldValidator<T>;
+  alpha: () => StringFieldValidator<T>;
+  alphanumeric: () => StringFieldValidator<T>;
+  numeric: () => StringFieldValidator<T>;
+  trim: () => StringFieldValidator<T>;
+  lowercase: () => StringFieldValidator<T>;
+  uppercase: () => StringFieldValidator<T>;
+  oneOf: (values: T[]) => StringFieldValidator<T>;
+  notOneOf: (values: T[]) => StringFieldValidator<T>;
+};
+/**
+ * Number field validator
+ */
+type NumberFieldValidator<T = number> = Validator<T> & {
+  min: (value: number) => NumberFieldValidator<T>;
+  max: (value: number) => NumberFieldValidator<T>;
+  range: (min: number, max: number) => NumberFieldValidator<T>;
+  integer: () => NumberFieldValidator<T>;
+  float: () => NumberFieldValidator<T>;
+  positive: () => NumberFieldValidator<T>;
+  negative: () => NumberFieldValidator<T>;
+  nonNegative: () => NumberFieldValidator<T>;
+  nonPositive: () => NumberFieldValidator<T>;
+  multipleOf: (value: number) => NumberFieldValidator<T>;
+  finite: () => NumberFieldValidator<T>;
+  safe: () => NumberFieldValidator<T>;
+};
+/**
+ * Boolean field validator
+ */
+type BooleanFieldValidator<T = boolean> = Validator<T> & {
+  true: () => BooleanFieldValidator<T>;
+  false: () => BooleanFieldValidator<T>;
+};
+/**
+ * Date field validator
+ */
+type DateFieldValidator<T = Date> = Validator<T> & {
+  min: (date: Date | string) => DateFieldValidator<T>;
+  max: (date: Date | string) => DateFieldValidator<T>;
+  range: (min: Date | string, max: Date | string) => DateFieldValidator<T>;
+  before: (date: Date | string) => DateFieldValidator<T>;
+  after: (date: Date | string) => DateFieldValidator<T>;
+  past: () => DateFieldValidator<T>;
+  future: () => DateFieldValidator<T>;
+};
+/**
+ * Array field validator
+ */
+type ArrayFieldValidator<T = unknown[]> = Validator<T> & {
+  minLength: (length: number) => ArrayFieldValidator<T>;
+  maxLength: (length: number) => ArrayFieldValidator<T>;
+  length: (min: number, max?: number) => ArrayFieldValidator<T>;
+  nonEmpty: () => ArrayFieldValidator<T>;
+  unique: () => ArrayFieldValidator<T>;
+  of: <U>(validator: Validator<U>) => ArrayFieldValidator<U[]>;
+};
+/**
+ * Object field validator
+ */
+type ObjectFieldValidator<T = Record<string, unknown>> = Validator<T> & {
+  shape: <S extends Record<string, Validator>>(schema: S) => ObjectFieldValidator<{ [K in keyof S]: S[K] extends Validator<infer U> ? U : never }>;
+  partial: () => ObjectFieldValidator<Partial<T>>;
+  strict: () => ObjectFieldValidator<T>;
+  stripUnknown: () => ObjectFieldValidator<T>;
+  nonEmpty: () => ObjectFieldValidator<T>;
+};
+/**
+ * Or validator
+ */
+interface OrValidator<T = unknown> {
+  validators: Validator<T>[];
+  validate: (value: unknown) => ValidatorResult<T>;
+}
+/**
+ * Not validator
+ */
+interface NotValidator<T = unknown> {
+  validator: Validator<T>;
+  validate: (value: unknown) => ValidatorResult<T>;
+}
+/**
+ * Custom validator
+ */
+interface CustomValidator<T = unknown> {
+  validate: (value: unknown, context?: ValidationContext) => ValidatorResult<T>;
+}
+/**
+ * Validation context
+ */
+interface ValidationContext<T = unknown> {
+  path: string;
+  parent?: T;
+  root: unknown;
+  options: ValidationOptions;
+}
+/**
+ * Validation options
+ */
+interface ValidationOptions {
+  abortEarly: boolean;
+  stripUnknown: boolean;
+  allowUnknown: boolean;
+  cast: boolean;
+  context?: Record<string, unknown>;
+}
+/**
+ * Min length constraint
+ */
+type MinLength<N extends number> = N;
+/**
+ * Max length constraint
+ */
+type MaxLength<N extends number> = N;
+/**
+ * Min value constraint
+ */
+type MinValue<N extends number> = N;
+/**
+ * Max value constraint
+ */
+type MaxValue<N extends number> = N;
+/**
+ * Pattern constraint
+ */
+type Pattern<S extends string> = S;
+/**
+ * Email constraint
+ */
+interface EmailConstraint {
+  allowDisplayName: boolean;
+  allowTld: boolean;
+  requireTld: boolean;
+  domainSpecificValidation: boolean;
+}
+/**
+ * URL constraint
+ */
+interface URLConstraint {
+  protocols: string[];
+  requireProtocol: boolean;
+  requireHost: boolean;
+  allowRelative: boolean;
+  allowProtocolRelativeUrls: boolean;
+}
+/**
+ * UUID constraint
+ */
+interface UUIDConstraint {
+  version: 1 | 3 | 4 | 5 | 'all';
+}
+/**
+ * Sanitizer type
+ */
+interface Sanitizer<T = unknown> {
+  sanitize: (value: unknown) => SanitizeResult<T>;
+}
+/**
+ * Sanitize result
+ */
+type SanitizeResult<T = unknown> = {
+  success: true;
+  value: T;
+  changed: boolean;
+} | {
+  success: false;
+  error: string;
+};
+/**
+ * Sanitization rule
+ */
+interface SanitizationRule<T = unknown> {
+  name: string;
+  sanitize: (value: T) => T;
+  description?: string;
+}
+/**
+ * String sanitizer
+ */
+type StringSanitizer = Sanitizer<string> & {
+  trim: () => StringSanitizer;
+  lowercase: () => StringSanitizer;
+  uppercase: () => StringSanitizer;
+  escape: () => StringSanitizer;
+  unescape: () => StringSanitizer;
+  stripTags: () => StringSanitizer;
+  stripLow: () => StringSanitizer;
+  normalizeEmail: () => StringSanitizer;
+  whitelist: (chars: string) => StringSanitizer;
+  blacklist: (chars: string) => StringSanitizer;
+};
+/**
+ * Number sanitizer
+ */
+type NumberSanitizer = Sanitizer<number> & {
+  toInt: () => NumberSanitizer;
+  toFloat: () => NumberSanitizer;
+  round: (precision?: number) => NumberSanitizer;
+  floor: () => NumberSanitizer;
+  ceil: () => NumberSanitizer;
+  clamp: (min: number, max: number) => NumberSanitizer;
+};
+/**
+ * Schema builder
+ */
+interface SchemaBuilder {
+  string: () => StringFieldValidator;
+  number: () => NumberFieldValidator;
+  boolean: () => BooleanFieldValidator;
+  date: () => DateFieldValidator;
+  array: <U>(validator?: Validator<U>) => ArrayFieldValidator<U[]>;
+  object: <S extends Record<string, Validator>>(schema?: S) => ObjectFieldValidator;
+  any: () => Validator<unknown>;
+  unknown: () => Validator<unknown>;
+  never: () => Validator<never>;
+  undefined: () => Validator<undefined>;
+  null: () => Validator<null>;
+  void: () => Validator<void>;
+  literal: <V extends string | number | boolean>(value: V) => Validator<V>;
+  enum: <V extends string>(values: V[]) => Validator<V>;
+  union: <U extends Validator[]>(...validators: U) => Validator<U[number] extends Validator<infer V> ? V : never>;
+  intersection: <U extends Validator[]>(...validators: U) => Validator<U[number] extends Validator<infer V> ? V : never>;
+  record: <K extends string, V>(keyValidator?: Validator<K>, valueValidator?: Validator<V>) => Validator<Record<K, V>>;
+  tuple: <T extends Validator[]>(...validators: T) => Validator<{ [I in keyof T]: T[I] extends Validator<infer V> ? V : never }>;
+}
+//#endregion
+//#region src/websocket/index.d.ts
+/**
+ * WebSocket & Real-Time Types
+ *
+ * Types for real-time communication with WebSocket.
+ */
+/**
+ * WebSocket message type
+ */
+interface WebSocketMessage<T = unknown> {
+  type: string;
+  payload: T;
+  timestamp?: number;
+  id?: string;
+}
+/**
+ * WebSocket event type
+ */
+interface WebSocketEvent<T = unknown> {
+  event: string;
+  data: T;
+  timestamp: number;
+}
+/**
+ * WebSocket handler function type
+ */
+type WebSocketHandler<T = unknown> = (message: WebSocketMessage<T>) => void | Promise<void>;
+/**
+ * WebSocket connection state
+ */
+type WebSocketState = 'connecting' | 'connected' | 'disconnecting' | 'disconnected';
+/**
+ * WebSocket options
+ */
+interface WebSocketOptions {
+  url: string;
+  protocols?: string | string[];
+  reconnect?: boolean;
+  reconnectInterval?: number;
+  maxReconnectAttempts?: number;
+}
+/**
+ * WebSocket configuration
+ */
+type WebSocketConfig<T = unknown> = WebSocketOptions & {
+  onMessage?: WebSocketHandler<T>;
+  onOpen?: () => void;
+  onClose?: (event: {
+    code: number;
+    reason: string;
+  }) => void;
+  onError?: (error: Error) => void;
+};
+/**
+ * Event map type
+ */
+type EventMap<T = Record<string, unknown>> = { [K in keyof T]: T[K] };
+/**
+ * Event handler function type
+ */
+type EventHandler$1<T, E extends keyof T = keyof T> = (event: T[E]) => void | Promise<void>;
+/**
+ * Event payload type
+ */
+type EventPayload<T, E extends keyof T = keyof T> = T[E];
+/**
+ * Event listener options
+ */
+interface EventListenerOptions {
+  once?: boolean;
+  capture?: boolean;
+  passive?: boolean;
+}
+/**
+ * Event emitter type
+ */
+interface EventEmitter<T extends EventMap> {
+  on: <E extends keyof T>(event: E, handler: EventHandler$1<T, E>) => void;
+  off: <E extends keyof T>(event: E, handler: EventHandler$1<T, E>) => void;
+  emit: <E extends keyof T>(event: E, payload: T[E]) => void;
+  once: <E extends keyof T>(event: E, handler: EventHandler$1<T, E>) => void;
+}
+/**
+ * Typed event target
+ */
+interface TypedEventTarget<T extends EventMap> {
+  addEventListener: <E extends keyof T>(event: E, handler: EventHandler$1<T, E>, options?: EventListenerOptions) => void;
+  removeEventListener: <E extends keyof T>(event: E, handler: EventHandler$1<T, E>) => void;
+  dispatchEvent: <E extends keyof T>(event: E, payload: T[E]) => boolean;
+}
+/**
+ * Real-time channel type
+ */
+interface RealTimeChannel<T = unknown> {
+  name: string;
+  subscribe: (handler: (message: T) => void) => () => void;
+  publish: (message: T) => void;
+  unsubscribe: (handler: (message: T) => void) => void;
+  close: () => void;
+}
+/**
+ * Real-time subscription type
+ */
+interface RealTimeSubscription<T = unknown> {
+  id: string;
+  channel: string;
+  handler: (message: T) => void;
+  unsubscribe: () => void;
+  active: boolean;
+}
+/**
+ * Real-time message type
+ */
+interface RealTimeMessage<T = unknown> {
+  channel: string;
+  data: T;
+  timestamp: number;
+  subscriptionId?: string;
+}
+/**
+ * Real-time client type
+ */
+interface RealTimeClient<T extends EventMap = Record<string, unknown>> {
+  connect: () => Promise<void>;
+  disconnect: () => Promise<void>;
+  subscribe: <E extends keyof T>(channel: E, handler: EventHandler$1<T, E>) => RealTimeSubscription<T[E]>;
+  publish: <E extends keyof T>(channel: E, data: T[E]) => void;
+  isConnected: boolean;
+}
+/**
+ * Stream type
+ */
+interface Stream<T = unknown> {
+  [Symbol.asyncIterator]: () => AsyncIterator<T>;
+  readable: boolean;
+  closed: boolean;
+}
+/**
+ * Stream chunk type
+ */
+interface StreamChunk<T = unknown> {
+  value: T;
+  done: boolean;
+}
+/**
+ * Stream reader type
+ */
+interface StreamReader<T = unknown> {
+  read: () => Promise<StreamChunk<T>>;
+  releaseLock: () => void;
+  closed: boolean;
+}
+/**
+ * Stream writer type
+ */
+interface StreamWriter<T = unknown> {
+  write: (chunk: T) => Promise<void>;
+  close: () => Promise<void>;
+  abort: (reason?: unknown) => Promise<void>;
+  closed: boolean;
+  desiredSize: number | null;
+}
+/**
+ * Readable stream type
+ */
+interface ReadableStreamLike<T = unknown> {
+  getReader: () => StreamReader<T>;
+  locked: boolean;
+  cancel: (reason?: unknown) => Promise<void>;
+  pipeThrough: <R>(transform: unknown) => ReadableStreamLike<R>;
+  pipeTo: (dest: WritableStreamLike<T>) => Promise<void>;
+  tee: () => [ReadableStreamLike<T>, ReadableStreamLike<T>];
+}
+/**
+ * Writable stream type
+ */
+interface WritableStreamLike<T = unknown> {
+  getWriter: () => StreamWriter<T>;
+  locked: boolean;
+  abort: (reason?: unknown) => Promise<void>;
+  close: () => Promise<void>;
+}
+/**
+ * Transform stream type
+ */
+interface TransformStreamLike<I = unknown, O = unknown> {
+  readable: ReadableStreamLike<O>;
+  writable: WritableStreamLike<I>;
+}
+/**
+ * Pub/Sub type
+ */
+interface PubSub<T = unknown> {
+  publish: (topic: string, message: T) => void;
+  subscribe: (topic: string, handler: (message: T) => void) => () => void;
+  unsubscribe: (topic: string, handler?: (message: T) => void) => void;
+  topics: string[];
+}
+/**
+ * Publisher type
+ */
+interface Publisher<T = unknown> {
+  publish: (topic: string, message: T) => void;
+}
+/**
+ * Subscriber type
+ */
+interface Subscriber<T = unknown> {
+  subscribe: (topic: string, handler: (message: T) => void) => () => void;
+  unsubscribe: (topic: string, handler?: (message: T) => void) => void;
+}
+/**
+ * Subscription options type
+ */
+interface SubscriptionOptions<T = unknown> {
+  topic: string;
+  handler: (message: T) => void;
+  once?: boolean;
+  filter?: (message: T) => boolean;
+}
+//#endregion
+//#region src/workflow/index.d.ts
+/**
+ * Workflow Engine Types
+ *
+ * Types for workflow and process management.
+ */
+/**
+ * Workflow type
+ */
+interface Workflow<T = unknown> {
+  id: string;
+  name: string;
+  description?: string;
+  version: string;
+  definition: WorkflowDefinition<T>;
+  status: WorkflowStatus;
+  createdAt: Date;
+  updatedAt: Date;
+}
+/**
+ * Workflow definition
+ */
+interface WorkflowDefinition<T = unknown> {
+  steps: WorkflowStep[];
+  transitions: WorkflowTransition[];
+  initialStep: string;
+  finalSteps: string[];
+  timeouts?: WorkflowTimeout;
+  errorHandler?: WorkflowErrorHandler<T>;
+  context?: T;
+}
+/**
+ * Workflow instance
+ */
+interface WorkflowInstance<T = unknown> {
+  id: string;
+  workflowId: string;
+  status: WorkflowStatus;
+  currentStep: string;
+  context: T;
+  history: HistoryEntry[];
+  startedAt: Date;
+  completedAt?: Date;
+  error?: WorkflowError;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Workflow status
+ */
+type WorkflowStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'paused';
+/**
+ * Workflow step
+ */
+interface WorkflowStep<T = unknown> {
+  id: string;
+  name: string;
+  description?: string;
+  type: StepType;
+  config?: T;
+  timeout?: number;
+  retryPolicy?: RetryPolicy$1;
+  compensation?: string;
+  onSuccess?: string;
+  onFailure?: string;
+}
+/**
+ * Step type
+ */
+type StepType = 'task' | 'decision' | 'parallel' | 'subworkflow' | 'wait' | 'human' | 'script' | 'http';
+/**
+ * Step result
+ */
+type StepResult<T = unknown> = {
+  success: true;
+  data: T;
+  nextStep?: string;
+} | {
+  success: false;
+  error: Error;
+  retry?: boolean;
+  compensation?: boolean;
+};
+/**
+ * Step status
+ */
+type StepStatus$1 = 'waiting' | 'running' | 'success' | 'failure' | 'skipped' | 'compensated';
+/**
+ * Workflow transition
+ */
+interface WorkflowTransition<T = unknown> {
+  from: string;
+  to: string | string[];
+  condition?: TransitionCondition<T>;
+  action?: TransitionAction<T>;
+  priority?: number;
+}
+/**
+ * Transition condition
+ */
+type TransitionCondition<T = unknown> = (context: T) => boolean;
+/**
+ * Transition action
+ */
+type TransitionAction<T = unknown> = (context: T) => T | Promise<T>;
+/**
+ * Workflow timeout
+ */
+interface WorkflowTimeout {
+  workflow?: number;
+  step?: number;
+  action?: number;
+}
+/**
+ * Workflow execution
+ */
+interface WorkflowExecution<T = unknown> {
+  id: string;
+  instanceId: string;
+  status: ExecutionStatus;
+  startedAt: Date;
+  completedAt?: Date;
+  duration?: number;
+  steps: ExecutionStep<T>;
+  result?: T;
+  error?: WorkflowError;
+}
+/**
+ * Execution status
+ */
+type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'timeout' | 'cancelled';
+/**
+ * Execution step
+ */
+interface ExecutionStep<T = unknown> {
+  stepId: string;
+  status: StepStatus$1;
+  startedAt: Date;
+  completedAt?: Date;
+  input?: T;
+  output?: T;
+  error?: Error;
+  retryCount: number;
+}
+/**
+ * Execution context
+ */
+interface ExecutionContext<T = unknown> {
+  workflowId: string;
+  instanceId: string;
+  executionId: string;
+  currentStep: string;
+  context: T;
+  metadata: Record<string, unknown>;
+  variables: Record<string, unknown>;
+}
+/**
+ * Execution result
+ */
+type ExecutionResult<T = unknown> = {
+  success: true;
+  data: T;
+  completedAt: Date;
+} | {
+  success: false;
+  error: WorkflowError;
+  completedAt: Date;
+};
+/**
+ * Workflow history
+ */
+interface WorkflowHistory<T = unknown> {
+  instanceId: string;
+  entries: HistoryEntry<T>[];
+  total: number;
+}
+/**
+ * History entry
+ */
+interface HistoryEntry<T = unknown> {
+  id: string;
+  timestamp: Date;
+  type: HistoryEventType;
+  stepId?: string;
+  fromStep?: string;
+  toStep?: string;
+  context?: T;
+  result?: StepResult<T>;
+  error?: Error;
+  duration?: number;
+  actor?: string;
+}
+/**
+ * History event
+ */
+interface HistoryEvent<T = unknown> {
+  type: HistoryEventType;
+  timestamp: Date;
+  data: T;
+}
+/**
+ * History event type
+ */
+type HistoryEventType = 'workflow_started' | 'workflow_completed' | 'workflow_failed' | 'workflow_cancelled' | 'step_started' | 'step_completed' | 'step_failed' | 'step_skipped' | 'transition' | 'compensation_started' | 'compensation_completed' | 'error' | 'retry' | 'timeout';
+/**
+ * Workflow error
+ */
+interface WorkflowError {
+  code: string;
+  message: string;
+  details?: unknown;
+  stack?: string;
+  retryable: boolean;
+  timestamp: Date;
+}
+/**
+ * Workflow error handler
+ */
+interface WorkflowErrorHandler<T = unknown> {
+  onError: (error: WorkflowError, context: ExecutionContext<T>) => ErrorHandlerResult;
+}
+/**
+ * Error handler result
+ */
+type ErrorHandlerResult = {
+  action: 'retry';
+  delay?: number;
+} | {
+  action: 'compensate';
+} | {
+  action: 'continue';
+  nextStep: string;
+} | {
+  action: 'fail';
+} | {
+  action: 'ignore';
+};
+/**
+ * Retry policy
+ */
+interface RetryPolicy$1 {
+  maxRetries: number;
+  backoff: 'fixed' | 'exponential' | 'linear';
+  initialDelay: number;
+  maxDelay: number;
+  retryableErrors?: string[];
+}
+/**
+ * BPMN process
+ */
+type BPMNProcess<T = unknown> = {
+  id: string;
+  name: string;
+  type: BPMNProcessType;
+  lane?: string;
+  documentation?: string;
+  extensionElements?: Record<string, unknown>;
+} & WorkflowDefinition<T>;
+/**
+ * BPMN process type
+ */
+type BPMNProcessType = 'none' | 'message' | 'timer' | 'signal' | 'conditional' | 'error' | 'escalation' | 'compensation' | 'multiple' | 'parallel';
+/**
+ * BPMN task
+ */
+interface BPMNTask<T = unknown> {
+  id: string;
+  name: string;
+  type: BPMNTaskType;
+  assignee?: string;
+  candidateUsers?: string[];
+  candidateGroups?: string[];
+  priority?: number;
+  dueDate?: Date;
+  formKey?: string;
+  input?: T;
+  output?: T;
+}
+/**
+ * BPMN task type
+ */
+type BPMNTaskType = 'user' | 'service' | 'script' | 'business-rule' | 'manual' | 'send' | 'receive' | 'abstract';
+/**
+ * BPMN gateway
+ */
+interface BPMNGateway<T = unknown> {
+  id: string;
+  name: string;
+  type: BPMNGatewayType;
+  conditions?: BPMNGatewayCondition<T>[];
+  defaultFlow?: string;
+}
+/**
+ * BPMN gateway type
+ */
+type BPMNGatewayType = 'exclusive' | 'parallel' | 'inclusive' | 'event-based' | 'complex';
+/**
+ * BPMN gateway condition
+ */
+interface BPMNGatewayCondition<T = unknown> {
+  flowId: string;
+  condition: (context: T) => boolean;
+  expression?: string;
+}
+/**
+ * BPMN event
+ */
+interface BPMNEvent<T = unknown> {
+  id: string;
+  name: string;
+  type: BPMNEventType;
+  trigger: BPMNEventTrigger;
+  catching: boolean;
+  data?: T;
+}
+/**
+ * BPMN event type
+ */
+type BPMNEventType = 'start' | 'end' | 'intermediate' | 'boundary';
+/**
+ * BPMN event trigger
+ */
+type BPMNEventTrigger = 'none' | 'message' | 'timer' | 'signal' | 'conditional' | 'error' | 'escalation' | 'compensation' | 'link' | 'terminate' | 'multiple' | 'parallel';
+/**
+ * Workflow engine
+ */
+interface WorkflowEngine<T = unknown> {
+  register: (workflow: Workflow<T>) => void;
+  unregister: (workflowId: string) => void;
+  start: (workflowId: string, input?: T) => Promise<WorkflowInstance>;
+  resume: (instanceId: string) => Promise<WorkflowInstance>;
+  cancel: (instanceId: string) => Promise<void>;
+  pause: (instanceId: string) => Promise<void>;
+  getStatus: (instanceId: string) => Promise<WorkflowInstance | undefined>;
+  getHistory: (instanceId: string) => Promise<WorkflowHistory>;
+  listInstances: (workflowId?: string) => Promise<WorkflowInstance[]>;
+}
+/**
+ * Workflow engine configuration
+ */
+interface WorkflowEngineConfig {
+  persistence: WorkflowPersistence;
+  executor: WorkflowExecutor;
+  maxConcurrentWorkflows: number;
+  defaultTimeout: number;
+  errorHandling: ErrorHandlingStrategy;
+}
+/**
+ * Workflow persistence
+ */
+interface WorkflowPersistence {
+  saveInstance: (instance: WorkflowInstance) => Promise<void>;
+  getInstance: (instanceId: string) => Promise<WorkflowInstance | undefined>;
+  deleteInstance: (instanceId: string) => Promise<void>;
+  saveHistory: (instanceId: string, entry: HistoryEntry) => Promise<void>;
+  getHistory: (instanceId: string) => Promise<HistoryEntry[]>;
+}
+/**
+ * Workflow executor
+ */
+interface WorkflowExecutor {
+  executeStep: <T>(step: WorkflowStep, context: ExecutionContext<T>) => Promise<StepResult>;
+  executeParallel: <T>(steps: WorkflowStep[], context: ExecutionContext<T>) => Promise<StepResult[]>;
+}
+/**
+ * Error handling strategy
+ */
+type ErrorHandlingStrategy = 'fail-fast' | 'compensate' | 'ignore' | 'manual';
+//#endregion
+export { type ABAC, type ABACConfig, type ACL, type ACLEntry, type APIGateway, type ARCCache, type AccessControl, type Action, Add, AddStage, type AggregateEvents, type Alert, type AlertConfig, type AlertReceiver, type AlertRoute, type AlertRule, type AlertSeverity, type AlertStatus, And, AnyGuard, AppendParameter, ArrayElement, ArrayElementGuard, type ArrayFieldValidator, ArrayPaths, Assert, AssertEqual, AssertExtends, AssertHasProperty, AssertKeyof, AssertNotNil, AssertType, AssertionFunction, AsyncFailure, AsyncParameters, AsyncResult, AsyncReturnType, AsyncReturnTypeFromPromise, AsyncSuccess, AtLeastOne, type Attribute, type AttributeValue, type AuthConfig, type AuthorizationOptions, type AuthorizationProvider, Awaited, type BPMNEvent, type BPMNEventTrigger, type BPMNEventType, type BPMNGateway, type BPMNGatewayCondition, type BPMNGatewayType, type BPMNProcess, type BPMNProcessType, type BPMNTask, type BPMNTaskType, type BaseEvent, Between, BinaryTreeNode, type BooleanFieldValidator, Brand, BrandCache, BrandedNumber, BrandedString, BuildStateMachine, Bulkhead, type CORSConfig, type Cache, type CacheAside, type CacheCluster, type CacheCompressionOptions, type CacheDecoratorOptions, type CacheEntry, type CacheInvalidation, type CacheKey, type CacheKeyBuilder, type CacheNode, type CacheOptions, type CacheSerializer, type CacheStats, type CacheStrategy, type CacheValue, Cached, CachedIntersection, CachedKeyOf, CachedProperty, CachedUnion, CachedValue, CamelCase, CamelCaseKeys, CanTransition, CapitalizeAll, Case, ChangeEventHandler, type CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerState, type CircuitBreakerStats, ColumnOptions, CombinedGuard, type Command, type CommandBus, type CommandHandler, type CommandResult, Compact, CompatibilityReport, CompatibleIntersection, CompatibleKeys, CompatibleMerge, CompatibleWith, ComponentProps, ComponentPropsWithRef, CompositeGuard, CompositeIndex, type ConditionOperator, type Config, type ConfigError, type ConfigField, type ConfigFieldType, type ConfigFileFormat, type ConfigLoader, type ConfigLoaderOptions, type ConfigPriority, type ConfigSchema, type ConfigValidationResult, type ConfigValidator, type ConfigValue, type ConfigWarning, type ConsistentHash, ConstantCase, ConversionMap, ConvertFrom, ConvertTo, type Counter, CreateTable, CurrentState, type CustomValidator, DataOnly, DatabaseConfig, type DateFieldValidator, type DeadLetterQueue, Debounce, DebounceOptions, DebugType, Dec, DeepMerge, DeepMutable, DeepNonNullable, DeepNullable, DeepOmit, DeepOmitPaths, DeepOptional, DeepPartial, DeepPick, DeepPickPaths, DeepReadonly, DeepRequired, DeepRequiredProperties, DeepSimplify, Default, Deferred, DeleteQuery, Dequeue, type DistributedCache, DotCase, type EmailConstraint, EndsWith, Enqueue, type EnvConfig, type EnvMapping, type EnvVar, type ErrorHandlerResult, type ErrorHandlingStrategy, EvaluateExpression, type EventBus, type EventBusConfig, type EventBusHandler, type EventBusMiddleware, type EventEmitter, EventHandler, type EventListenerOptions, type EventMap, type EventPayload, type StepStatus as EventStepStatus, type EventStore, type EventStream, type EventTimestamp, type EventVersion, Exact, ExactType, Exclusive, type ExecutionContext, type ExecutionResult, type ExecutionStatus, type ExecutionStep, ExpandType, ExpectAny, ExpectEqual, ExpectExtends, ExpectFalse, ExpectNever, ExpectNotExtends, ExpectTrue, ExpectUnknown, ExtractPropTypes, ExtractVueProps, type FIFOCache, type FeatureFlag, type FeatureFlagConfig, type FeatureFlagVariant, type FeatureFlags, type FeatureTargeting, FilterKeys, type Find, type FindIndex, FirstParameter, type Flatten, type FlattenDeep, FlattenType, FlushCache, FocusEventHandler, ForEach, ForceEvaluate, FormEventHandler, ForwardRefProps, FromTsToolbelt, FromTypeFest, FromUtilityTypes, Front, FunctionKeys, FunctionOnly, type GatewayConfig, type GatewayMiddleware, type GatewayRoute, type Gauge, GenericTree, Graph, GraphEdge, GraphEdges, GraphHasCycle, GraphNode, GraphNodes, GraphPath, GraphQLArgs, GraphQLContext, GraphQLEnumType, GraphQLFieldResolver, GraphQLFieldTypes, GraphQLFlatSelection, GraphQLFragment, GraphQLInputObjectType, GraphQLInputType, GraphQLInterfaceType, GraphQLMutation, GraphQLObjectType, GraphQLOutputType, GraphQLQuery, GraphQLResolveInfo, GraphQLResolver, GraphQLReturn, GraphQLScalarType, GraphQLSchema, GraphQLSelection, GraphQLSelectionSet, GraphQLSubscription, GraphQLToType, GraphQLType, GraphQLUnionType, GreaterThan, GuardedType, type HTTPStatus, HasExactKeys, HasKeys, HasMethod, HasProperties, HasProperty, HasRuntimeCheck, Head$1 as Head, type HealthCheck, type HealthIndicator, type HealthReport, type Histogram, type HistoryEntry, type HistoryEvent, type HistoryEventType, type HitRate, If, Immutable, Inc, type Includes, IncompatibleKeys, Index, type IndexOf, type InhibitRule, Init, InsertQuery, InspectType, type InstanceStatus, type InvalidationEvent, type InvalidationRule, type InvalidationStrategy, IsAny, IsArray, IsAsyncFunction, IsCompatible, IsEmail, IsEmptyObject, IsEmptyQueue, IsEmptyStack, IsEmptyString, IsEmptyTuple, IsEqual, IsFunction, IsIntersection, IsNever, IsNumeric, IsPromise, IsTerminal, IsTuple, IsURL, IsUUID, IsUnion, IsUnknown, IsValidJSON, IsYupNullable, IsYupOptional, IsYupSchema, IsZodNullable, IsZodOptional, IsZodSchema, Iterate, Join, JoinQuery, KebabCase, KeyboardEventHandler, Keys, KeysByValueType, KeysOfType, type LFUCache, type LRUCache, Last$1 as Last, Lazy, LazyArrayElement, LazyAwaited, LazyChain, LazyConditional, LazyKey, LazyMap, LazyParameters, LazyReturnType, LeafPaths, LessThan, LibraryFeatures, LinkedList, type ListConcat, type ListFilter, type ListFind, ListHead, type ListIncludes, type ListLength, ListNode, type ListReverse, ListTail, Literal$1 as Literal, LiteralBoolean, LiteralNumber, LiteralString, type LivenessCheck, type LoadBalancer, type LoadBalancerStrategy, LockAcquisition, type LogContext, type LogEntry, type LogLevel, type LogTransport, type Logger, type LoggerConfig, type HealthCheckResult as LoggingHealthCheckResult, type LongestCommonPrefix, LoosePartial, LowerCase, MachineConfig, MakeAsync, MakeOptional, type MapDelete, type MapGet, type MapHas, type MapKeys, type MapSet, type MapValues, MarkType, Match, Max, type MaxLength, type MaxValue, Maybe, Memoized, Merge, MergeAll, MergeAllObjects, MergeDefaultProps, type MessageQueue, type Metric, type MetricType, type MetricsRegistry, type Microservice, type Middleware, Migration, MigrationDown, MigrationHistory, MigrationUp, Min, type MinLength, type MinValue, type MissRate, type Monitor, type MonitorResult, type MonitorStatus, MouseEventHandler, Mutable, MutexState, NegateGuard, NextState, NoNullish, NonFunctionKeys, NonNullable$1 as NonNullable, Normalize, NormalizeVueProps, Not, type NotValidator, NthParameter, NullGuard, Nullable, NullishGuard, type NumberFieldValidator, type NumberSanitizer, ObjectEntries, type ObjectFieldValidator, ObjectFilter, ObjectInvert, ObjectMap, ObjectOmitByType, ObjectPath, ObjectPickByType, OmitPartial, OmitRequired, OmitThisParameter, Optional, OptionalKeys, OptionalParameters, OptionalProps, OptionalVueProp, Optionalize, Or, type OrValidator, OrderClause, PadEnd, PadStart, Parameters, ParentPath, ParseCSV, type ParseEnvResult, ParseExpression, ParseJSON, ParseURL, PascalCase, PascalCaseKeys, PathExists, PathLeaf, PathLength, PathParams, PathValue, Paths, type Pattern, Peek, type Permission, type PermissionCheckResult, type PermissionCondition, type PermissionDeny, type PermissionGrant, type PermissionSet, PickNonNullable, PickNullable, PickPartial, PickRequired, Pipeline, PipelineRun, PipelineStage, type Policy, type PolicyCondition, type PolicyContext, type PolicyEffect, type PolicyResult, type PolicyRule, Pop, PrefixKeys, PrependParameter, PrettyType, PrimitiveGuard, PrimitiveGuardMap, PriorityQueue, PrismaAggregateArgs, PrismaCountArgs, PrismaCreateArgs, PrismaCreateInput, PrismaDeleteArgs, PrismaFindFirstArgs, PrismaFindManyArgs, PrismaFindUniqueArgs, PrismaGroupByArgs, PrismaInclude, PrismaModel, PrismaOrderByInput, PrismaPagination, PrismaRelationFields, PrismaScalarFields, PrismaSelect, PrismaUniqueWhere, PrismaUpdateArgs, PrismaUpdateInput, PrismaUpsertArgs, PrismaWhereInput, PromiseFulfilledResult, PromiseRejectedResult, PromiseResult, PromiseSettledResult, PromiseValue, PropsWithChildren, PropsWithClassName, PropsWithStyle, PropsWithStyleAndClassName, PropsWithoutChildren, type PubSub, type PublishOptions, type Publisher, Push, type Query, QueryBuilder, type QueryBus, type QueryHandler, QueryParams, type QueryResult, QueryState, Queue, type QueueConsumer, type QueueMessage, type QueueProducer, QueueSize, type RBAC, type RBACConfig, Range, type RateLimit, RateLimiter, type ReadThroughCache, type ReadableStreamLike, type ReadinessCheck, ReadonlyKeys, type RealTimeChannel, type RealTimeClient, type RealTimeMessage, type RealTimeSubscription, Reduce, ReduceIntersection, ReduceUnion, type RemoteConfigProvider, RemoveSpaces, RenameKeys, Repeat, Replace, ReplaceAll, RequireArray, RequireAtLeastOne, RequireExactlyOne, RequireFunction, RequireKeys, RequireNotNullish, Required$1 as Required, RequiredKeys, RequiredProps, RequiredVueProp, ResolveBrandCache, type Resource, ReturnType$1 as ReturnType, type Reverse, ReverseString, type Role, type RoleHierarchy, type RolePermission, type RoleSet, type Route, RunTypeTest, RuntimeGuard, SQLColumn, SQLType, type Saga, type SagaCompensation, type SagaResult, type SagaStatus, type SagaStep, type SanitizationRule, type SanitizeResult, type Sanitizer, ScheduleOptions, ScheduledJob, Scheduler, type SchemaBuilder, type Secret, type SecretConfig, type SecretOptions, type SecretProvider, SelectQuery, Semaphore, SendEvent, type ServiceClient, type ServiceConfig, type ServiceDiscovery, type ServiceError, type HealthStatus as ServiceHealthStatus, type ServiceInstance, type ServiceRegistry, type ServiceRequest, type ServiceResponse, type RetryPolicy as ServiceRetryPolicy, type SetAdd, type SetDifference, type SetHas, type SetIntersection, type SetIsEmpty, type SetIsSubset, type SetRemove, type SetUnion, Simplify, SkipTest, SnakeCase, SnakeCaseKeys, type Span, type SpanEvent, type SpanKind, type SpanLink, type SpanOptions, type SpanStatus, Split, SplitByComma, SplitPath, Stack, StackSize, StageResult, StartsWith, State, StateHistory, StateMachine, type StepResult, type StepType, type Stream, type StreamChunk, type StreamReader, type StreamWriter, StrictExclude, StrictExtract, type StringFieldValidator, StringLength, type StringSanitizer, StringToArray, StringifyCSV, StringifyJSON, StripNever, StripNull, StripUndefined, type Subscriber, type SubscriptionOptions, Subtract, SuffixKeys, type Summary, TRPCCallerRouter, TRPCClient, TRPCContext, TRPCErrorShape, TRPCExtractProcedureType, TRPCMergeRouters, TRPCMiddleware, TRPCMutations, TRPCProcedureBuilder, TRPCProcedureCaller, TRPCProcedureInput, TRPCProcedureOutput, TRPCProcedureType, TRPCQueries, TRPCRouterRecord, TRPCRouterShape, TRPCSubscriptions, TRPSCaller, type TTLCache, Tail$1 as Tail, type TargetingOperator, Task, TaskError, TaskOptions, TaskPriority, TaskResult, TaskStatus, ThisParameterType, Throttle, ThrottleOptions, Thunk, ToTsToolbelt, ToTypeFest, ToUtilityTypes, ToolbeltDeepPartial, ToolbeltUnionExclude, ToolbeltUnionPick, type Trace, type TraceContext, type TraceStatus, type Tracer, Transaction, type TransformStreamLike, Transition, type TransitionAction, type TransitionCondition, Tree, TreeDepth, TreeFlatten, TreeLeaves, TreeNode, TreePath, Trim, TrimLeft, TrimRight, TupleLength, TypeCache, TypeCategory, TypeComplexity, TypeCoverage, TypeEq, TypeEvery, TypeFestCamelCase, TypeFestSnakeCase, TypeFilter, TypeFind, TypeIdentity, TypeIncludes, TypeInfo, type TypeMap, TypePredicate, type TypeSet, TypeSome, TypeTest, TypeTestResult, TypeTestSuite, TypeToGraphQL, TypeToGuardKey, type TypedEventTarget, type URLConstraint, type UUIDConstraint, Unbrand, UncapitalizeAll, UncoveredTypes, UndefinedGuard, UnionGuard, UnionToIntersection, UnionToTuple, type Unique, UniqueIndex, UnwrapPromise, UpdateQuery, UpperCase, UtilityDeepPartial, UtilityDeepReadonly, UtilityMap, ValidPath, ValidTransitions, type ValidationContext, type ValidationError, type ValidationOptions, type ValidationRule, type Validator, type ValidatorResult, ValueOf, VueComponentInstance, VueComputed, VueEmitType, VueExpose, VueInjectionKey, VueModelProps, VuePropConstructor, VuePropType, VuePropWithDefault, VuePropsToType, VueProvideInjectPair, VueRawProps, VueReactive, VueRef, VueSlot, VueSlots, type WebSocketConfig, type WebSocketEvent, type EventHandler$1 as WebSocketEventHandler, type WebSocketHandler, type WebSocketMessage, type WebSocketOptions, type WebSocketState, WhereBuilder, WhereClause, Worker, WorkerOptions, WorkerPool, WorkerTask, type Workflow, type WorkflowDefinition, type WorkflowEngine, type WorkflowEngineConfig, type WorkflowError, type WorkflowErrorHandler, type WorkflowExecution, type WorkflowExecutor, type WorkflowHistory, type WorkflowInstance, type WorkflowPersistence, type RetryPolicy$1 as WorkflowRetryPolicy, type WorkflowStatus, type WorkflowStep, type StepStatus$1 as WorkflowStepStatus, type WorkflowTimeout, type WorkflowTransition, WrapPromise, WritableKeys, type WritableStreamLike, type WriteBehindCache, type WriteThroughCache, YupArrayElement, YupErrorType, YupFields, YupInput, YupOptionalKeys, YupOutput, YupRequiredKeys, YupSchemaStub, YupTestConfig, YupToType, YupTransform, YupTypeNames, YupUnwrapOptional, ZodArrayElement, ZodDeepPartialInput, ZodErrorType, ZodInput, ZodMapEntry, ZodObjectShapeStub, ZodOmit, ZodOptionalKeys, ZodOutput, ZodPick, ZodRecordValue, ZodRequiredKeys, ZodShape, ZodToType, ZodTypeNames, ZodTypeStub, ZodUnwrapNullable, ZodUnwrapOptional };