@ketrics/sdk-backend 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -23,20 +23,20 @@
  *     const file = await volume.get('documents/report.pdf');
  *     return { contentType: file.contentType, size: file.contentLength };
  *   } catch (error) {
- *     if (error instanceof ketrics.VolumeNotFoundError) {
+ *     if (error instanceof ketrics.Volume.NotFoundError) {
  *       return { error: `Volume not found: ${error.volumeCode}` };
  *     }
  *     throw error;
  *   }
  *
- *   // Use ketrics.DatabaseConnection.connect() for databases
+ *   // Use ketrics.Database.connect() for databases
  *   try {
- *     const db = await ketrics.DatabaseConnection.connect('main-db');
+ *     const db = await ketrics.Database.connect('main-db');
  *     const result = await db.query('SELECT * FROM users');
  *     await db.close();
  *     return { users: result.rows };
  *   } catch (error) {
- *     if (error instanceof ketrics.DatabaseNotFoundError) {
+ *     if (error instanceof ketrics.Database.NotFoundError) {
  *       return { error: `Database not found: ${error.databaseCode}` };
  *     }
  *     throw error;
@@ -47,7 +47,7 @@
  *     const apiKey = await ketrics.Secret.get('stripe-api-key');
  *     // Use the API key
  *   } catch (error) {
- *     if (error instanceof ketrics.SecretNotFoundError) {
+ *     if (error instanceof ketrics.Secret.NotFoundError) {
  *       return { error: `Secret not found: ${error.secretCode}` };
  *     }
  *     throw error;
@@ -55,51 +55,316 @@
  * }
  * ```
  */
-export { TenantContext, ApplicationContext, UserContext, RequestorContext, RuntimeContext, EnvironmentVariables, } from './context';
-export { ConsoleLogger } from './console';
-export { HttpRequestConfig, HttpResponse, HttpClient } from './http';
-export { DatabaseQueryResult, DatabaseExecuteResult, IDatabaseConnection, DatabaseManager, } from './databases';
-export { DatabaseError, DatabaseNotFoundError, DatabaseAccessDeniedError, DatabaseConnectionError, DatabaseQueryError, DatabaseTransactionError, isDatabaseError, isDatabaseErrorType, } from './database-errors';
-export { ISecret } from './secrets';
-export { SecretError, SecretNotFoundError, SecretAccessDeniedError, SecretDecryptionError, isSecretError, isSecretErrorType, } from './secret-errors';
-export { ExcelCellValue, ExcelRowValues, ExcelColumnDefinition, AddWorksheetOptions, IExcelCell, IExcelRow, IExcelWorksheet, IExcelWorkbook, ExcelManager, } from './excel';
-export { ExcelError, ExcelParseError, ExcelWriteError, isExcelError, isExcelErrorType, } from './excel-errors';
-export { PdfPageSize, PdfStandardFont, PdfRgbColor, PdfDrawTextOptions, PdfDrawRectOptions, PdfDrawLineOptions, PdfDrawCircleOptions, PdfDrawImageOptions, PdfEmbeddedImage, PdfEmbeddedFont, IPdfPage, IPdfDocument, PdfManager, } from './pdf';
-export { PdfError, PdfParseError, PdfWriteError, isPdfError, isPdfErrorType, } from './pdf-errors';
-export { JobStatusValue, RunInBackgroundOptions, RunInBackgroundParams, JobErrorDetails, JobStatus, JobListParams, JobListResult, } from './job';
-export { JobError, JobNotFoundError, InvalidFunctionError, CrossAppPermissionError, JobExecutionError, isJobError, isJobErrorType, } from './job-errors';
-export { MessagePriorityLevel, MessageChannelConfig, SendMessageParams, SendBulkMessageParams, SendGroupMessageParams, SendMessageResult, SendBulkMessageResult, MessagesManager, } from './messages';
-export { MessageError, MessageValidationError, GroupNotFoundError, TenantGrantPermissionDeniedError, isMessageError, isMessageErrorType, } from './messages-errors';
-export { PutContent, FileContent, FileMetadata, FileInfo, PutOptions, PutResult, DeleteResult, DeleteError, DeleteByPrefixResult, ListOptions, ListResult, CopyOptions, CopyResult, MoveOptions, MoveResult, DownloadUrlOptions, UploadUrlOptions, PresignedUrl, IVolume, } from './volumes';
-export { VolumePermissionValue, VolumeError, VolumeNotFoundError, VolumeAccessDeniedError, VolumePermissionDeniedError, FileNotFoundError, FileAlreadyExistsError, InvalidPathError, FileSizeLimitError, ContentTypeNotAllowedError, isVolumeError, isVolumeErrorType, } from './errors';
-import type { TenantContext, ApplicationContext, RequestorContext, RuntimeContext, EnvironmentVariables } from './context';
-import type { ConsoleLogger } from './console';
-import type { HttpClient } from './http';
-import type { IDatabaseConnection } from './databases';
-import type { IVolume } from './volumes';
-import type { IExcelWorkbook } from './excel';
-import type { IPdfDocument, PdfRgbColor } from './pdf';
-import type { RunInBackgroundParams, JobStatus, JobListParams, JobListResult } from './job';
-import type { MessagesManager } from './messages';
-import { VolumeError as VolumeErrorClass, VolumeNotFoundError as VolumeNotFoundErrorClass, VolumeAccessDeniedError as VolumeAccessDeniedErrorClass, VolumePermissionDeniedError as VolumePermissionDeniedErrorClass, FileNotFoundError as FileNotFoundErrorClass, FileAlreadyExistsError as FileAlreadyExistsErrorClass, InvalidPathError as InvalidPathErrorClass, FileSizeLimitError as FileSizeLimitErrorClass, ContentTypeNotAllowedError as ContentTypeNotAllowedErrorClass } from './errors';
-import { DatabaseError as DatabaseErrorClass, DatabaseNotFoundError as DatabaseNotFoundErrorClass, DatabaseAccessDeniedError as DatabaseAccessDeniedErrorClass, DatabaseConnectionError as DatabaseConnectionErrorClass, DatabaseQueryError as DatabaseQueryErrorClass, DatabaseTransactionError as DatabaseTransactionErrorClass } from './database-errors';
-import { SecretError as SecretErrorClass, SecretNotFoundError as SecretNotFoundErrorClass, SecretAccessDeniedError as SecretAccessDeniedErrorClass, SecretDecryptionError as SecretDecryptionErrorClass } from './secret-errors';
-import { ExcelError as ExcelErrorClass, ExcelParseError as ExcelParseErrorClass, ExcelWriteError as ExcelWriteErrorClass } from './excel-errors';
-import { PdfError as PdfErrorClass, PdfParseError as PdfParseErrorClass, PdfWriteError as PdfWriteErrorClass } from './pdf-errors';
-import { JobError as JobErrorClass, JobNotFoundError as JobNotFoundErrorClass, InvalidFunctionError as InvalidFunctionErrorClass, CrossAppPermissionError as CrossAppPermissionErrorClass, JobExecutionError as JobExecutionErrorClass } from './job-errors';
-import { MessageError as MessageErrorClass, MessageValidationError as MessageValidationErrorClass, GroupNotFoundError as GroupNotFoundErrorClass, TenantGrantPermissionDeniedError as TenantGrantPermissionDeniedErrorClass } from './messages-errors';
-import { isVolumeError, isVolumeErrorType } from './errors';
-import { isDatabaseError, isDatabaseErrorType } from './database-errors';
-import { isSecretError, isSecretErrorType } from './secret-errors';
-import { isExcelError, isExcelErrorType } from './excel-errors';
-import { isPdfError, isPdfErrorType } from './pdf-errors';
-import { isJobError, isJobErrorType } from './job-errors';
-import { isMessageError, isMessageErrorType } from './messages-errors';
+export { TenantContext, ApplicationContext, UserContext, RequestorContext, RuntimeContext, EnvironmentVariables } from "./context";
+export { ConsoleLogger } from "./console";
+export { HttpRequestConfig, HttpResponse, HttpClient } from "./http";
+export { DatabaseQueryResult, DatabaseExecuteResult, IDatabaseConnection, DatabaseManager } from "./databases";
+export { DatabaseError, DatabaseNotFoundError, DatabaseAccessDeniedError, DatabaseConnectionError, DatabaseQueryError, DatabaseTransactionError, isDatabaseError, isDatabaseErrorType, } from "./database-errors";
+export { ISecret } from "./secrets";
+export { SecretError, SecretNotFoundError, SecretAccessDeniedError, SecretDecryptionError, isSecretError, isSecretErrorType } from "./secret-errors";
+export { ExcelCellValue, ExcelRowValues, ExcelColumnDefinition, AddWorksheetOptions, IExcelCell, IExcelRow, IExcelWorksheet, IExcelWorkbook, ExcelManager, } from "./excel";
+export { ExcelError, ExcelParseError, ExcelWriteError, isExcelError, isExcelErrorType } from "./excel-errors";
+export { PdfPageSize, PdfStandardFont, PdfRgbColor, PdfDrawTextOptions, PdfDrawRectOptions, PdfDrawLineOptions, PdfDrawCircleOptions, PdfDrawImageOptions, PdfEmbeddedImage, PdfEmbeddedFont, IPdfPage, IPdfDocument, PdfManager, } from "./pdf";
+export { PdfError, PdfParseError, PdfWriteError, isPdfError, isPdfErrorType } from "./pdf-errors";
+export { JobStatusValue, RunInBackgroundOptions, RunInBackgroundParams, JobErrorDetails, JobStatus, JobListParams, JobListResult } from "./job";
+export { JobError, JobNotFoundError, InvalidFunctionError, CrossAppPermissionError, EltJobExecutionError, isJobError, isJobErrorType, } from "./job-errors";
+export { MessagePriorityLevel, MessageChannelConfig, SendMessageParams, SendBulkMessageParams, SendGroupMessageParams, SendMessageResult, SendBulkMessageResult, MessagesManager, } from "./messages";
+export { MessageError, MessageValidationError, GroupNotFoundError, TenantGrantPermissionDeniedError, isMessageError, isMessageErrorType, } from "./messages-errors";
+export { PutContent, FileContent, FileMetadata, FileInfo, PutOptions, PutResult, DeleteResult, DeleteError, DeleteByPrefixResult, ListOptions, ListResult, CopyOptions, CopyResult, MoveOptions, MoveResult, DownloadUrlOptions, UploadUrlOptions, PresignedUrl, IVolume, } from "./volumes";
+export { VolumePermissionValue, VolumeError, VolumeNotFoundError, VolumeAccessDeniedError, VolumePermissionDeniedError, FileNotFoundError, FileAlreadyExistsError, InvalidPathError, FileSizeLimitError, ContentTypeNotAllowedError, isVolumeError, isVolumeErrorType, } from "./errors";
+import type { TenantContext, ApplicationContext, RequestorContext, RuntimeContext, EnvironmentVariables } from "./context";
+import type { ConsoleLogger } from "./console";
+import type { HttpClient } from "./http";
+import type { IDatabaseConnection } from "./databases";
+import type { IVolume } from "./volumes";
+import type { IExcelWorkbook } from "./excel";
+import type { IPdfDocument, PdfRgbColor } from "./pdf";
+import type { RunInBackgroundParams, JobStatus, JobListParams, JobListResult } from "./job";
+import type { SendMessageParams, SendBulkMessageParams, SendGroupMessageParams, SendMessageResult, SendBulkMessageResult } from "./messages";
+/**
+ * Base class for all Volume errors
+ */
+export interface VolumeErrorClass extends Error {
+    readonly volumeCode: string;
+    readonly operation: string;
+    readonly timestamp: Date;
+    toJSON(): Record<string, unknown>;
+}
+export type AbstractVolumeErrorConstructor = abstract new (...args: any[]) => VolumeErrorClass;
+export type VolumeErrorConstructor = new (...args: any[]) => VolumeErrorClass;
+/**
+ * Base class for all Database errors
+ */
+export interface DatabaseErrorClass extends Error {
+    readonly databaseCode: string;
+    readonly operation: string;
+    readonly timestamp: Date;
+    toJSON(): Record<string, unknown>;
+}
+export type AbstractDatabaseErrorConstructor = abstract new (...args: any[]) => DatabaseErrorClass;
+export type DatabaseErrorConstructor = new (...args: any[]) => DatabaseErrorClass;
+/**
+ * Base class for all Secret errors
+ */
+export interface SecretErrorClass extends Error {
+    readonly secretCode: string;
+    readonly operation: string;
+    readonly timestamp: Date;
+    toJSON(): Record<string, unknown>;
+}
+export type AbstractSecretErrorConstructor = abstract new (...args: any[]) => SecretErrorClass;
+export type SecretErrorConstructor = new (...args: any[]) => SecretErrorClass;
+/**
+ * Base class for all Excel errors
+ */
+export interface ExcelErrorClass extends Error {
+    readonly operation: string;
+    readonly timestamp: Date;
+    toJSON(): Record<string, unknown>;
+}
+export type AbstractExcelErrorConstructor = abstract new (...args: any[]) => ExcelErrorClass;
+export type ExcelErrorConstructor = new (...args: any[]) => ExcelErrorClass;
+/**
+ * Base class for all PDF errors
+ */
+export interface PdfErrorClass extends Error {
+    readonly operation: string;
+    readonly timestamp: Date;
+    toJSON(): Record<string, unknown>;
+}
+export type AbstractPdfErrorConstructor = abstract new (...args: any[]) => PdfErrorClass;
+export type PdfErrorConstructor = new (...args: any[]) => PdfErrorClass;
+/**
+ * Base class for all Job errors
+ */
+export interface JobErrorClass extends Error {
+    readonly jobId?: string;
+    readonly operation: string;
+    readonly timestamp: Date;
+    toJSON(): Record<string, unknown>;
+}
+export type AbstractJobErrorConstructor = abstract new (...args: any[]) => JobErrorClass;
+export type JobErrorConstructor = new (...args: any[]) => JobErrorClass;
+/**
+ * Base class for all Message errors
+ */
+export interface MessageErrorClass extends Error {
+    readonly code: string;
+}
+export type MessageErrorConstructor = new (message: string, code?: string) => MessageErrorClass;
+/**
+ * Volume Module
+ *
+ * Groups Volume operations, error classes, and type guards under a single namespace.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const volume = await ketrics.Volume.connect('uploads');
+ *   const files = await volume.list();
+ * } catch (error) {
+ *   if (error instanceof ketrics.Volume.NotFoundError) {
+ *     console.log('Volume not found');
+ *   }
+ * }
+ * ```
+ */
+export interface VolumeModule {
+    connect(volumeCode: string): Promise<IVolume>;
+    Error: AbstractVolumeErrorConstructor;
+    NotFoundError: VolumeErrorConstructor;
+    AccessDeniedError: VolumeErrorConstructor;
+    PermissionDeniedError: VolumeErrorConstructor;
+    FileNotFoundError: VolumeErrorConstructor;
+    FileAlreadyExistsError: VolumeErrorConstructor;
+    InvalidPathError: VolumeErrorConstructor;
+    FileSizeLimitError: VolumeErrorConstructor;
+    ContentTypeNotAllowedError: VolumeErrorConstructor;
+    isError: (error: unknown) => error is VolumeErrorClass;
+    isErrorType: <T extends VolumeErrorClass>(error: unknown, errorClass: new (...args: never[]) => T) => error is T;
+}
+/**
+ * Database Module
+ *
+ * Groups Database operations, error classes, and type guards under a single namespace.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const db = await ketrics.Database.connect('main-db');
+ *   const result = await db.query('SELECT * FROM users WHERE id = $1', [1]);
+ *   await db.close();
+ * } catch (error) {
+ *   if (error instanceof ketrics.Database.NotFoundError) {
+ *     console.log('Database not found');
+ *   } else if (error instanceof ketrics.Database.QueryError) {
+ *     console.log('Query failed');
+ *   }
+ * }
+ * ```
+ */
+export interface DatabaseModule {
+    connect(databaseCode: string): Promise<IDatabaseConnection>;
+    Error: AbstractDatabaseErrorConstructor;
+    NotFoundError: DatabaseErrorConstructor;
+    AccessDeniedError: DatabaseErrorConstructor;
+    ConnectionError: DatabaseErrorConstructor;
+    QueryError: DatabaseErrorConstructor;
+    TransactionError: DatabaseErrorConstructor;
+    isError: (error: unknown) => error is DatabaseErrorClass;
+    isErrorType: <T extends DatabaseErrorClass>(error: unknown, errorClass: new (...args: never[]) => T) => error is T;
+}
+/**
+ * Secret Module
+ *
+ * Groups Secret operations, error classes, and type guards under a single namespace.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const apiKey = await ketrics.Secret.get('stripe-api-key');
+ * } catch (error) {
+ *   if (error instanceof ketrics.Secret.NotFoundError) {
+ *     console.log('Secret not found');
+ *   }
+ * }
+ * ```
+ */
+export interface SecretModule {
+    get(secretCode: string): Promise<string>;
+    exists(secretCode: string): Promise<boolean>;
+    Error: AbstractSecretErrorConstructor;
+    NotFoundError: SecretErrorConstructor;
+    AccessDeniedError: SecretErrorConstructor;
+    DecryptionError: SecretErrorConstructor;
+    isError: (error: unknown) => error is SecretErrorClass;
+    isErrorType: <T extends SecretErrorClass>(error: unknown, errorClass: new (...args: any[]) => T) => error is T;
+}
+/**
+ * Excel Module
+ *
+ * Groups Excel operations, error classes, and type guards under a single namespace.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const workbook = await ketrics.Excel.read(buffer);
+ *   const sheet = workbook.getWorksheet('Sheet1');
+ * } catch (error) {
+ *   if (error instanceof ketrics.Excel.ParseError) {
+ *     console.log('Invalid Excel file');
+ *   }
+ * }
+ * ```
+ */
+export interface ExcelModule {
+    read(buffer: Buffer): Promise<IExcelWorkbook>;
+    create(): IExcelWorkbook;
+    Error: AbstractExcelErrorConstructor;
+    ParseError: ExcelErrorConstructor;
+    WriteError: ExcelErrorConstructor;
+    isError: (error: unknown) => error is ExcelErrorClass;
+    isErrorType: <T extends ExcelErrorClass>(error: unknown, errorClass: new (...args: never[]) => T) => error is T;
+}
+/**
+ * PDF Module
+ *
+ * Groups PDF operations, error classes, and type guards under a single namespace.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const doc = await ketrics.Pdf.create();
+ *   const page = doc.addPage('A4');
+ *   const red = ketrics.Pdf.rgb(1, 0, 0);
+ *   await page.drawText('Hello!', { x: 50, y: 700, color: red });
+ * } catch (error) {
+ *   if (error instanceof ketrics.Pdf.WriteError) {
+ *     console.log('PDF write failed');
+ *   }
+ * }
+ * ```
+ */
+export interface PdfModule {
+    read(buffer: Buffer): Promise<IPdfDocument>;
+    create(): Promise<IPdfDocument>;
+    rgb(r: number, g: number, b: number): PdfRgbColor;
+    Error: AbstractPdfErrorConstructor;
+    ParseError: PdfErrorConstructor;
+    WriteError: PdfErrorConstructor;
+    isError: (error: unknown) => error is PdfErrorClass;
+    isErrorType: <T extends PdfErrorClass>(error: unknown, errorClass: new (...args: never[]) => T) => error is T;
+}
+/**
+ * Job Module (Grouped)
+ *
+ * Groups Job operations, error classes, and type guards under a single namespace.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const jobId = await ketrics.Job.runInBackground({
+ *     function: 'processOrder',
+ *     payload: { orderId: '123' },
+ *   });
+ *   const status = await ketrics.Job.getStatus(jobId);
+ * } catch (error) {
+ *   if (error instanceof ketrics.Job.NotFoundError) {
+ *     console.log('Job not found');
+ *   }
+ * }
+ * ```
+ */
+export interface JobGroupedModule {
+    runInBackground(params: RunInBackgroundParams): Promise<string>;
+    getStatus(jobId: string): Promise<JobStatus>;
+    list(params?: JobListParams): Promise<JobListResult>;
+    Error: AbstractJobErrorConstructor;
+    NotFoundError: JobErrorConstructor;
+    InvalidFunctionError: JobErrorConstructor;
+    CrossAppPermissionError: JobErrorConstructor;
+    ExecutionError: JobErrorConstructor;
+    isError: (error: unknown) => error is JobErrorClass;
+    isErrorType: <T extends JobErrorClass>(error: unknown, errorClass: new (...args: never[]) => T) => error is T;
+}
+/**
+ * Messages Module (Grouped)
+ *
+ * Groups Messages operations, error classes, and type guards under a single namespace.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await ketrics.Messages.send({
+ *     userId: 'user-123',
+ *     type: 'ORDER_SHIPPED',
+ *     subject: 'Your order has shipped!',
+ *     body: 'Track your package...',
+ *   });
+ * } catch (error) {
+ *   if (error instanceof ketrics.Messages.ValidationError) {
+ *     console.log('Invalid message params');
+ *   }
+ * }
+ * ```
+ */
+export interface MessagesGroupedModule {
+    send(params: SendMessageParams): Promise<SendMessageResult>;
+    sendBulk(params: SendBulkMessageParams): Promise<SendBulkMessageResult>;
+    sendToGroup(params: SendGroupMessageParams): Promise<SendBulkMessageResult>;
+    Error: MessageErrorConstructor;
+    ValidationError: MessageErrorConstructor;
+    GroupNotFoundError: MessageErrorConstructor;
+    PermissionDeniedError: MessageErrorConstructor;
+    isError: (error: unknown) => error is MessageErrorClass;
+    isErrorType: <T extends MessageErrorClass>(error: unknown, errorClass: new (...args: any[]) => T) => error is T;
+}
 /**
  * Ketrics Platform SDK Interface
  *
  * The complete SDK interface available as the global `ketrics` object
- * in tenant application code.
+ * in tenant application code. Each module groups its operations, error
+ * classes, and type guards under a single namespace.
  *
  * @example
  * ```typescript
@@ -118,8 +383,8 @@ import { isMessageError, isMessageErrorType } from './messages-errors';
  * const response = await ketrics.http.get('https://api.example.com/data');
  * console.log(response.data);
  *
- * // Access databases (new static factory pattern)
- * const db = await ketrics.DatabaseConnection.connect('main-db');
+ * // Access databases
+ * const db = await ketrics.Database.connect('main-db');
  * const result = await db.query('SELECT * FROM users');
  * await db.close();
  *
@@ -154,134 +419,20 @@ export interface KetricsSdkV1 {
     console: ConsoleLogger;
     /** HTTP client for external API requests */
     http: HttpClient;
-    /** Volume class with static connect() factory method */
-    Volume: {
-        connect(volumeCode: string): Promise<IVolume>;
-    };
-    /** Base error class for all Volume errors (abstract) */
-    VolumeError: typeof VolumeErrorClass;
-    /** Error thrown when volume doesn't exist */
-    VolumeNotFoundError: typeof VolumeNotFoundErrorClass;
-    /** Error thrown when application has no access grant */
-    VolumeAccessDeniedError: typeof VolumeAccessDeniedErrorClass;
-    /** Error thrown when operation requires missing permission */
-    VolumePermissionDeniedError: typeof VolumePermissionDeniedErrorClass;
-    /** Error thrown when file doesn't exist */
-    FileNotFoundError: typeof FileNotFoundErrorClass;
-    /** Error thrown when file already exists (with ifNotExists option) */
-    FileAlreadyExistsError: typeof FileAlreadyExistsErrorClass;
-    /** Error thrown for invalid path characters or traversal attempts */
-    InvalidPathError: typeof InvalidPathErrorClass;
-    /** Error thrown when file exceeds size limit */
-    FileSizeLimitError: typeof FileSizeLimitErrorClass;
-    /** Error thrown when content type is not allowed */
-    ContentTypeNotAllowedError: typeof ContentTypeNotAllowedErrorClass;
-    /** Type guard to check if error is a VolumeError */
-    isVolumeError: typeof isVolumeError;
-    /** Type guard to check if error is a specific VolumeError type */
-    isVolumeErrorType: typeof isVolumeErrorType;
-    /** DatabaseConnection class with static connect() factory method */
-    DatabaseConnection: {
-        connect(databaseCode: string): Promise<IDatabaseConnection>;
-    };
-    /** Base error class for all Database errors (abstract) */
-    DatabaseError: typeof DatabaseErrorClass;
-    /** Error thrown when database doesn't exist */
-    DatabaseNotFoundError: typeof DatabaseNotFoundErrorClass;
-    /** Error thrown when application has no access grant */
-    DatabaseAccessDeniedError: typeof DatabaseAccessDeniedErrorClass;
-    /** Error thrown when connection cannot be established */
-    DatabaseConnectionError: typeof DatabaseConnectionErrorClass;
-    /** Error thrown when query execution fails */
-    DatabaseQueryError: typeof DatabaseQueryErrorClass;
-    /** Error thrown when transaction fails */
-    DatabaseTransactionError: typeof DatabaseTransactionErrorClass;
-    /** Type guard to check if error is a DatabaseError */
-    isDatabaseError: typeof isDatabaseError;
-    /** Type guard to check if error is a specific DatabaseError type */
-    isDatabaseErrorType: typeof isDatabaseErrorType;
-    /** Secret class with static get() method */
-    Secret: {
-        get(secretCode: string): Promise<string>;
-        exists(secretCode: string): Promise<boolean>;
-    };
-    /** Base error class for all Secret errors (abstract) */
-    SecretError: typeof SecretErrorClass;
-    /** Error thrown when secret doesn't exist */
-    SecretNotFoundError: typeof SecretNotFoundErrorClass;
-    /** Error thrown when application has no access grant */
-    SecretAccessDeniedError: typeof SecretAccessDeniedErrorClass;
-    /** Error thrown when decryption fails */
-    SecretDecryptionError: typeof SecretDecryptionErrorClass;
-    /** Type guard to check if error is a SecretError */
-    isSecretError: typeof isSecretError;
-    /** Type guard to check if error is a specific SecretError type */
-    isSecretErrorType: typeof isSecretErrorType;
-    /** Excel class with static read() and create() methods */
-    Excel: {
-        read(buffer: Buffer): Promise<IExcelWorkbook>;
-        create(): IExcelWorkbook;
-    };
-    /** Base error class for all Excel errors (abstract) */
-    ExcelError: typeof ExcelErrorClass;
-    /** Error thrown when parsing Excel file fails */
-    ExcelParseError: typeof ExcelParseErrorClass;
-    /** Error thrown when writing Excel file fails */
-    ExcelWriteError: typeof ExcelWriteErrorClass;
-    /** Type guard to check if error is an ExcelError */
-    isExcelError: typeof isExcelError;
-    /** Type guard to check if error is a specific ExcelError type */
-    isExcelErrorType: typeof isExcelErrorType;
-    /** PDF class with static read() and create() methods */
-    Pdf: {
-        read(buffer: Buffer): Promise<IPdfDocument>;
-        create(): Promise<IPdfDocument>;
-        rgb(r: number, g: number, b: number): PdfRgbColor;
-    };
-    /** Base error class for all PDF errors (abstract) */
-    PdfError: typeof PdfErrorClass;
-    /** Error thrown when parsing PDF file fails */
-    PdfParseError: typeof PdfParseErrorClass;
-    /** Error thrown when writing PDF file fails */
-    PdfWriteError: typeof PdfWriteErrorClass;
-    /** Type guard to check if error is a PdfError */
-    isPdfError: typeof isPdfError;
-    /** Type guard to check if error is a specific PdfError type */
-    isPdfErrorType: typeof isPdfErrorType;
-    /** Job class with static methods for background job operations */
-    Job: {
-        runInBackground(params: RunInBackgroundParams): Promise<string>;
-        getStatus(jobId: string): Promise<JobStatus>;
-        list(params?: JobListParams): Promise<JobListResult>;
-    };
-    /** Base error class for all job errors */
-    JobError: typeof JobErrorClass;
-    /** Thrown when a job is not found */
-    JobNotFoundError: typeof JobNotFoundErrorClass;
-    /** Thrown when function name is invalid or missing */
-    InvalidFunctionError: typeof InvalidFunctionErrorClass;
-    /** Thrown when cross-app job lacks required permission */
-    CrossAppPermissionError: typeof CrossAppPermissionErrorClass;
-    /** Thrown when job execution fails */
-    JobExecutionError: typeof JobExecutionErrorClass;
-    /** Type guard to check if error is a JobError */
-    isJobError: typeof isJobError;
-    /** Type guard to check if error is a specific JobError type */
-    isJobErrorType: typeof isJobErrorType;
-    /** Messages class with static methods for sending messages to users */
-    Messages: MessagesManager;
-    /** Base error class for all message errors */
-    MessageError: typeof MessageErrorClass;
-    /** Error thrown when message validation fails */
-    MessageValidationError: typeof MessageValidationErrorClass;
-    /** Error thrown when group is not found */
-    GroupNotFoundError: typeof GroupNotFoundErrorClass;
-    /** Error thrown when TenantGrant permissions are missing */
-    TenantGrantPermissionDeniedError: typeof TenantGrantPermissionDeniedErrorClass;
-    /** Type guard to check if error is a MessageError */
-    isMessageError: typeof isMessageError;
-    /** Type guard to check if error is a specific MessageError type */
-    isMessageErrorType: typeof isMessageErrorType;
+    /** Volume SDK - S3-backed file storage */
+    Volume: VolumeModule;
+    /** Database SDK - External SQL database access */
+    Database: DatabaseModule;
+    /** Secret SDK - Encrypted secret values */
+    Secret: SecretModule;
+    /** Excel SDK - Excel file reading and writing */
+    Excel: ExcelModule;
+    /** PDF SDK - PDF file reading, creation, and modification */
+    Pdf: PdfModule;
+    /** Job SDK - Async background job execution */
+    Job: JobGroupedModule;
+    /** Messages SDK - Application message delivery */
+    Messages: MessagesGroupedModule;
 }
 /**
  * Volume - S3-backed storage for tenant applications
@@ -310,10 +461,10 @@ export interface KetricsSdkV1 {
  *     }
  *
  *   } catch (error) {
- *     // Error classes are on the ketrics object
- *     if (error instanceof ketrics.VolumeNotFoundError) {
+ *     // Error classes are grouped under the module namespace
+ *     if (error instanceof ketrics.Volume.NotFoundError) {
  *       console.log('Volume not found');
- *     } else if (error instanceof ketrics.FileNotFoundError) {
+ *     } else if (error instanceof ketrics.Volume.FileNotFoundError) {
  *       console.log('File not found:', error.key);
  *     }
  *   }
@@ -337,16 +488,16 @@ export declare class Volume {
     static connect(volumeCode: string): Promise<IVolume>;
 }
 /**
- * DatabaseConnection - External database access for tenant applications
+ * Database - External database access for tenant applications
  *
- * Access via `ketrics.DatabaseConnection.connect()` to obtain an instance.
+ * Access via `ketrics.Database.connect()` to obtain an instance.
  *
  * @example
  * ```typescript
  * export async function handler() {
  *   try {
  *     // Connect to a database
- *     const db = await ketrics.DatabaseConnection.connect('main-db');
+ *     const db = await ketrics.Database.connect('main-db');
  *
  *     // Query data
  *     const result = await db.query('SELECT * FROM users WHERE id = ?', [1]);
@@ -365,16 +516,16 @@ export declare class Volume {
  *     await db.close();
  *
  *   } catch (error) {
- *     if (error instanceof ketrics.DatabaseNotFoundError) {
+ *     if (error instanceof ketrics.Database.NotFoundError) {
  *       console.log('Database not found');
- *     } else if (error instanceof ketrics.DatabaseAccessDeniedError) {
+ *     } else if (error instanceof ketrics.Database.AccessDeniedError) {
  *       console.log('No access to database');
  *     }
  *   }
  * }
  * ```
  */
-export declare class DatabaseConnection {
+export declare class Database {
     private constructor();
     /** Database code (read-only) */
     readonly code: string;
@@ -384,10 +535,10 @@ export declare class DatabaseConnection {
      * Connect to a database by code
      *
      * @param databaseCode - Database code (e.g., "main-db", "analytics-db")
-     * @returns Connected DatabaseConnection instance
-     * @throws DatabaseNotFoundError if database doesn't exist
-     * @throws DatabaseAccessDeniedError if application has no access grant
-     * @throws DatabaseConnectionError if connection cannot be established
+     * @returns Connected Database instance
+     * @throws Database.NotFoundError if database doesn't exist
+     * @throws Database.AccessDeniedError if application has no access grant
+     * @throws Database.ConnectionError if connection cannot be established
      */
     static connect(databaseCode: string): Promise<IDatabaseConnection>;
 }
@@ -411,9 +562,9 @@ export declare class DatabaseConnection {
  *     }
  *
  *   } catch (error) {
- *     if (error instanceof ketrics.SecretNotFoundError) {
+ *     if (error instanceof ketrics.Secret.NotFoundError) {
  *       console.log('Secret not found');
- *     } else if (error instanceof ketrics.SecretAccessDeniedError) {
+ *     } else if (error instanceof ketrics.Secret.AccessDeniedError) {
  *       console.log('No access to secret');
  *     }
  *   }
@@ -472,9 +623,9 @@ export declare class Secret {
  *     await volume.put('output.xlsx', buffer);
  *
  *   } catch (error) {
- *     if (error instanceof ketrics.ExcelParseError) {
+ *     if (error instanceof ketrics.Excel.ParseError) {
  *       console.log('Failed to parse Excel file');
- *     } else if (error instanceof ketrics.ExcelWriteError) {
+ *     } else if (error instanceof ketrics.Excel.WriteError) {
  *       console.log('Failed to write Excel file');
  *     }
  *   }
@@ -529,9 +680,9 @@ export declare class Excel {
  *     await volume.put('output.pdf', buffer);
  *
  *   } catch (error) {
- *     if (error instanceof ketrics.PdfParseError) {
+ *     if (error instanceof ketrics.Pdf.ParseError) {
  *       console.log('Failed to parse PDF file');
- *     } else if (error instanceof ketrics.PdfWriteError) {
+ *     } else if (error instanceof ketrics.Pdf.WriteError) {
  *       console.log('Failed to write PDF file');
  *     }
  *   }
@@ -592,11 +743,11 @@ export declare class Pdf {
  *     console.log('Pending jobs:', result.jobs.length);
  *
  *   } catch (error) {
- *     if (error instanceof ketrics.JobNotFoundError) {
+ *     if (error instanceof ketrics.Job.NotFoundError) {
  *       console.log('Job not found');
- *     } else if (error instanceof ketrics.InvalidFunctionError) {
+ *     } else if (error instanceof ketrics.Job.InvalidFunctionError) {
  *       console.log('Invalid function name');
- *     } else if (error instanceof ketrics.CrossAppPermissionError) {
+ *     } else if (error instanceof ketrics.Job.CrossAppPermissionError) {
  *       console.log('Cross-app permission denied');
  *     }
  *   }
@@ -636,15 +787,13 @@ export declare class Job {
  * The `ketrics` global object provides:
  * - Context: tenant, application, requestor, runtime, environment
  * - Utilities: console, http
- * - Volume: Static class for S3 storage
- * - DatabaseConnection: Static class for database access
- * - Secret: Static class for secret retrieval
- * - Excel: Static class for Excel file operations
- * - Pdf: Static class for PDF file operations
- * - Job: Static class for background job execution
- * - Messages: Static class for user messaging
- * - Error classes: For instanceof checks
- * - Type guards: For error type checking
+ * - Volume: S3 storage (connect, errors, type guards)
+ * - Database: SQL database access (connect, errors, type guards)
+ * - Secret: Encrypted secrets (get, exists, errors, type guards)
+ * - Excel: Excel file operations (read, create, errors, type guards)
+ * - Pdf: PDF file operations (read, create, rgb, errors, type guards)
+ * - Job: Background job execution (runInBackground, getStatus, list, errors, type guards)
+ * - Messages: Application messaging (send, sendBulk, sendToGroup, errors, type guards)
  */
 declare global {
     /** Ketrics SDK global object - available in all tenant application code */