@beethovn/errors 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Beethovn Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,375 @@
+# @beethovn/errors
+
+Standardized error types for the Beethovn platform. Provides structured, typed errors with rich metadata for better debugging, logging, and monitoring.
+
+## Installation
+
+```bash
+pnpm add @beethovn/errors
+```
+
+## Quick Start
+
+```typescript
+import { ValidationError, ErrorFactory, isDomainError } from '@beethovn/errors';
+
+// Throw typed errors
+if (!email.includes('@')) {
+  throw new ValidationError('Invalid email format', 'email');
+}
+
+// Handle unknown errors
+try {
+  await riskyOperation();
+} catch (error: unknown) {
+  const beethovnError = ErrorFactory.fromUnknown(error, 'riskyOperation');
+  logger.error('Operation failed', beethovnError.toJSON());
+  
+  if (isDomainError(error)) {
+    // User-fixable error
+    return { error: beethovnError.toClient() };
+  }
+}
+```
+
+## Error Hierarchy
+
+```
+BeethovnError (base)
+├── DomainError (business logic)
+│   ├── ValidationError
+│   ├── BusinessRuleError
+│   ├── NotFoundError
+│   ├── ConflictError
+│   └── InvalidStateError
+├── InfrastructureError (technical)
+│   ├── DatabaseError
+│   ├── NetworkError
+│   ├── ExternalServiceError
+│   ├── TimeoutError
+│   ├── RateLimitError
+│   └── UnknownError
+├── AuthError (authentication/authorization)
+│   ├── InvalidCredentialsError
+│   ├── TokenExpiredError
+│   ├── InvalidTokenError
+│   ├── PermissionDeniedError
+│   ├── ForbiddenError
+│   └── UnauthenticatedError
+└── IntegrationError (inter-service communication)
+    ├── EventPublishError
+    ├── MessageQueueError
+    ├── WebSocketError
+    └── EventSubscriptionError
+```
+
+## Usage Examples
+
+### Domain Errors
+
+```typescript
+import {
+  ValidationError,
+  BusinessRuleError,
+  NotFoundError,
+  ConflictError,
+} from '@beethovn/errors';
+
+// Validation error
+if (!email.includes('@')) {
+  throw new ValidationError('Invalid email format', 'email', {
+    value: email,
+  });
+}
+
+// Business rule violation
+if (balance < amount) {
+  throw new BusinessRuleError(
+    'Insufficient balance',
+    'MINIMUM_BALANCE',
+    { balance, required: amount }
+  );
+}
+
+// Not found
+const user = await db.getUser(id);
+if (!user) {
+  throw new NotFoundError('User', id, { tenantId });
+}
+
+// Conflict
+if (existingUser) {
+  throw new ConflictError(
+    'User with this email already exists',
+    { email }
+  );
+}
+```
+
+### Infrastructure Errors
+
+```typescript
+import {
+  DatabaseError,
+  NetworkError,
+  ExternalServiceError,
+  TimeoutError,
+} from '@beethovn/errors';
+
+// Database error
+try {
+  await db.query(sql, params);
+} catch (error: unknown) {
+  throw new DatabaseError('saveUser', error, { userId });
+}
+
+// Network error
+try {
+  const response = await fetch(url);
+} catch (error: unknown) {
+  throw new NetworkError('Failed to fetch user data', { url, method: 'GET' });
+}
+
+// External service error
+try {
+  await stripeClient.charge(amount);
+} catch (error: unknown) {
+  throw new ExternalServiceError(
+    'Stripe',
+    'createCharge',
+    error,
+    { amount, currency }
+  );
+}
+
+// Timeout error
+throw new TimeoutError('Database query', 5000, { query: sql });
+```
+
+### Auth Errors
+
+```typescript
+import {
+  InvalidCredentialsError,
+  TokenExpiredError,
+  PermissionDeniedError,
+} from '@beethovn/errors';
+
+// Invalid credentials
+const user = await verifyCredentials(email, password);
+if (!user) {
+  throw new InvalidCredentialsError({ email });
+}
+
+// Token expired
+if (token.exp < Date.now()) {
+  throw new TokenExpiredError({ userId: token.sub });
+}
+
+// Permission denied
+if (!user.permissions.includes('delete:product')) {
+  throw new PermissionDeniedError('Product', 'delete', {
+    userId: user.id,
+    requiredPermission: 'delete:product',
+  });
+}
+```
+
+### Error Factory
+
+```typescript
+import { ErrorFactory } from '@beethovn/errors';
+
+// Convert unknown errors
+try {
+  await operation();
+} catch (error: unknown) {
+  throw ErrorFactory.fromUnknown(error, 'operationContext');
+}
+
+// Create database error
+throw ErrorFactory.database('saveUser', error, { userId });
+
+// Create validation error
+throw ErrorFactory.validation('Invalid email', 'email');
+
+// Aggregate multiple errors
+const errors = [
+  new ValidationError('Invalid email', 'email'),
+  new ValidationError('Invalid age', 'age'),
+];
+throw ErrorFactory.aggregate(errors, 'User validation');
+```
+
+### Type Guards
+
+```typescript
+import {
+  isBeethovnError,
+  isDomainError,
+  isInfrastructureError,
+  isRecoverableError,
+  isClientSafeError,
+} from '@beethovn/errors';
+
+try {
+  await operation();
+} catch (error: unknown) {
+  if (isBeethovnError(error)) {
+    logger.error('Beethovn error', error.toJSON());
+  }
+  
+  if (isDomainError(error)) {
+    // User-fixable error - return helpful message
+    return { error: error.toClient() };
+  }
+  
+  if (isInfrastructureError(error) && error.recoverable) {
+    // Retry recoverable infrastructure errors
+    await retryWithBackoff(operation);
+  }
+  
+  if (isClientSafeError(error)) {
+    // Safe to send to client
+    res.status(error.statusCode).json(error.toClient());
+  } else {
+    // Internal error - don't expose details
+    res.status(500).json({ error: 'Internal server error' });
+  }
+}
+```
+
+## Error Properties
+
+All errors extend `BeethovnError` and include:
+
+- `code` - Unique error code (e.g., 'VALIDATION_ERROR')
+- `statusCode` - HTTP status code (e.g., 400, 404, 500)
+- `message` - Human-readable error message
+- `metadata` - Additional context for debugging
+- `timestamp` - When the error occurred
+- `recoverable` - Whether the error can be retried
+- `stack` - Stack trace for debugging
+
+## Error Methods
+
+### `toJSON()`
+
+Serialize error for logging and monitoring (includes all details):
+
+```typescript
+const error = new ValidationError('Invalid email', 'email');
+logger.error('Validation failed', error.toJSON());
+// {
+//   name: 'ValidationError',
+//   code: 'VALIDATION_ERROR',
+//   message: 'Invalid email',
+//   statusCode: 400,
+//   metadata: { field: 'email' },
+//   timestamp: '2025-01-03T10:00:00.000Z',
+//   recoverable: false,
+//   stack: '...'
+// }
+```
+
+### `toClient()`
+
+Sanitized error for API responses (excludes stack trace and sensitive data):
+
+```typescript
+const error = new ValidationError('Invalid email', 'email');
+res.status(error.statusCode).json(error.toClient());
+// {
+//   code: 'VALIDATION_ERROR',
+//   message: 'Invalid email',
+//   statusCode: 400,
+//   timestamp: '2025-01-03T10:00:00.000Z'
+// }
+```
+
+## Integration with DbResult
+
+```typescript
+import { DbResult } from '@beethovn/types';
+import { NotFoundError, ErrorFactory } from '@beethovn/errors';
+
+async function getUser(id: string): Promise<DbResult<User>> {
+  try {
+    const user = await db.query('SELECT * FROM users WHERE id = $1', [id]);
+    
+    if (!user) {
+      return {
+        data: null,
+        error: new NotFoundError('User', id),
+      };
+    }
+    
+    return { data: user, error: null };
+  } catch (error: unknown) {
+    return {
+      data: null,
+      error: ErrorFactory.database('getUser', error, { userId: id }),
+    };
+  }
+}
+```
+
+## Best Practices
+
+1. **Always use typed errors** - Never throw generic `Error`
+2. **Include context** - Add relevant metadata for debugging
+3. **Use ErrorFactory.fromUnknown** - For handling unknown errors
+4. **Check recoverability** - Retry recoverable errors
+5. **Sanitize client responses** - Use `toClient()` for API responses
+6. **Log with toJSON()** - Include full error details in logs
+7. **Use type guards** - Handle different error types appropriately
+
+## Error Decision Tree
+
+```
+Is this a business logic issue?
+├─ YES → Use DomainError
+│   ├─ Invalid input? → ValidationError
+│   ├─ Rule violation? → BusinessRuleError
+│   ├─ Not found? → NotFoundError
+│   └─ Already exists? → ConflictError
+│
+└─ NO → Is it a technical issue?
+    ├─ YES → Use InfrastructureError
+    │   ├─ Database? → DatabaseError
+    │   ├─ Network? → NetworkError
+    │   └─ External service? → ExternalServiceError
+    │
+    └─ NO → Is it auth/authz?
+        ├─ YES → Use AuthError
+        └─ NO → Use ErrorFactory.fromUnknown()
+```
+
+## TypeScript Support
+
+Full TypeScript support with type inference:
+
+```typescript
+import { BeethovnError, ValidationError } from '@beethovn/errors';
+
+function handleError(error: BeethovnError) {
+  // TypeScript knows all properties
+  console.log(error.code);      // ✓ string
+  console.log(error.statusCode); // ✓ number
+  console.log(error.metadata);   // ✓ Record<string, unknown>
+}
+
+// Type narrowing with type guards
+if (error instanceof ValidationError) {
+  // TypeScript knows this is ValidationError
+  console.log(error.metadata.field); // ✓ unknown
+}
+```
+
+## License
+
+MIT
+
+## Contributing
+
+See [CONTRIBUTING.md](../../CONTRIBUTING.md)

package/dist/auth/AuthError.d.ts

@@ -0,0 +1,95 @@
+import { BeethovnError } from '../base/BeethovnError.js';
+/**
+ * Base class for authentication and authorization errors
+ *
+ * Auth errors represent issues with authentication (identity verification)
+ * and authorization (permission checks). These are typically not recoverable.
+ */
+export declare abstract class AuthError extends BeethovnError {
+    constructor(message: string, code: string, statusCode?: number, metadata?: Record<string, unknown>);
+}
+/**
+ * Invalid credentials error
+ *
+ * @example
+ * ```typescript
+ * const user = await verifyCredentials(email, password);
+ * if (!user) {
+ *   throw new InvalidCredentialsError({ email });
+ * }
+ * ```
+ */
+export declare class InvalidCredentialsError extends AuthError {
+    constructor(metadata?: Record<string, unknown>);
+}
+/**
+ * Token expired error
+ *
+ * @example
+ * ```typescript
+ * if (token.exp < Date.now()) {
+ *   throw new TokenExpiredError({ userId: token.sub });
+ * }
+ * ```
+ */
+export declare class TokenExpiredError extends AuthError {
+    constructor(metadata?: Record<string, unknown>);
+}
+/**
+ * Invalid token error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   verifyToken(token);
+ * } catch {
+ *   throw new InvalidTokenError({ token: token.substring(0, 10) + '...' });
+ * }
+ * ```
+ */
+export declare class InvalidTokenError extends AuthError {
+    constructor(metadata?: Record<string, unknown>);
+}
+/**
+ * Permission denied error
+ *
+ * @example
+ * ```typescript
+ * if (!user.permissions.includes('delete:product')) {
+ *   throw new PermissionDeniedError('Product', 'delete', {
+ *     userId: user.id,
+ *     requiredPermission: 'delete:product',
+ *   });
+ * }
+ * ```
+ */
+export declare class PermissionDeniedError extends AuthError {
+    constructor(resource: string, action: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Forbidden error - authenticated but not authorized
+ *
+ * @example
+ * ```typescript
+ * if (resource.tenantId !== user.tenantId) {
+ *   throw new ForbiddenError('Cannot access resource from different tenant');
+ * }
+ * ```
+ */
+export declare class ForbiddenError extends AuthError {
+    constructor(message?: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Unauthenticated error - no valid authentication provided
+ *
+ * @example
+ * ```typescript
+ * if (!req.headers.authorization) {
+ *   throw new UnauthenticatedError('No authentication token provided');
+ * }
+ * ```
+ */
+export declare class UnauthenticatedError extends AuthError {
+    constructor(message?: string, metadata?: Record<string, unknown>);
+}
+//# sourceMappingURL=AuthError.d.ts.map

package/dist/auth/AuthError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthError.d.ts","sourceRoot":"","sources":["../../src/auth/AuthError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;GAKG;AACH,8BAAsB,SAAU,SAAQ,aAAa;gBAEjD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAAY,EACxB,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAIzC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;gBACxC,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAGnD;AAED;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;gBAClC,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAGnD;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;gBAClC,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAGnD;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;gBAEhD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CASzC;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,SAAS;gBAEzC,OAAO,GAAE,MAA2B,EACpC,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAIzC;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;gBAE/C,OAAO,GAAE,MAAkC,EAC3C,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAIzC"}

package/dist/auth/AuthError.js

@@ -0,0 +1,109 @@
+import { BeethovnError } from '../base/BeethovnError.js';
+/**
+ * Base class for authentication and authorization errors
+ *
+ * Auth errors represent issues with authentication (identity verification)
+ * and authorization (permission checks). These are typically not recoverable.
+ */
+export class AuthError extends BeethovnError {
+    constructor(message, code, statusCode = 401, metadata = {}) {
+        super(message, code, statusCode, metadata, false);
+    }
+}
+/**
+ * Invalid credentials error
+ *
+ * @example
+ * ```typescript
+ * const user = await verifyCredentials(email, password);
+ * if (!user) {
+ *   throw new InvalidCredentialsError({ email });
+ * }
+ * ```
+ */
+export class InvalidCredentialsError extends AuthError {
+    constructor(metadata = {}) {
+        super('Invalid credentials', 'INVALID_CREDENTIALS', 401, metadata);
+    }
+}
+/**
+ * Token expired error
+ *
+ * @example
+ * ```typescript
+ * if (token.exp < Date.now()) {
+ *   throw new TokenExpiredError({ userId: token.sub });
+ * }
+ * ```
+ */
+export class TokenExpiredError extends AuthError {
+    constructor(metadata = {}) {
+        super('Token has expired', 'TOKEN_EXPIRED', 401, metadata);
+    }
+}
+/**
+ * Invalid token error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   verifyToken(token);
+ * } catch {
+ *   throw new InvalidTokenError({ token: token.substring(0, 10) + '...' });
+ * }
+ * ```
+ */
+export class InvalidTokenError extends AuthError {
+    constructor(metadata = {}) {
+        super('Invalid or malformed token', 'INVALID_TOKEN', 401, metadata);
+    }
+}
+/**
+ * Permission denied error
+ *
+ * @example
+ * ```typescript
+ * if (!user.permissions.includes('delete:product')) {
+ *   throw new PermissionDeniedError('Product', 'delete', {
+ *     userId: user.id,
+ *     requiredPermission: 'delete:product',
+ *   });
+ * }
+ * ```
+ */
+export class PermissionDeniedError extends AuthError {
+    constructor(resource, action, metadata = {}) {
+        super(`Permission denied: Cannot ${action} ${resource}`, 'PERMISSION_DENIED', 403, { ...metadata, resource, action });
+    }
+}
+/**
+ * Forbidden error - authenticated but not authorized
+ *
+ * @example
+ * ```typescript
+ * if (resource.tenantId !== user.tenantId) {
+ *   throw new ForbiddenError('Cannot access resource from different tenant');
+ * }
+ * ```
+ */
+export class ForbiddenError extends AuthError {
+    constructor(message = 'Access forbidden', metadata = {}) {
+        super(message, 'FORBIDDEN', 403, metadata);
+    }
+}
+/**
+ * Unauthenticated error - no valid authentication provided
+ *
+ * @example
+ * ```typescript
+ * if (!req.headers.authorization) {
+ *   throw new UnauthenticatedError('No authentication token provided');
+ * }
+ * ```
+ */
+export class UnauthenticatedError extends AuthError {
+    constructor(message = 'Authentication required', metadata = {}) {
+        super(message, 'UNAUTHENTICATED', 401, metadata);
+    }
+}
+//# sourceMappingURL=AuthError.js.map

package/dist/auth/AuthError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthError.js","sourceRoot":"","sources":["../../src/auth/AuthError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,OAAgB,SAAU,SAAQ,aAAa;IACnD,YACE,OAAe,EACf,IAAY,EACZ,aAAqB,GAAG,EACxB,WAAoC,EAAE;QAEtC,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,uBAAwB,SAAQ,SAAS;IACpD,YAAY,WAAoC,EAAE;QAChD,KAAK,CAAC,qBAAqB,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IACrE,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,iBAAkB,SAAQ,SAAS;IAC9C,YAAY,WAAoC,EAAE;QAChD,KAAK,CAAC,mBAAmB,EAAE,eAAe,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,iBAAkB,SAAQ,SAAS;IAC9C,YAAY,WAAoC,EAAE;QAChD,KAAK,CAAC,4BAA4B,EAAE,eAAe,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IACtE,CAAC;CACF;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,qBAAsB,SAAQ,SAAS;IAClD,YACE,QAAgB,EAChB,MAAc,EACd,WAAoC,EAAE;QAEtC,KAAK,CACH,6BAA6B,MAAM,IAAI,QAAQ,EAAE,EACjD,mBAAmB,EACnB,GAAG,EACH,EAAE,GAAG,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,CAClC,CAAC;IACJ,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,cAAe,SAAQ,SAAS;IAC3C,YACE,UAAkB,kBAAkB,EACpC,WAAoC,EAAE;QAEtC,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,oBAAqB,SAAQ,SAAS;IACjD,YACE,UAAkB,yBAAyB,EAC3C,WAAoC,EAAE;QAEtC,KAAK,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IACnD,CAAC;CACF"}

package/dist/base/BeethovnError.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Base error class for all Beethovn errors
+ *
+ * Provides structured error information for logging, monitoring, and debugging.
+ * All custom errors in the Beethovn platform should extend this class.
+ *
+ * @example
+ * ```typescript
+ * class MyCustomError extends BeethovnError {
+ *   constructor(message: string) {
+ *     super(message, 'MY_CUSTOM_ERROR', 400, { custom: 'metadata' });
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BeethovnError extends Error {
+    /** Unique error code for categorization and monitoring */
+    readonly code: string;
+    /** HTTP status code (for API errors) */
+    readonly statusCode: number;
+    /** Additional contextual metadata for debugging */
+    readonly metadata: Record<string, unknown>;
+    /** Timestamp when error occurred */
+    readonly timestamp: Date;
+    /** Is this error recoverable with retry logic? */
+    readonly recoverable: boolean;
+    /**
+     * Create a new BeethovnError
+     *
+     * @param message - Human-readable error message
+     * @param code - Unique error code (e.g., 'VALIDATION_ERROR')
+     * @param statusCode - HTTP status code (default: 500)
+     * @param metadata - Additional context for debugging
+     * @param recoverable - Can this error be retried? (default: false)
+     */
+    constructor(message: string, code: string, statusCode?: number, metadata?: Record<string, unknown>, recoverable?: boolean);
+    /**
+     * Serialize error for logging and monitoring
+     *
+     * @returns Plain object representation of the error
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Get a sanitized version of the error for client responses
+     * (Excludes stack traces and sensitive metadata)
+     *
+     * @returns Sanitized error object safe for API responses
+     */
+    toClient(): Record<string, unknown>;
+}
+//# sourceMappingURL=BeethovnError.d.ts.map

package/dist/base/BeethovnError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeethovnError.d.ts","sourceRoot":"","sources":["../../src/base/BeethovnError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,aAAc,SAAQ,KAAK;IAC/C,0DAA0D;IAC1D,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,wCAAwC;IACxC,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC,mDAAmD;IACnD,SAAgB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElD,oCAAoC;IACpC,SAAgB,SAAS,EAAE,IAAI,CAAC;IAEhC,kDAAkD;IAClD,SAAgB,WAAW,EAAE,OAAO,CAAC;IAErC;;;;;;;;OAQG;gBAED,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAAY,EACxB,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACtC,WAAW,GAAE,OAAe;IAc9B;;;;OAIG;IACH,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAajC;;;;;OAKG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAQpC"}