@sudobility/types 1.8.21

package/CLAUDE.md

@@ -0,0 +1,285 @@
+# Claude AI Assistant Configuration
+
+## Project Overview
+
+This is `@johnqh/types` v1.6.2, a comprehensive TypeScript types library for the 0xmail.box ecosystem. It provides shared type definitions, interfaces, enums, and utility functions used across multiple projects in the 0xmail.box Web3 email platform.
+
+## Key Architecture
+
+- **Framework Agnostic**: Pure TypeScript with zero external runtime dependencies
+- **Tree Shakeable**: Optimized for modern bundlers with barrel exports
+- **Dual Module Support**: ESM + CommonJS builds for maximum compatibility
+- **AI-Optimized**: Enhanced documentation and patterns for AI-assisted development
+- **Type-Safe**: Strict TypeScript configuration with comprehensive coverage
+- **Modular Structure**: Domain-organized architecture (business, blockchain, infrastructure, etc.)
+
+## Project Structure
+
+```
+src/
+├── types/                    # Type definitions organized by domain
+│   ├── api/                 # API request/response types
+│   │   ├── index.ts         # Barrel exports for API types
+│   │   ├── indexer-guards.ts # Type guards for API responses
+│   │   └── indexer-responses.ts # Complete API response definitions
+│   ├── blockchain/          # Web3 and blockchain-related types
+│   │   ├── common.ts        # Multi-chain messaging types
+│   │   ├── index.ts         # Blockchain type exports
+│   │   └── validation.ts    # Blockchain validation utilities
+│   ├── business/            # Core business logic types
+│   │   ├── email.ts         # Email and user types
+│   │   ├── enums.ts         # Business logic enums
+│   │   ├── mailbox.ts       # Mailbox and folder types
+│   │   └── wallet-status.ts # Wallet connection state
+│   ├── common.ts            # Shared utility types (Optional<T>, Result<T>)
+│   ├── config/              # Configuration and environment types
+│   └── infrastructure/      # Infrastructure abstractions
+│       ├── analytics.ts     # Analytics service interface
+│       ├── api.ts           # Database entity interfaces
+│       ├── navigation.ts    # UI navigation abstractions
+│       └── network.ts       # Network client interface
+├── utils/                   # Pure utility functions
+│   ├── auth/                # Authentication utilities
+│   ├── blockchain/          # Blockchain utilities
+│   │   ├── address.ts       # Address validation and parsing
+│   │   ├── event-helpers.ts # Multi-chain event utilities
+│   │   └── network-config.ts # Network configuration
+│   ├── constants/           # Shared constants
+│   │   └── status-values.ts # Shared enum values
+│   ├── formatting/          # Formatting utilities
+│   ├── logging/             # Logging utilities
+│   ├── url/                 # URL utilities
+│   └── validation/          # Validation utilities
+│       ├── type-validation.ts # Generic type validation
+│       └── web3-username-validator.ts # Web3 address validation
+├── wildduck-requests.ts     # WildDuck email server API types
+└── index.ts                 # Main export file
+```
+
+## Essential Commands
+
+### Development Commands
+```bash
+# Build the project (dual ESM/CJS output)
+npm run build
+
+# Watch mode for development
+npm run dev
+
+# Run all 267 tests
+npm test
+
+# Type checking
+npm run typecheck
+
+# Linting (ESLint v9)
+npm run lint
+
+# Fix linting issues
+npm run lint:fix
+
+# Format code (Prettier)
+npm run format
+
+# Check formatting
+npm run format:check
+
+# Clean build artifacts
+npm run clean
+
+# Full verification (build + test + lint + typecheck)
+npm run verify
+
+# AI development tools
+npm run ai:analyze        # Analyze type structure
+npm run ai:validate       # Validate exports
+npm run ai:docs          # Generate AI documentation
+```
+
+## Testing Strategy
+
+- **Framework**: Vitest for fast unit testing
+- **Coverage**: 267 comprehensive tests covering all utilities and type guards
+- **Structure**: Tests mirror source structure in `test/` directory
+- **Focus**: Type guards, validation functions, utility functions, and API contracts
+
+## Code Style and Standards
+
+- **TypeScript**: Strict mode with `noUncheckedIndexedAccess` and `exactOptionalPropertyTypes`
+- **ESLint**: Flat config format (ESLint v9+) with TypeScript rules
+- **Prettier**: Code formatting with consistent style
+- **Naming**: PascalCase for types/interfaces, camelCase for functions
+- **Exports**: Barrel exports from index.ts files for tree-shaking
+
+## Domain Knowledge
+
+### 0xmail.box Context
+- **Web3-native email platform**: Blockchain-based messaging system
+- **Multi-chain support**: Ethereum, Polygon, Arbitrum, Optimism, Base, Solana
+- **Wallet-centric**: User management tied to crypto wallet addresses
+- **WildDuck integration**: Email server backend integration
+- **Decentralized identity**: ENS and SNS name support
+
+### Key Types to Know
+
+#### Core Business Types
+- `Email`: Core email message interface with Web3 extensions
+- `User`/`WalletUserData`: User account types with wallet integration
+- `MailBox`, `Folder`: Email organization structures
+- `AuthStatus`, `ConnectionState`: Authentication and connection states
+
+#### Blockchain Types
+- `Message`/`PreparedMessage`: Multi-chain messaging interfaces
+- `MessageRecipient`: Universal address type (EVM/Solana)
+- `TransactionResult`, `TransactionStatus`: Transaction handling
+- `NetworkConfig`, `DeploymentAddresses`: Network configuration
+
+#### Utility Types
+- `Optional<T>`: Null/undefined safe typing (`T | undefined | null`)
+- `Result<T, E>`: Error handling pattern for operations
+- `ValidationResult<T>`: Validation result pattern
+- `PaginatedResponse<T>`: API pagination wrapper
+
+#### Infrastructure Types
+- `ApiResponse<T>`: Unified API response structure
+- `AnalyticsService`: Analytics abstraction interface
+- `NetworkClient`: HTTP client abstraction
+- `UINavigationService`: Navigation abstraction
+
+## Development Guidelines
+
+### Adding New Types
+1. Place in appropriate domain directory under `src/types/`
+2. Export from domain's `index.ts`
+3. Add to main `src/index.ts` if commonly used
+4. Write comprehensive JSDoc comments with examples
+5. Add unit tests for type guards/validators
+6. Update TYPE_CHANGES.md documentation
+
+### Adding Utilities
+1. Place in appropriate utility directory under `src/utils/`
+2. Keep functions pure (no side effects)
+3. Add comprehensive tests with edge cases
+4. Export from utility's `index.ts`
+5. Document with JSDoc including usage examples
+
+### Type Safety Best Practices
+1. Use `Optional<T>` instead of manual `| null | undefined`
+2. Prefer `unknown` over `any` for type safety
+3. Use `Result<T, E>` pattern for error-prone operations
+4. Implement type guards for runtime validation
+5. Leverage utility types for consistent patterns
+
+### Testing New Code
+```bash
+# Run tests in watch mode during development
+npm run test:watch
+
+# Run specific test file
+npm test -- path/to/test.file.ts
+
+# Generate coverage report
+npm run test:coverage
+```
+
+## AI Assistant Specific Notes
+
+### When Working on This Project:
+1. **Always run verification after changes**: `npm run verify`
+2. **Maintain zero dependencies**: Don't add runtime dependencies
+3. **Keep utilities pure**: No side effects in utility functions
+4. **Follow naming conventions**: Established patterns for consistency
+5. **Update documentation**: Keep TYPE_CHANGES.md current
+6. **Test comprehensively**: All new utilities need tests
+
+### Common Tasks:
+- **Adding API response types**: Use consistent `ApiResponse<T>` pattern
+- **Creating type guards**: Follow existing validation patterns
+- **Updating blockchain types**: Consider multi-chain compatibility
+- **Adding utility functions**: Ensure pure functions with comprehensive tests
+- **Consolidating duplicates**: Use established utility types like `Optional<T>`
+
+### Important Files:
+- `src/index.ts`: Main export file - update for commonly used types
+- `src/types/common.ts`: Core utility types - home of `Optional<T>`, `Result<T>`
+- `src/types/business/enums.ts`: Business logic enums with shared constants
+- `TYPE_CHANGES.md`: Comprehensive change documentation
+- `package.json`: Dependencies and scripts (maintain zero runtime deps)
+
+### Build Process:
+1. **Dual output**: TypeScript compilation to both ESM and CJS
+2. **Type definitions**: Generates `.d.ts` files for full TypeScript support
+3. **Tree-shaking**: Optimized exports for modern bundlers
+4. **Verification**: Comprehensive quality pipeline
+
+### Quality Standards:
+- **267 tests passing**: Complete test coverage maintained
+- **Zero lint errors**: ESLint v9 with strict TypeScript rules
+- **Perfect formatting**: Prettier integration
+- **Type safety**: Strict TypeScript with comprehensive checking
+- **Documentation**: JSDoc comments on all public APIs
+
+## Recent Changes (v1.6.2)
+
+### Type System Improvements
+- **Optional<T> Consistency**: Standardized optional type usage throughout
+- **Enhanced Type Safety**: Replaced all `any` types with `unknown`
+- **Shared Constants**: STATUS_VALUES for enum consistency
+- **Field Standardization**: Consistent `txHash` usage across blockchain types
+
+### New Features
+- **Comprehensive Indexer Types**: HeliusTransaction, ErrorResponse, DelegationInfo
+- **Enhanced Validation**: Web3UsernameValidator with multi-chain support
+- **Improved Analytics**: Type-safe analytics event properties
+- **Better Error Handling**: UnifiedError with structured details
+
+### Documentation
+- **AI-Optimized README**: Comprehensive examples and usage patterns
+- **TYPE_CHANGES.md**: Complete change log with migration guidance
+- **Enhanced JSDoc**: Better documentation coverage across all APIs
+- **Development Guides**: Improved contributor documentation
+
+## Migration Guidance
+
+### For Type Consumers
+```typescript
+// Recommended patterns
+import { Optional, Result, ValidationResult } from '@johnqh/types';
+import { ChainType, AuthStatus } from '@johnqh/types';
+import { isEvmAddress, formatWalletAddress } from '@johnqh/types';
+
+// Use Optional<T> for nullable values
+const user: Optional<User> = getUser(); // instead of User | null | undefined
+
+// Use Result<T> for error-prone operations
+const result: Result<User> = validateUser(data); // instead of throwing
+
+// Use proper type guards
+if (isEvmAddress(address)) {
+  // TypeScript knows address is EVM format
+}
+```
+
+### For Library Maintainers
+1. **Backward Compatibility**: All changes maintain compatibility via type aliases
+2. **Deprecation Timeline**: Gradual migration with clear documentation
+3. **Version Strategy**: Semantic versioning with comprehensive change logs
+
+## Future Considerations
+
+### Planned Improvements
+1. **Enhanced Analytics Types**: More comprehensive event tracking
+2. **Advanced Validation**: Schema-based validation utilities
+3. **Better Error Types**: More specific error categorization
+4. **Performance Optimization**: Further tree-shaking improvements
+5. **Documentation**: Interactive type explorer
+
+### Monitoring
+- Track usage of deprecated patterns
+- Monitor for type safety regressions
+- Evaluate bundle size impact
+- Collect developer feedback
+
+---
+
+*This configuration optimizes @johnqh/types for AI-assisted development while maintaining enterprise-grade quality standards.*

package/README.md

@@ -0,0 +1,310 @@
+# @johnqh/types
+
+[![npm version](https://badge.fury.io/js/@johnqh%2Ftypes.svg)](https://badge.fury.io/js/@johnqh%2Ftypes)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Comprehensive TypeScript type definitions and utilities for the 0xmail.box Web3 email ecosystem.**
+
+## 🚀 Overview
+
+This package provides a complete type-safe foundation for 0xmail.box applications, featuring:
+
+- **267 comprehensive tests** ensuring type reliability
+- **Zero runtime dependencies** for optimal performance
+- **Dual module support** (ESM + CommonJS)
+- **Complete TypeScript coverage** with strict type checking
+- **AI-friendly documentation** for enhanced development experience
+
+## 📦 Features
+
+### Core Type System
+- **Business Logic Types**: Email, User, WalletData, MailBox interfaces
+- **Blockchain Types**: Multi-chain support (Ethereum, Solana, Polygon, etc.)
+- **API Types**: Complete request/response type definitions
+- **Infrastructure Types**: Analytics, navigation, network client abstractions
+- **Utility Types**: `Optional<T>`, `Result<T, E>`, `ValidationResult<T>`
+
+### Utilities & Helpers
+- **Address Validation**: EVM, Solana, ENS, SNS address validation
+- **Blockchain Utilities**: Network configuration, chain detection, event helpers
+- **Formatting**: Date, currency, string formatting utilities
+- **Validation**: Type guards, schema validation, Web3 username validation
+- **URL Management**: Type-safe URL parameter handling
+
+### Development Features
+- **Tree Shakeable**: Import only what you need
+- **Framework Agnostic**: Works with React, Vue, Node.js, React Native
+- **Zero Config**: Ready to use out of the box
+- **Type-Safe**: Complete IntelliSense support
+
+## 🛠 Installation
+
+```bash
+npm install @johnqh/types
+```
+
+## 📖 Usage Examples
+
+### Basic Types
+```typescript
+import {
+  Email,
+  User,
+  WalletUserData,
+  AuthStatus,
+  ChainType,
+  Optional
+} from '@johnqh/types';
+
+// Email handling
+const email: Email = {
+  from: 'sender@0xmail.box',
+  to: 'recipient@0xmail.box',
+  subject: 'Web3 Email',
+  body: 'Hello from the blockchain!',
+  id: 'msg_123',
+  timestamp: Date.now(),
+  read: false
+};
+
+// User management with optional fields
+const user: WalletUserData = {
+  walletAddress: '0x742d35Cc6634C0532925a3b8D2C36B7f12345678',
+  chainType: ChainType.EVM,
+  emails: [email],
+  folders: []
+};
+
+// Optional type usage
+const maybeUser: Optional<User> = null; // T | undefined | null
+```
+
+### Blockchain Integration
+```typescript
+import {
+  Message,
+  TransactionResult,
+  MessageType,
+  isEvmAddress,
+  isSolanaAddress
+} from '@johnqh/types';
+
+// Multi-chain message
+const message: Message = {
+  from: '0x742d35Cc6634C0532925a3b8D2C36B7f12345678',
+  to: '9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM',
+  subject: 'Cross-chain message',
+  body: 'EVM to Solana communication',
+  timestamp: Date.now(),
+  txHash: '0x123abc...',
+  messageType: MessageType.PRIORITY
+};
+
+// Address validation
+const evmValid = isEvmAddress('0x742d35Cc6634C0532925a3b8D2C36B7f12345678'); // true
+const solanaValid = isSolanaAddress('9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM'); // true
+```
+
+### API Integration
+```typescript
+import {
+  ApiResponse,
+  ValidationResult,
+  IndexerApiResponse,
+  Result
+} from '@johnqh/types';
+
+// Type-safe API responses
+const apiResponse: ApiResponse<User> = {
+  success: true,
+  data: user,
+  timestamp: new Date().toISOString()
+};
+
+// Result pattern for error handling
+const validateUser = (data: unknown): Result<User> => {
+  // Validation logic...
+  return { success: true, data: user as User };
+};
+```
+
+### Utilities
+```typescript
+import {
+  formatWalletAddress,
+  parseEmailAddress,
+  createMultiChainId,
+  Web3UsernameValidator
+} from '@johnqh/types';
+
+// Address formatting
+const formatted = formatWalletAddress('0x742d35Cc6634C0532925a3b8D2C36B7f12345678');
+// Result: "0x742d...5678"
+
+// Email parsing
+const parsed = parseEmailAddress('user@domain.eth');
+// Result: { address: 'user', domain: 'domain.eth', type: AddressType.ENSName }
+
+// Multi-chain ID generation
+const id = createMultiChainId(1, '0x123...', 0);
+// Result: "1-0x123...-0"
+
+// Web3 username validation
+const validation = Web3UsernameValidator.validate('vitalik.eth');
+// Result: { name: 'vitalik.eth', address: null, chainType: ChainType.EVM }
+```
+
+## 🏗 Project Structure
+
+```
+src/
+├── types/                    # Type definitions by domain
+│   ├── indexer/             # Indexer API request/response types
+│   ├── blockchain/          # Web3 and blockchain types
+│   ├── business/            # Core business logic types
+│   ├── common.ts            # Shared utility types (Optional<T>, Result<T>)
+│   ├── config/              # Configuration types
+│   └── infrastructure/      # Infrastructure abstractions
+├── utils/                   # Pure utility functions
+│   ├── auth/                # Authentication utilities
+│   ├── blockchain/          # Blockchain utilities
+│   ├── constants/           # Shared constants
+│   ├── formatting/          # Formatting utilities
+│   ├── logging/             # Logging utilities
+│   ├── url/                 # URL utilities
+│   └── validation/          # Validation utilities
+├── wildduck-requests.ts     # WildDuck email server types
+└── index.ts                 # Main exports
+```
+
+## 🧪 Development
+
+### Available Scripts
+```bash
+# Development
+npm run build          # Build both ESM and CommonJS
+npm run dev            # Watch mode development
+npm test               # Run all 267 tests
+npm run test:watch     # Watch mode testing
+npm run test:coverage  # Generate coverage report
+
+# Quality Assurance
+npm run lint           # ESLint checking
+npm run lint:fix       # Fix linting issues
+npm run format         # Format with Prettier
+npm run typecheck      # TypeScript type checking
+npm run verify         # Complete verification pipeline
+
+# AI Development Tools
+npm run ai:analyze     # Analyze type structure
+npm run ai:validate    # Validate exports
+npm run ai:docs        # Generate AI documentation
+```
+
+### Quality Standards
+- **100% TypeScript**: Strict mode enabled with comprehensive coverage
+- **267 Tests**: Complete test suite with Vitest
+- **Zero Lint Errors**: ESLint v9 with flat config
+- **Perfect Formatting**: Prettier integration
+- **Dual Module Support**: ESM + CommonJS builds
+
+## 🤖 AI Development Optimization
+
+This project is optimized for AI-assisted development with:
+
+### Enhanced Documentation
+- **Comprehensive JSDoc comments** on all public APIs
+- **Usage examples** for common patterns
+- **Type relationships** clearly documented
+- **Change logs** with migration guides
+
+### AI-Friendly Patterns
+- **Consistent naming conventions** across all types
+- **Semantic type organization** by domain
+- **Clear export patterns** with barrel exports
+- **Utility type composition** for complex scenarios
+
+### Development Support
+- **CLAUDE.md** with project-specific instructions
+- **TYPE_CHANGES.md** documenting all type evolution
+- **AI analysis scripts** for type validation
+- **Comprehensive test coverage** for validation
+
+## 📚 Key Type Categories
+
+### Core Business Types
+- `Email`, `User`, `WalletUserData` - Core application entities
+- `MailBox`, `Folder` - Email organization structures
+- `AuthStatus`, `ConnectionState` - Authentication states
+
+### Blockchain Types
+- `Message`, `PreparedMessage` - Multi-chain messaging
+- `TransactionResult`, `TransactionStatus` - Transaction handling
+- `NetworkConfig`, `DeploymentAddresses` - Network configuration
+
+### Utility Types
+- `Optional<T>` - Null/undefined safe typing
+- `Result<T, E>` - Error handling patterns
+- `ValidationResult<T>` - Validation patterns
+- `PaginatedResponse<T>` - API pagination
+
+### Infrastructure Types
+- `AnalyticsService` - Analytics abstraction
+- `NetworkClient` - HTTP client interface
+- `UINavigationService` - Navigation abstraction
+
+## 🔧 Configuration
+
+### TypeScript Config
+The package is built with strict TypeScript settings:
+```json
+{
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true
+  }
+}
+```
+
+### Import Patterns
+```typescript
+// Main exports
+import { Email, User, Optional } from '@johnqh/types';
+
+// Specific modules (tree-shakeable)
+import { ChainType } from '@johnqh/types/enums';
+import { ValidationResponse } from '@johnqh/types/indexer';
+
+// Utilities
+import { formatWalletAddress } from '@johnqh/types/utils';
+```
+
+## 🔄 Recent Updates (v1.6.2)
+
+- ✅ **Optional<T> Consistency**: Standardized optional type usage
+- ✅ **Enhanced Type Safety**: Replaced `any` with `unknown` throughout
+- ✅ **Improved Documentation**: Comprehensive JSDoc coverage
+- ✅ **Better AI Support**: Enhanced for AI-assisted development
+- ✅ **Performance**: Zero runtime dependencies maintained
+
+## 🤝 Contributing
+
+This project follows strict quality standards:
+
+1. **All types must have JSDoc documentation**
+2. **Comprehensive tests required for utilities**
+3. **Zero external runtime dependencies**
+4. **Backward compatibility maintained**
+5. **AI-friendly code patterns**
+
+## 📄 License
+
+MIT © 0xmail.box
+
+---
+
+**Built with ❤️ for the Web3 email revolution**
+
+*This package powers the type-safe foundation of 0xmail.box, the first Web3-native email platform.*

package/dist/index.cjs

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * @johnqh/types - Common TypeScript types for 0xmail.box projects
+ *
+ * This package contains all shared TypeScript definitions used across
+ * the 0xmail.box ecosystem including business logic types, blockchain
+ * types, configuration interfaces, infrastructure types, and utility functions.
+ *
+ * @version 1.0.0
+ * @license MIT
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageType = exports.WalletType = exports.ChainType = exports.AnalyticsEvent = exports.TransactionStatus = exports.MessageType = exports.NotificationType = exports.RequestStatus = exports.MobileView = exports.EmailComposeType = exports.FontSize = exports.Theme = exports.Chain = exports.AuthStatus = exports.debounceAsync = exports.clearExpiredCache = exports.withCache = exports.withTimeout = exports.safeParallel = exports.withLoadingState = exports.safeAsync = exports.RpcHelpers = void 0;
+// Re-export all types from the types module
+__exportStar(require("./types"), exports);
+// Re-export all utilities
+__exportStar(require("./utils"), exports);
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "RpcHelpers", { enumerable: true, get: function () { return utils_1.RpcHelpers; } });
+// Export async utilities
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "safeAsync", { enumerable: true, get: function () { return utils_2.safeAsync; } });
+Object.defineProperty(exports, "withLoadingState", { enumerable: true, get: function () { return utils_2.withLoadingState; } });
+Object.defineProperty(exports, "safeParallel", { enumerable: true, get: function () { return utils_2.safeParallel; } });
+Object.defineProperty(exports, "withTimeout", { enumerable: true, get: function () { return utils_2.withTimeout; } });
+Object.defineProperty(exports, "withCache", { enumerable: true, get: function () { return utils_2.withCache; } });
+Object.defineProperty(exports, "clearExpiredCache", { enumerable: true, get: function () { return utils_2.clearExpiredCache; } });
+Object.defineProperty(exports, "debounceAsync", { enumerable: true, get: function () { return utils_2.debounceAsync; } });
+// Export the most commonly used enums
+var types_1 = require("./types");
+// Business enums
+Object.defineProperty(exports, "AuthStatus", { enumerable: true, get: function () { return types_1.AuthStatus; } });
+Object.defineProperty(exports, "Chain", { enumerable: true, get: function () { return types_1.Chain; } });
+Object.defineProperty(exports, "Theme", { enumerable: true, get: function () { return types_1.Theme; } });
+Object.defineProperty(exports, "FontSize", { enumerable: true, get: function () { return types_1.FontSize; } });
+Object.defineProperty(exports, "EmailComposeType", { enumerable: true, get: function () { return types_1.EmailComposeType; } });
+Object.defineProperty(exports, "MobileView", { enumerable: true, get: function () { return types_1.MobileView; } });
+Object.defineProperty(exports, "RequestStatus", { enumerable: true, get: function () { return types_1.RequestStatus; } });
+Object.defineProperty(exports, "NotificationType", { enumerable: true, get: function () { return types_1.NotificationType; } });
+// Blockchain enums
+Object.defineProperty(exports, "MessageType", { enumerable: true, get: function () { return types_1.MessageType; } });
+Object.defineProperty(exports, "TransactionStatus", { enumerable: true, get: function () { return types_1.TransactionStatus; } });
+// Infrastructure enums
+Object.defineProperty(exports, "AnalyticsEvent", { enumerable: true, get: function () { return types_1.AnalyticsEvent; } });
+Object.defineProperty(exports, "ChainType", { enumerable: true, get: function () { return types_1.ChainType; } });
+Object.defineProperty(exports, "WalletType", { enumerable: true, get: function () { return types_1.WalletType; } });
+Object.defineProperty(exports, "StorageType", { enumerable: true, get: function () { return types_1.StorageType; } });
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @johnqh/types - Common TypeScript types for 0xmail.box projects
+ *
+ * This package contains all shared TypeScript definitions used across
+ * the 0xmail.box ecosystem including business logic types, blockchain
+ * types, configuration interfaces, infrastructure types, and utility functions.
+ *
+ * @version 1.0.0
+ * @license MIT
+ */
+export * from './types';
+export * from './utils';
+export type { AppConfig, FirebaseConfig, EnvironmentVariables, ChainConfig, Message, MessageRecipient, TransactionResult, AnalyticsEventProperties, AnalyticsService, NetworkClient, NetworkResponse, UINavigationService, BaseTransactionResponse, TransactionReceipt, MessageSendResponse, PreparedMessageSendResponse, ClaimableInfo, ClaimRevenueResponse, ClaimableAmountResponse, DomainRegistrationResponse, MailboxDelegationResponse, DelegationRejectionResponse, FeeInfo, FeeUpdateResponse, PauseInfo, PauseResponse, EmergencyDistributionResponse, EVMTransactionResponse, SolanaTransactionResponse, UnifiedClientResponse, BatchOperationResponse, MessageHistoryResponse, DelegationStatusResponse, ContractError, IndexerNameServiceAccount, IndexerWalletAccount, IndexerEmailAccountsResult, IndexerEmailAccountsResponse, IndexerRewardData, IndexerRewardHistoryData, IndexerRewardsResponse, IndexerAddressValidationData, IndexerAddressValidationResponse, IndexerDelegateData, IndexerDelegatedToResponse, IndexerDelegatedFromData, IndexerDelegatedFromResponse, IndexerNonceData, IndexerNonceResponse, IndexerEntitlementInfo, IndexerEntitlementData, IndexerEntitlementResponse, IndexerSignInMessageData, IndexerSignInMessageResponse, IndexerPointsData, IndexerPointsResponse, IndexerLeaderboardData, IndexerLeaderboardResponse, IndexerSiteStatsData, IndexerSiteStatsResponse, IndexerReferralCodeData, IndexerReferralCodeResponse, IndexerReferralConsumptionData, IndexerReferralStatsData, IndexerReferralStatsResponse, IndexerAuthenticationStatusData, IndexerAuthenticationStatusResponse, IndexerChainBlockInfo, IndexerBlockStatusData, IndexerBlockStatusResponse, IndexerNameServiceData, IndexerNameServiceResponse, IndexerNameResolutionData, IndexerNameResolutionResponse, IndexerErrorResponse, IndexerApiResponse, KYCApplication, VerificationResult, UserConsent, InitiateKYCRequest, InitiateKYCResponse, GetKYCStatusResponse, VerifyUserRequest, VerifyUserResponse, KYCVerificationLevel, KYCApplicationStatus, } from './types';
+export type { BlockchainApis } from './utils';
+export { RpcHelpers } from './utils';
+export { safeAsync, withLoadingState, safeParallel, withTimeout, withCache, clearExpiredCache, debounceAsync, type AsyncResult, } from './utils';
+export { AuthStatus, Chain, Theme, FontSize, EmailComposeType, MobileView, RequestStatus, NotificationType, MessageType, TransactionStatus, AnalyticsEvent, ChainType, WalletType, StorageType, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,SAAS,CAAC;AAGxB,cAAc,SAAS,CAAC;AAIxB,YAAY,EAEV,SAAS,EACT,cAAc,EACd,oBAAoB,EAGpB,WAAW,EACX,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EAGjB,wBAAwB,EACxB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,mBAAmB,EAGnB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,2BAA2B,EAC3B,aAAa,EACb,oBAAoB,EACpB,uBAAuB,EACvB,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,OAAO,EACP,iBAAiB,EACjB,SAAS,EACT,aAAa,EACb,6BAA6B,EAC7B,sBAAsB,EACtB,yBAAyB,EACzB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,aAAa,EAGb,yBAAyB,EACzB,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,EACtB,4BAA4B,EAC5B,gCAAgC,EAChC,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,4BAA4B,EAC5B,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,0BAA0B,EAC1B,wBAAwB,EACxB,4BAA4B,EAC5B,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,0BAA0B,EAC1B,oBAAoB,EACpB,wBAAwB,EACxB,uBAAuB,EACvB,2BAA2B,EAC3B,8BAA8B,EAC9B,wBAAwB,EACxB,4BAA4B,EAC5B,+BAA+B,EAC/B,mCAAmC,EACnC,qBAAqB,EACrB,sBAAsB,EACtB,0BAA0B,EAC1B,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,EACzB,6BAA6B,EAC7B,oBAAoB,EACpB,kBAAkB,EAGlB,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,KAAK,WAAW,GACjB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAEL,UAAU,EACV,KAAK,EACL,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,UAAU,EACV,aAAa,EACb,gBAAgB,EAGhB,WAAW,EACX,iBAAiB,EAGjB,cAAc,EACd,SAAS,EACT,UAAU,EACV,WAAW,GACZ,MAAM,SAAS,CAAC"}