@c15t/backend 1.8.0 → 2.0.0-rc.0

package/dist/pkgs/migrations/migration-builders.d.ts

@@ -1,28 +0,0 @@
-import type { Kysely } from 'kysely';
-import type { Database, KyselyDatabaseType } from '../db-adapters/adapters/kysely-adapter/types';
-import type { ColumnsToAdd, MigrationOperation, TableToCreate } from './types';
-/**
- * Builds migrations for adding columns to existing tables
- *
- * This function creates ALTER TABLE statements to add missing columns
- * to existing tables in the database.
- *
- * @param db - Kysely database instance used to build SQL operations
- * @param toBeAdded - Collection of tables and columns that need to be added
- * @param dbType - Database type to determine appropriate column types
- * @returns Array of migration operations ready to be executed
- */
-export declare function buildColumnAddMigrations(db: Kysely<Database>, toBeAdded: ColumnsToAdd[], dbType: KyselyDatabaseType): MigrationOperation[];
-/**
- * Builds migrations for creating new tables
- *
- * This function creates CREATE TABLE statements for tables
- * that don't exist in the database but are defined in the schema.
- *
- * @param db - Kysely database instance used to build SQL operations
- * @param toBeCreated - Collection of tables that need to be created
- * @param dbType - Database type to determine appropriate column types
- * @returns Array of migration operations ready to be executed
- */
-export declare function buildTableCreateMigrations(db: Kysely<Database>, toBeCreated: TableToCreate[], dbType: KyselyDatabaseType): MigrationOperation[];
-//# sourceMappingURL=migration-builders.d.ts.map

package/dist/pkgs/migrations/migration-builders.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migration-builders.d.ts","sourceRoot":"","sources":["../../../src/pkgs/migrations/migration-builders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA8B,MAAM,EAAE,MAAM,QAAQ,CAAC;AACjE,OAAO,KAAK,EACX,QAAQ,EACR,kBAAkB,EAClB,MAAM,kDAAkD,CAAC;AAI1D,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE/E;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACvC,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,EACpB,SAAS,EAAE,YAAY,EAAE,EACzB,MAAM,EAAE,kBAAkB,GACxB,kBAAkB,EAAE,CA0CtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACzC,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,EACpB,WAAW,EAAE,aAAa,EAAE,EAC5B,MAAM,EAAE,kBAAkB,GACxB,kBAAkB,EAAE,CAqFtB"}

package/dist/pkgs/migrations/migration-execution.d.ts

@@ -1,12 +0,0 @@
-import type { MigrationOperation } from './types';
-/**
- * Creates functions to run or compile the generated migrations
- *
- * @param migrations - Migration operations to execute
- * @returns Object with runMigrations and compileMigrations functions
- */
-export declare function createMigrationExecutors(migrations: MigrationOperation[]): {
-    runMigrations: () => Promise<void>;
-    compileMigrations: () => Promise<string>;
-};
-//# sourceMappingURL=migration-execution.d.ts.map

package/dist/pkgs/migrations/migration-execution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migration-execution.d.ts","sourceRoot":"","sources":["../../../src/pkgs/migrations/migration-execution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,kBAAkB,EAAE;;;EA8DxE"}

package/dist/pkgs/migrations/schema-comparison.d.ts

@@ -1,35 +0,0 @@
-import type { TableMetadata } from 'kysely';
-import type { KyselyDatabaseType } from '../db-adapters/adapters/kysely-adapter/types';
-import type { C15TOptions } from '../../types';
-import type { ColumnsToAdd, TableToCreate } from './types';
-/**
- * Analyzes schema differences between the expected schema and actual database
- *
- * This function compares the schema defined in the application with the
- * actual database structure to determine what changes need to be made.
- *
- * @param config - c15t configuration containing the schema definition
- * @param tableMetadata - Database table metadata from introspection, containing
- *                        information about existing tables and columns
- * @param dbType - The database type (postgres, mysql, sqlite, mssql) which affects
- *                 how types are compared and mapped
- *
- * @returns An object containing tables to be created and columns to be added
- *
- * @example
- * ```typescript
- * const changes = analyzeSchemaChanges(
- *   appConfig,
- *   databaseMetadata,
- *   'postgres'
- * );
- *
- * console.log(`Need to create ${changes.toBeCreated.length} tables`);
- * console.log(`Need to add columns to ${changes.toBeAdded.length} tables`);
- * ```
- */
-export declare function analyzeSchemaChanges(config: C15TOptions, tableMetadata: TableMetadata[], dbType: KyselyDatabaseType): {
-    toBeCreated: TableToCreate[];
-    toBeAdded: ColumnsToAdd[];
-};
-//# sourceMappingURL=schema-comparison.d.ts.map

package/dist/pkgs/migrations/schema-comparison.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-comparison.d.ts","sourceRoot":"","sources":["../../../src/pkgs/migrations/schema-comparison.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kDAAkD,CAAC;AAE3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,OAAO,KAAK,EACX,YAAY,EAEZ,aAAa,EACb,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,aAAa,EAAE,EAC9B,MAAM,EAAE,kBAAkB,GACxB;IAAE,WAAW,EAAE,aAAa,EAAE,CAAC;IAAC,SAAS,EAAE,YAAY,EAAE,CAAA;CAAE,CAwB7D"}

package/dist/pkgs/migrations/type-mapping.d.ts

@@ -1,75 +0,0 @@
-import type { Field, FieldType } from '../data-model';
-import type { KyselyDatabaseType } from '../db-adapters/adapters/kysely-adapter/types';
-/**
- * Determines MySQL string type based on field attributes
- *
- * @param field - Field attributes including unique and references properties
- * @returns The appropriate MySQL type for the string field
- *
- * @example
- * ```typescript
- * // Returns 'varchar(255)' for unique fields
- * getMySqlStringType({ type: 'string', unique: true });
- *
- * // Returns 'varchar(36)' for reference fields
- * getMySqlStringType({ type: 'string', references: 'subjects' });
- *
- * // Returns 'text' for regular string fields
- * getMySqlStringType({ type: 'string' });
- * ```
- */
-export declare function getMySqlStringType(field: Field): string;
-/**
- * Checks if a database column type matches the expected field type
- *
- * @param columnDataType - The actual column type in the database
- * @param fieldType - The expected field type from c15t
- * @param dbType - The database type (postgres, mysql, etc.)
- * @returns True if types match, false otherwise
- *
- * @remarks
- * This function handles type compatibility across different databases,
- * accounting for the fact that the same logical type may have different
- * names in different database systems.
- *
- * Array types (string[] and number[]) are treated specially and matched
- * against JSON-compatible column types.
- *
- * @example
- * ```typescript
- * // Returns true because 'text' is compatible with 'string' in PostgreSQL
- * matchType('text', 'string', 'postgres');
- *
- * // Returns true because 'jsonb' is compatible with array types
- * matchType('jsonb', 'string[]', 'postgres');
- * ```
- */
-export declare function matchType(columnDataType: string, fieldType: FieldType, dbType: KyselyDatabaseType): boolean;
-/**
- * Gets the appropriate database type for a field
- *
- * @param field - Field attributes including type and other properties
- * @param dbType - Database type to get the appropriate type for
- * @returns The appropriate database-specific type
- *
- * @remarks
- * This function determines the most appropriate database type for a given field,
- * taking into account:
- * - The field's base type (string, number, boolean, etc.)
- * - Special attributes (unique, references, bigint)
- * - Database-specific requirements and best practices
- *
- * @example
- * ```typescript
- * // Returns 'text' for a regular string field in SQLite
- * getType({ type: 'string' }, 'sqlite');
- *
- * // Returns 'jsonb' for a JSON field in PostgreSQL
- * getType({ type: 'json' }, 'postgres');
- *
- * // Returns 'bigint' for a number field with bigint flag
- * getType({ type: 'number', bigint: true }, 'mysql');
- * ```
- */
-export declare function getType(field: Field, dbType?: KyselyDatabaseType): string;
-//# sourceMappingURL=type-mapping.d.ts.map

package/dist/pkgs/migrations/type-mapping.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type-mapping.d.ts","sourceRoot":"","sources":["../../../src/pkgs/migrations/type-mapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kDAAkD,CAAC;AAqF3F;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAQvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CACxB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,kBAAkB,GACxB,OAAO,CAUT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,kBAA6B,UA8D1E"}

package/dist/pkgs/migrations/types.d.ts

@@ -1,36 +0,0 @@
-import type { AlterTableColumnAlteringBuilder, CreateTableBuilder } from 'kysely';
-import type { Field } from '../data-model';
-/**
- * Type representing a table to be created during migration
- */
-export interface TableToCreate {
-    table: string;
-    fields: Record<string, Field>;
-    order: number;
-}
-/**
- * Type representing table columns to be added during migration
- */
-export interface ColumnsToAdd {
-    table: string;
-    fields: Record<string, Field>;
-    order: number;
-}
-/**
- * Type for migration operations
- */
-export type MigrationOperation = AlterTableColumnAlteringBuilder | CreateTableBuilder<string, string>;
-/**
- * Result of migration generation
- */
-export interface MigrationResult {
-    toBeCreated: TableToCreate[];
-    toBeAdded: ColumnsToAdd[];
-    runMigrations: () => Promise<void>;
-    compileMigrations: () => Promise<string>;
-}
-/**
- * Re-export TableSchemaDefinition from get-schema
- */
-export type { SchemaDefinition, TableSchemaDefinition, } from './get-schema/types';
-//# sourceMappingURL=types.d.ts.map

package/dist/pkgs/migrations/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/pkgs/migrations/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,+BAA+B,EAC/B,kBAAkB,EAClB,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAC3B,+BAA+B,GAC/B,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B,WAAW,EAAE,aAAa,EAAE,CAAC;IAC7B,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,YAAY,EACX,gBAAgB,EAChB,qBAAqB,GACrB,MAAM,oBAAoB,CAAC"}

package/dist/pkgs/results/__tests__/error-class.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=error-class.test.d.ts.map

package/dist/pkgs/results/__tests__/error-class.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-class.test.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/__tests__/error-class.test.ts"],"names":[],"mappings":""}

package/dist/pkgs/results/__tests__/error-codes.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=error-codes.test.d.ts.map

package/dist/pkgs/results/__tests__/error-codes.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-codes.test.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/__tests__/error-codes.test.ts"],"names":[],"mappings":""}

package/dist/pkgs/results/__tests__/neverthrow-integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=neverthrow-integration.test.d.ts.map

package/dist/pkgs/results/__tests__/neverthrow-integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"neverthrow-integration.test.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/__tests__/neverthrow-integration.test.ts"],"names":[],"mappings":""}

package/dist/pkgs/results/__tests__/recovery-utils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=recovery-utils.test.d.ts.map

package/dist/pkgs/results/__tests__/recovery-utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recovery-utils.test.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/__tests__/recovery-utils.test.ts"],"names":[],"mappings":""}

package/dist/pkgs/results/__tests__/result-helpers.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=result-helpers.test.d.ts.map

package/dist/pkgs/results/__tests__/result-helpers.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result-helpers.test.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/__tests__/result-helpers.test.ts"],"names":[],"mappings":""}

package/dist/pkgs/results/core/error-class.d.ts

@@ -1,128 +0,0 @@
-import { ORPCError } from '@orpc/server';
-import type { DoubleTieErrorOptions } from '../types';
-/**
- * Custom error class for DoubleTie errors that extends ORPCError.
- *
- * This class directly extends ORPCError to provide seamless integration with oRPC
- * while adding application-specific error properties and context.
- *
- * @remarks
- * The DoubleTieError is designed to be compatible with HTTP responses and API error handling
- * while providing rich context for debugging and error reporting.
- *
- * @example
- * ```typescript
- * // Create and throw a DoubleTie error
- * throw new DoubleTieError('Failed to update subject preferences', {
- *   code: ERROR_CODES.FAILED_TO_UPDATE_CONSENT,
- *   status: 400,
- *   meta: { subjectId: 'sub_x1pftyoufsm7xgo1kv', preferences: { analytics: true } }
- * });
- *
- * // Catch and handle a DoubleTie error
- * try {
- *   // some operation
- * } catch (err) {
- *   if (DoubleTieError.isDoubleTieError(err)) {
- *     console.error(`${err.code}: ${err.message} (${err.category})`);
- *   }
- * }
- * ```
- */
-export declare class DoubleTieError extends ORPCError<string, Record<string, unknown>> {
-    /**
-     * Error category that groups related errors.
-     * Defaults to 'unexpected' if not specified.
-     *
-     * @see ERROR_CATEGORIES for predefined categories
-     */
-    readonly category: string;
-    /**
-     * Additional metadata about the error.
-     * Can contain any contextual information that might help debugging.
-     */
-    readonly meta: Record<string, unknown>;
-    /**
-     * HTTP status code for the error
-     */
-    readonly statusCode: number;
-    /**
-     * Creates a new DoubleTieError instance.
-     *
-     * @param message - Human-readable error message
-     * @param options - Configuration options for the error
-     * @param options.code - Error code identifying the error type
-     * @param options.status - HTTP status code (defaults to 500)
-     * @param options.category - Error category (defaults to 'unexpected')
-     * @param options.cause - Original error that caused this error
-     * @param options.meta - Additional metadata about the error
-     *
-     * @example
-     * ```typescript
-     * const error = new DoubleTieError('Authentication failed', {
-     *   code: ERROR_CODES.UNAUTHORIZED,
-     *   status: 401,
-     *   category: ERROR_CATEGORIES.AUTH,
-     *   meta: { userId: 'usr_abc123' }
-     * });
-     * ```
-     */
-    constructor(message: string, options?: DoubleTieErrorOptions);
-    /**
-     * Type guard to check if an unknown error is a DoubleTieError.
-     *
-     * @param error - The error to check
-     * @returns True if the error is a DoubleTieError, false otherwise
-     */
-    static isDoubleTieError(error: unknown): error is DoubleTieError;
-    /**
-     * Convert the error to a JSON-serializable object matching oRPC's error format.
-     * Override of the parent ORPCError toJSON method.
-     */
-    toJSON(): {
-        code: string;
-        message: string;
-        status: number;
-        defined: boolean;
-        data: {
-            cause?: {} | undefined;
-            originalMessage?: string | undefined;
-            stack?: string[] | undefined;
-            category: string;
-            meta: Record<string, unknown>;
-        };
-    };
-    /**
-     * Creates a DoubleTieError from an HTTP response object.
-     *
-     * @param response - The HTTP Response object
-     * @param data - Optional response data that was already parsed
-     * @returns A new DoubleTieError instance with information from the response
-     */
-    static fromResponse(response: Response, data?: unknown): DoubleTieError;
-    /**
-     * Creates a new error instance with additional metadata merged with the original.
-     * Does not modify the original error instance.
-     *
-     * @param additionalMeta - Additional metadata to add to the error
-     * @returns A new DoubleTieError instance with the combined metadata
-     */
-    withMeta(additionalMeta: Record<string, unknown>): DoubleTieError;
-    /**
-     * Creates a subclass of DoubleTieError with a custom name.
-     * Useful for creating domain-specific error classes.
-     *
-     * @param name - The name for the new error class
-     * @returns A new error class extending DoubleTieError
-     */
-    static createSubclass(name: string): typeof DoubleTieError;
-    /**
-     * Format a validation error into a more user-friendly message.
-     * Especially useful for displaying validation errors from the meta field.
-     *
-     * @param error - The DoubleTieError containing validation details
-     * @returns A formatted string with validation error details
-     */
-    static formatValidationError(error: DoubleTieError): string;
-}
-//# sourceMappingURL=error-class.d.ts.map

package/dist/pkgs/results/core/error-class.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-class.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/core/error-class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,qBAAqB,EAAoB,MAAM,UAAU,CAAC;AAIxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,cAAe,SAAQ,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7E;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;;;;;;;;;;;;;;;;;;;OAoBG;gBAEF,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,qBAMR;IA4CF;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc;IAIhE;;;OAGG;IACH,MAAM;;;;;;;;;;;;;IAmDN;;;;;;OAMG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,cAAc;IA+BvE;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc;IAUjE;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,cAAc;IAY1D;;;;;;OAMG;IACH,MAAM,CAAC,qBAAqB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;CAuB3D"}

package/dist/pkgs/results/core/error-codes.d.ts

@@ -1,178 +0,0 @@
-/**
- * Core error codes for DoubleTie applications.
- *
- * These error codes are used throughout the application to provide consistent
- * error messages and enable proper error handling in client applications.
- * Each error code represents a common type of error that can occur in any application.
- *
- * @example
- * ```typescript
- * import { CORE_ERROR_CODES, DoubleTieError } from '@doubletie/errors';
- *
- * // Handle a specific error
- * try {
- *   await dataManager.updateRecord(recordId, data);
- * } catch (error) {
- *   if (error instanceof DoubleTieError && error.code === CORE_ERROR_CODES.NOT_FOUND) {
- *     // Handle the specific case where record is not found
- *     console.error('Cannot update: record does not exist');
- *   } else {
- *     // Handle other errors
- *     console.error('Failed to update record:', error.message);
- *   }
- * }
- * ```
- */
-export declare const ERROR_CODES: Readonly<{
-    /**
-     * The requested resource could not be found.
-     * This is a general error for when a requested entity does not exist.
-     */
-    NOT_FOUND: "Resource not found";
-    /**
-     * The request is invalid or malformed.
-     * This is a general error for requests that do not meet the expected format.
-     */
-    BAD_REQUEST: "Bad request";
-    /**
-     * The request conflicts with the current state of the server.
-     * This may occur when trying to create a resource that already exists or
-     * when attempting to modify a resource in a way that conflicts with its current state.
-     */
-    CONFLICT: "Conflict with current state";
-    /**
-     * A required parameter is missing from the request.
-     * This may occur when API calls are made without all necessary data.
-     */
-    MISSING_REQUIRED_PARAMETER: "Missing required parameter";
-    /**
-     * The request requires authentication that was not provided or is invalid.
-     * This may occur when attempting to access protected resources without proper credentials.
-     */
-    UNAUTHORIZED: "Unauthorized";
-    /**
-     * The requester does not have permission to perform the requested operation.
-     * This may occur when authenticated subjects attempt operations beyond their permission level.
-     */
-    FORBIDDEN: "Forbidden";
-    /**
-     * An unexpected internal error occurred on the server.
-     * This is a general error for unexpected exceptions during request processing.
-     */
-    INTERNAL_SERVER_ERROR: "Internal server error";
-    /**
-     * Initialization of the system failed.
-     * This may occur when the system cannot be initialized due to configuration
-     * errors, missing dependencies, or other setup issues.
-     */
-    INITIALIZATION_FAILED: "Initialization failed";
-    /**
-     * Database connection error.
-     * This may occur when the system cannot connect to the database due to
-     * connection issues, authentication failures, or other database-related problems.
-     */
-    DATABASE_CONNECTION_ERROR: "Database connection error";
-    /**
-     * Database query error.
-     * This may occur when a database query fails due to syntax errors,
-     * constraint violations, or other database-related issues.
-     */
-    DATABASE_QUERY_ERROR: "Database query error";
-    /**
-     * The provided configuration is invalid or contains errors.
-     * This may occur when initializing the system with incorrect settings.
-     */
-    INVALID_CONFIGURATION: "Invalid configuration";
-    /**
-     * An error occurred while attempting to handle a request.
-     * This may occur when a request cannot be processed due to invalid input,
-     * internal errors, or other issues.
-     */
-    REQUEST_HANDLER_ERROR: "Request handler error";
-    /**
-     * The request is invalid or malformed.
-     * This is a specific error for requests that do not meet the expected format.
-     */
-    INVALID_REQUEST: "Invalid request";
-    /**
-     * Unknown or unclassified error.
-     * Used when an error occurs that doesn't match any other error code.
-     */
-    UNKNOWN_ERROR: "Unknown error";
-    /**
-     * A network-related error occurred.
-     * This may occur when network requests fail due to connectivity issues.
-     */
-    NETWORK_ERROR: "Network error";
-    /**
-     * Plugin initialization failed.
-     * This may occur when a plugin cannot be initialized due to configuration
-     * errors, missing dependencies, or other setup issues.
-     */
-    PLUGIN_INITIALIZATION_FAILED: "Plugin initialization failed";
-    /**
-     * Error retrieving API endpoints.
-     * This may occur when the system cannot retrieve API endpoints due to
-     * configuration errors or other internal issues.
-     */
-    API_RETRIEVAL_ERROR: "API retrieval error";
-    /**
-     * Validation of input data failed.
-     * This may occur when input data does not meet schema requirements or other validation rules.
-     */
-    VALIDATION_ERROR: "Validation error";
-    /**
-     * An unexpected error occurred.
-     * This is a general error for unexpected exceptions that don't fit other categories.
-     */
-    UNEXPECTED: "Unexpected error";
-}>;
-/**
- * Error categories for organizing errors by domain
- */
-export declare const ERROR_CATEGORIES: Readonly<{
-    VALIDATION: "validation";
-    AUTHORIZATION: "authorization";
-    STORAGE: "storage";
-    NETWORK: "network";
-    PLUGIN: "plugin";
-    CONFIGURATION: "configuration";
-    UNEXPECTED: "unexpected";
-}>;
-/**
- * Utility function to create custom error categories
- *
- * @param categories - Record of category names and their string values
- * @returns The categories object with const assertion
- *
- * @example
- * ```typescript
- * const MY_ERROR_CATEGORIES = createErrorCategories({
- *   BILLING: 'billing',
- *   ANALYTICS: 'analytics',
- * });
- * ```
- */
-export declare function createErrorCategories<TCategories extends Record<string, string>>(categories: TCategories): Readonly<TCategories>;
-/**
- * Utility function to create custom error codes that can be used with DoubleTieError
- *
- * @param codes - Record of error code names and their string message values
- * @returns The error codes object with const assertion
- *
- * @example
- * ```typescript
- * const BILLING_ERROR_CODES = createErrorCodes({
- *   PAYMENT_FAILED: 'Payment processing failed',
- *   INVOICE_NOT_FOUND: 'Invoice not found',
- * });
- *
- * // Later in your code
- * throw new DoubleTieError('Could not charge credit card', {
- *   code: BILLING_ERROR_CODES.PAYMENT_FAILED,
- *   status: 400,
- * });
- * ```
- */
-export declare function createErrorCodes<TCodes extends Record<string, string>>(codes: TCodes): Readonly<TCodes>;
-//# sourceMappingURL=error-codes.d.ts.map

package/dist/pkgs/results/core/error-codes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/core/error-codes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,WAAW;IACvB;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;EAEF,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;EAQ3B,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACpC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,UAAU,EAAE,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC,CAEhD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACrE,KAAK,EAAE,MAAM,GACX,QAAQ,CAAC,MAAM,CAAC,CAElB"}

package/dist/pkgs/results/core/tracing.d.ts

@@ -1,11 +0,0 @@
-import { type Span } from '@opentelemetry/api';
-/**
- * Creates and manages a span for a function execution
- *
- * @param name - Name of the span
- * @param fn - Function to execute within the span
- * @param attributes - Optional attributes to add to the span
- * @returns The result of the function execution
- */
-export declare function withSpan<T>(name: string, fn: (span: Span) => Promise<T> | T, attributes?: Record<string, string | number | boolean>): Promise<T>;
-//# sourceMappingURL=tracing.d.ts.map

package/dist/pkgs/results/core/tracing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/core/tracing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAyB,MAAM,oBAAoB,CAAC;AAKtE;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAClC,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAM,GACxD,OAAO,CAAC,CAAC,CAAC,CA+CZ"}

package/dist/pkgs/results/create-telemetry-options.d.ts

@@ -1,31 +0,0 @@
-import type { Tracer } from '@opentelemetry/api';
-import type { DoubleTieOptions } from '../types';
-/**
- * Configuration options for the telemetry system
- */
-export interface TelemetryConfig {
-    /**
-     * Custom OpenTelemetry tracer to use instead of the default
-     */
-    tracer?: Tracer;
-    /**
-     * Whether telemetry should be disabled
-     */
-    disabled?: boolean;
-    /**
-     * Default attributes to add to all telemetry spans
-     */
-    defaultAttributes?: Record<string, string | number | boolean>;
-}
-/**
- * Creates telemetry configuration from provided options
- *
- * This function merges user-provided telemetry options with sensible defaults,
- * ensuring that service name and version are always properly set.
- *
- * @param appName - The application name to use for service.name attribute
- * @param telemetryConfig - Optional user-provided telemetry configuration
- * @returns Properly structured telemetry options for the OpenTelemetry SDK
- */
-export declare function createTelemetryOptions(appName?: string, telemetryConfig?: TelemetryConfig): DoubleTieOptions['telemetry'];
-//# sourceMappingURL=create-telemetry-options.d.ts.map

package/dist/pkgs/results/create-telemetry-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-telemetry-options.d.ts","sourceRoot":"","sources":["../../../src/pkgs/results/create-telemetry-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CAC9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACrC,OAAO,SAAS,EAChB,eAAe,CAAC,EAAE,eAAe,GAC/B,gBAAgB,CAAC,WAAW,CAAC,CAyB/B"}