@gala-chain/launchpad-sdk 5.0.2-beta.1 → 5.0.4-beta.0

package/dist/src/utils/error-patterns.d.ts

@@ -0,0 +1,360 @@
+/**
+ * Error Pattern Utilities
+ *
+ * Advanced error extraction and handling patterns that consolidate
+ * 7 frequently-repeated error handling idioms across 100+ files.
+ *
+ * @category Utilities
+ * @since 6.17.0
+ */
+/**
+ * Extract error message from any error type with safe fallbacks
+ *
+ * Handles multiple error formats and provides sensible defaults.
+ * Consolidates 47 occurrences of pattern: `error.message || String(error) || 'Unknown error'`.
+ *
+ * Supports:
+ * - Error instances (error.message)
+ * - Objects with message property ({ message: "..." })
+ * - String errors ("error message")
+ * - Other types (converted to string)
+ * - null/undefined (returns fallback)
+ *
+ * @param error Unknown error value from catch block
+ * @returns Safe string representation of the error, never null/undefined
+ *
+ * @example Basic usage
+ * ```typescript
+ * try {
+ *   await operation();
+ * } catch (error: unknown) {
+ *   const msg = extractErrorMessageFromUnknown(error);
+ *   logger.error(`Failed: ${msg}`); // Safe - always a string
+ * }
+ * ```
+ *
+ * @example With custom fallback
+ * ```typescript
+ * try {
+ *   await riskyOperation();
+ * } catch (error: unknown) {
+ *   // Use default fallback
+ *   const message = extractErrorMessageFromUnknown(error);
+ *   console.log(message); // "Unknown error" if error is null
+ * }
+ * ```
+ *
+ * @example Multiple error types
+ * ```typescript
+ * // Error instance
+ * extractErrorMessageFromUnknown(new Error('Test')) // → "Test"
+ *
+ * // Object with message
+ * extractErrorMessageFromUnknown({ message: 'API error' }) // → "API error"
+ *
+ * // String error
+ * extractErrorMessageFromUnknown('Error string') // → "Error string"
+ *
+ * // null/undefined
+ * extractErrorMessageFromUnknown(null) // → "Unknown error"
+ * extractErrorMessageFromUnknown(undefined) // → "Unknown error"
+ * ```
+ *
+ * @since 6.17.0
+ */
+export declare function extractErrorMessageFromUnknown(error: unknown): string;
+/**
+ * Generic GSwap error handler with fallback message
+ *
+ * Consolidates 18 occurrences of pattern:
+ * `if (isAxiosError) { extract status } else { generic message }`.
+ *
+ * Provides consistent error handling across GSwap service operations.
+ *
+ * @param error Unknown error from GSwap operation
+ * @param context Operation context for error message (e.g., "quote generation")
+ * @returns Error with context-prefixed message, preserving original error if HTTP error
+ *
+ * @example GSwap quote error
+ * ```typescript
+ * try {
+ *   const quote = await gswapClient.getQuote(params);
+ * } catch (error: unknown) {
+ *   throw handleGSwapErrorGeneric(error, 'quote generation');
+ *   // Throws: Error("GSwap quote generation failed: ...")
+ * }
+ * ```
+ *
+ * @example GSwap pool error
+ * ```typescript
+ * try {
+ *   const pool = await gswapClient.getPoolInfo('GALA', 'GUSDC');
+ * } catch (error: unknown) {
+ *   throw handleGSwapErrorGeneric(error, 'pool info retrieval');
+ *   // Throws: Error("GSwap pool info retrieval failed: ...")
+ * }
+ * ```
+ *
+ * @example HTTP error with status code
+ * ```typescript
+ * try {
+ *   await gswapClient.executeSwap(params);
+ * } catch (error: unknown) {
+ *   const err = handleGSwapErrorGeneric(error, 'swap execution');
+ *   // If HTTP error (404): Error with additional context
+ *   // If network error: Generic error with message
+ * }
+ * ```
+ *
+ * @since 6.17.0
+ */
+export declare function handleGSwapErrorGeneric(error: unknown, context: string): Error;
+/**
+ * Log error with full stack trace and context
+ *
+ * Consolidates 11 occurrences of manual console.error + stack trace extraction.
+ * Side-effect function that logs to console or optional logger.
+ *
+ * @param error Unknown error to log
+ * @param context Operation context for log message
+ * @param logger Optional logger object (defaults to console)
+ * @returns void (side-effect function, does not return value)
+ *
+ * @example Basic logging
+ * ```typescript
+ * try {
+ *   await operation();
+ * } catch (error: unknown) {
+ *   logErrorWithStack(error, 'Operation failed');
+ *   // Logs to console: "Operation failed: <message> <stack>"
+ * }
+ * ```
+ *
+ * @example With custom logger
+ * ```typescript
+ * try {
+ *   await complexOperation();
+ * } catch (error: unknown) {
+ *   logErrorWithStack(error, 'Complex operation', logger);
+ *   // Logs via logger.error()
+ * }
+ * ```
+ *
+ * @example Without throwing
+ * ```typescript
+ * // Log but don't rethrow
+ * try {
+ *   await nonCriticalOperation();
+ * } catch (error: unknown) {
+ *   logErrorWithStack(error, 'Non-critical failed');
+ *   // Continue execution
+ * }
+ * ```
+ *
+ * @since 6.17.0
+ */
+export declare function logErrorWithStack(error: unknown, context: string, logger?: {
+    error: (message: string) => void;
+}): void;
+/**
+ * Cast unknown error to object with guaranteed message property
+ *
+ * Consolidates 8 occurrences of unsafe type assertions like `(error as Error)`.
+ * Returns object with message property and all original properties.
+ *
+ * @param error Unknown error value
+ * @returns Object with guaranteed message property + any original properties
+ *
+ * @example Error instance
+ * ```typescript
+ * const err = castErrorToObject(new Error('test'));
+ * // → { message: "test", [Error properties] }
+ * ```
+ *
+ * @example Object without message
+ * ```typescript
+ * const err = castErrorToObject({ code: 500 });
+ * // → { message: "Unknown error", code: 500 }
+ * ```
+ *
+ * @example null/undefined
+ * ```typescript
+ * const err = castErrorToObject(null);
+ * // → { message: "Unknown error" }
+ * ```
+ *
+ * @example String error
+ * ```typescript
+ * const err = castErrorToObject('Network timeout');
+ * // → { message: "Network timeout" }
+ * ```
+ *
+ * @since 6.17.0
+ */
+export declare function castErrorToObject(error: unknown): {
+    message: string;
+    [key: string]: unknown;
+};
+/**
+ * Safely extract field from error response object
+ *
+ * Consolidates 7 occurrences of pattern: `error?.response?.data?.message`
+ * Supports nested field access with dot notation.
+ *
+ * @param error Unknown error object
+ * @param fieldPath Dot-notation path to field (e.g., "response.data.error.code")
+ * @returns Field value if found, undefined if not found or path invalid
+ *
+ * @example Extract status code
+ * ```typescript
+ * try {
+ *   await api.get('/endpoint');
+ * } catch (error: unknown) {
+ *   const status = getErrorResponseField(error, 'response.status');
+ *   if (status === 404) {
+ *     console.log('Not found');
+ *   }
+ * }
+ * ```
+ *
+ * @example Extract nested error message
+ * ```typescript
+ * try {
+ *   await operation();
+ * } catch (error: unknown) {
+ *   const msg = getErrorResponseField(error, 'response.data.error.message');
+ *   console.log(msg || 'Unknown error');
+ * }
+ * ```
+ *
+ * @example API error with code
+ * ```typescript
+ * try {
+ *   await galachain.call();
+ * } catch (error: unknown) {
+ *   const code = getErrorResponseField(error, 'response.data.code');
+ *   const message = getErrorResponseField(error, 'response.data.Message');
+ *   logError(`${code}: ${message}`);
+ * }
+ * ```
+ *
+ * @since 6.17.0
+ */
+export declare function getErrorResponseField(error: unknown, fieldPath: string): unknown;
+/**
+ * Collect the last error from Promise.allSettled results
+ *
+ * Consolidates 6 occurrences of pattern: manual loop through results
+ * to find rejected promises and extract error.
+ *
+ * Returns the last (most recent) error from rejected promises,
+ * or undefined if all promises succeeded.
+ *
+ * @param results Array of Promise settlement results
+ * @returns Last error found in rejected promises, undefined if no errors
+ *
+ * @example Batch operation with error handling
+ * ```typescript
+ * const results = await Promise.allSettled([
+ *   operation1(),
+ *   operation2(),
+ *   operation3(),
+ * ]);
+ *
+ * const lastError = collectLastError(results);
+ * if (lastError) {
+ *   console.log('At least one operation failed:', lastError.message);
+ * }
+ * ```
+ *
+ * @example Parallel transfers with fallback
+ * ```typescript
+ * const transfers = await Promise.allSettled([
+ *   sdk.transferToken({ to: addr1, amount: '100' }),
+ *   sdk.transferToken({ to: addr2, amount: '200' }),
+ *   sdk.transferToken({ to: addr3, amount: '150' }),
+ * ]);
+ *
+ * const error = collectLastError(transfers);
+ * if (error) {
+ *   throw new Error(`Transfer batch failed: ${error.message}`);
+ * }
+ * ```
+ *
+ * @example All promises succeeded
+ * ```typescript
+ * const results = await Promise.allSettled([
+ *   operation1(),
+ *   operation2(),
+ * ]);
+ *
+ * const error = collectLastError(results);
+ * // error is undefined (all succeeded)
+ * ```
+ *
+ * @since 6.17.0
+ */
+export declare function collectLastError(results: PromiseSettledResult<unknown>[]): Error | undefined;
+/**
+ * Type guard for errors matching specific error pattern
+ *
+ * Consolidates 4 occurrences of pattern: `error instanceof Error && error.name === 'X'`.
+ * Supports optional name and message pattern matching.
+ *
+ * @param error Unknown error value to check
+ * @param name Optional error constructor name to match
+ * @param messagePattern Optional regex pattern to match against error message
+ * @returns Type guard: true if error matches pattern, false otherwise
+ *
+ * @example Check for ValidationError
+ * ```typescript
+ * try {
+ *   validate(data);
+ * } catch (error: unknown) {
+ *   if (isErrorWithNameAndMessagePattern(error, 'ValidationError')) {
+ *     console.log('Validation failed:', error.message);
+ *   }
+ * }
+ * ```
+ *
+ * @example Check by name only
+ * ```typescript
+ * try {
+ *   await operation();
+ * } catch (error: unknown) {
+ *   if (isErrorWithNameAndMessagePattern(error, 'TimeoutError')) {
+ *     console.log('Operation timed out');
+ *   }
+ * }
+ * ```
+ *
+ * @example Check with message pattern
+ * ```typescript
+ * try {
+ *   await galachain.call();
+ * } catch (error: unknown) {
+ *   // Match GalaChain status errors
+ *   if (isErrorWithNameAndMessagePattern(error, 'Error', /status indicates failure/i)) {
+ *     console.log('GalaChain status check failed');
+ *   }
+ * }
+ * ```
+ *
+ * @example No pattern (just type guard)
+ * ```typescript
+ * try {
+ *   await operation();
+ * } catch (error: unknown) {
+ *   if (isErrorWithNameAndMessagePattern(error)) {
+ *     // Guaranteed that error is Error with message property
+ *     console.log(error.message);
+ *   }
+ * }
+ * ```
+ *
+ * @since 6.17.0
+ */
+export declare function isErrorWithNameAndMessagePattern(error: unknown, name?: string, messagePattern?: RegExp): error is Error & {
+    message: string;
+};
+//# sourceMappingURL=error-patterns.d.ts.map

package/dist/src/utils/error-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-patterns.d.ts","sourceRoot":"","sources":["../../../src/utils/error-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,GACd,KAAK,CAcP;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC5C,IAAI,CAUN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,GACb;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAc7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CA0BT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EAAE,GACvC,KAAK,GAAG,SAAS,CAgBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,KAAK,IAAI,KAAK,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAiBtC"}

package/dist/src/utils/error-utils.d.ts

@@ -205,4 +205,254 @@ export declare function isAxiosError(error: unknown): error is {
  * ```
  */
 export declare function getHttpStatusCode(error: unknown): number | undefined;
+/**
+ * Validates and extracts response.data with comprehensive null/structure checks
+ *
+ * Performs combined validation of response object and extraction of its data property.
+ * Throws descriptive errors if response is invalid or missing data.
+ *
+ * @param response Unknown response object from API call
+ * @param operation Name of the operation for error messages
+ * @returns The data from response.data, strongly typed
+ * @throws Error if response is invalid or data is missing
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const response = await api.get('/data');
+ *   const data = validateAndExtractResponseData<UserData>(response, 'Fetch user');
+ *   console.log(data.id); // TypeScript knows data is UserData
+ * } catch (error: unknown) {
+ *   console.error('Failed to fetch user:', getErrorMessage(error));
+ * }
+ * ```
+ */
+export declare function validateAndExtractResponseData<T>(response: unknown, operation: string): T;
+/**
+ * Wraps an error with operation context and message prefix for better error tracing
+ *
+ * Creates a new Error with a prefixed message that includes the operation context,
+ * preserving the original error information through the message.
+ *
+ * @param error Unknown error to wrap
+ * @param context Operation context string (e.g., "Swap delta calculation")
+ * @param prefix Optional custom prefix (defaults to context)
+ * @returns New Error with context-prefixed message
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await performSwap();
+ *   return result;
+ * } catch (error: unknown) {
+ *   throw wrapErrorWithContext(error, 'Swap calculation');
+ *   // Throws: "Swap calculation: Original error message"
+ * }
+ * ```
+ */
+export declare function wrapErrorWithContext(error: unknown, context: string, prefix?: string): Error;
+/**
+ * Validates response status and throws standardized error if response indicates failure
+ *
+ * Checks that response exists and has a Status property equal to 1 (success).
+ * Throws descriptive errors if response is invalid or indicates failure.
+ *
+ * @param response Unknown response object from API call
+ * @param operation Name of the operation for error messages
+ * @returns The response object if status check passes, strongly typed
+ * @throws Error if response is invalid or Status is not 1
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const response = await this.http.post('/api/data');
+ *   const validated = assertResponseSuccess(response, 'API request');
+ *   console.log(validated); // TypeScript knows response is valid
+ * } catch (error: unknown) {
+ *   console.error('API call failed:', getErrorMessage(error));
+ * }
+ * ```
+ */
+export declare function assertResponseSuccess(response: unknown, operation: string): Record<string, unknown>;
+/**
+ * Safely extracts error details from HTTP error responses with fallbacks
+ *
+ * Use this to extract status codes, messages, and error data from axios or HTTP errors.
+ * Provides sensible defaults when properties are missing or malformed.
+ *
+ * @param error The error object to extract details from
+ * @returns Object with status, message, and optional data properties
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const response = await api.get('/data');
+ * } catch (error: unknown) {
+ *   const { status, message, data } = extractErrorResponse(error);
+ *   console.log(`HTTP ${status}: ${message}`);
+ *   if (data) {
+ *     console.log('Error details:', data);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Handles various error types gracefully
+ * const { status, message } = extractErrorResponse('string error');
+ * // → { status: 500, message: "string error", data: undefined }
+ *
+ * const { status, message } = extractErrorResponse(new Error('Network error'));
+ * // → { status: 500, message: "Network error", data: undefined }
+ *
+ * const { status, message, data } = extractErrorResponse(axiosError);
+ * // → { status: 404, message: "Not Found", data: { details: "..." } }
+ * ```
+ *
+ * @since 3.50.0
+ */
+export declare function extractErrorResponse(error: unknown): {
+    status: number;
+    message: string;
+    data?: unknown;
+};
+/**
+ * Extract error message from response object with optional context
+ *
+ * Safely extracts Message property from API response for error context
+ * without unsafe type casts or verbose inline conditionals.
+ *
+ * @param response Unknown response object
+ * @returns Error message suffix (empty string if no message found)
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await sdk.lockTokens(data);
+ * } catch (error) {
+ *   const responseMsg = extractResponseMessage(response);
+ *   throw new LockError(`${getErrorMessage(error)}${responseMsg}`);
+ * }
+ * ```
+ */
+export declare function extractResponseMessage(response: unknown): string;
+/**
+ * Collects ValidationError messages from a function into an error array for batch validation reporting
+ *
+ * Simplifies the pattern of throwing validation errors in try-catch blocks and collecting messages.
+ * Catches ValidationError specifically and adds the message to the errors array, re-throws non-ValidationError exceptions.
+ *
+ * ## Replaces Pattern
+ *
+ * ### Before (Verbose try-catch for each validation):
+ * ```typescript
+ * const errors: string[] = [];
+ *
+ * try {
+ *   throw createRequiredFieldError('role', 'Role');
+ * } catch (e) {
+ *   if (e instanceof ValidationError) errors.push(e.message);
+ * }
+ *
+ * try {
+ *   validateLaunchpadTokenName(options.tokenName ?? '', 'tokenName');
+ * } catch (e) {
+ *   if (e instanceof ValidationError) errors.push(e.message);
+ * }
+ *
+ * try {
+ *   throw createInvalidFormatError('address', 'valid Ethereum address');
+ * } catch (e) {
+ *   if (e instanceof ValidationError) errors.push(e.message);
+ * }
+ * ```
+ *
+ * ### After (Concise with collectValidationErrors):
+ * ```typescript
+ * const errors: string[] = [];
+ *
+ * collectValidationErrors(errors, () => {
+ *   throw createRequiredFieldError('role', 'Role');
+ * });
+ *
+ * collectValidationErrors(errors, () =>
+ *   validateLaunchpadTokenName(options.tokenName ?? '', 'tokenName')
+ * );
+ *
+ * collectValidationErrors(errors, () => {
+ *   throw createInvalidFormatError('address', 'valid Ethereum address');
+ * });
+ * ```
+ *
+ * @param errors Array to accumulate error messages into
+ * @param fn Function that may throw ValidationError
+ * @param errorPrefix Optional prefix to add to collected error messages for context
+ * @throws Non-ValidationError exceptions are re-thrown as-is
+ *
+ * @example Basic usage with error factory
+ * ```typescript
+ * const errors: string[] = [];
+ *
+ * collectValidationErrors(errors, () => {
+ *   throw createRequiredFieldError('tokenName');
+ * });
+ *
+ * // errors is now: ['TokenName is required']
+ * ```
+ *
+ * @example With validation helper function
+ * ```typescript
+ * const errors: string[] = [];
+ *
+ * collectValidationErrors(errors, () =>
+ *   validateLaunchpadTokenName(tokenName, 'tokenName')
+ * );
+ *
+ * if (errors.length > 0) {
+ *   throw new ValidationError(errors.join('; '));
+ * }
+ * ```
+ *
+ * @example With optional error prefix for context
+ * ```typescript
+ * const errors: string[] = [];
+ *
+ * collectValidationErrors(
+ *   errors,
+ *   () => validateSwapAmount(amount),
+ *   'Swap validation failed: '
+ * );
+ *
+ * // If ValidationError thrown, message includes prefix
+ * // errors: ['Swap validation failed: Amount must be positive']
+ * ```
+ *
+ * @example Multiple validations with batch reporting
+ * ```typescript
+ * const errors: string[] = [];
+ *
+ * collectValidationErrors(errors, () => {
+ *   if (!role) throw createRequiredFieldError('role', 'Role');
+ * });
+ *
+ * collectValidationErrors(errors, () => {
+ *   if (!isValidEnum(scope)) throw createInvalidEnumError('scope', scope, SCOPES);
+ * });
+ *
+ * collectValidationErrors(errors, () => {
+ *   if (description.length > 255) throw createStringTooLongError('description', 255);
+ * });
+ *
+ * if (errors.length > 0) {
+ *   throw new ValidationError(
+ *     `Validation failed: ${errors.join('; ')}`,
+ *     'batch',
+ *     'VALIDATION_BATCH_FAILED'
+ *   );
+ * }
+ * ```
+ *
+ * @since 6.15.0
+ */
+export declare function collectValidationErrors(errors: string[], fn: () => void, errorPrefix?: string): void;
 //# sourceMappingURL=error-utils.d.ts.map

package/dist/src/utils/error-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/error-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAEtD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAOvE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAQ1E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAetD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAehE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAMxE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAoBA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE;QACT,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,OAAO,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAOA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAMpE"}
+{"version":3,"file":"error-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/error-utils.ts"],"names":[],"mappings":"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"}