@vritti/api-sdk 0.2.4 → 0.2.6

package/dist/index.d.ts

@@ -1,107 +1,91 @@
+import { FastifyRequest, FastifyReply, VrittiSessionInfo } from 'fastify';
 import * as _nestjs_common from '@nestjs/common';
-import { DynamicModule, CanActivate, ExecutionContext, OnModuleInit, OnModuleDestroy, InjectionToken, Logger, HttpException, HttpStatus, ExceptionFilter, ArgumentsHost, ModuleMetadata, Type, LoggerService as LoggerService$1, NestInterceptor, CallHandler, NestModule, MiddlewareConsumer, NestMiddleware } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
+import { InjectionToken, DynamicModule, CanActivate, ExecutionContext, OnModuleInit, OnModuleDestroy, Logger, HttpException, HttpStatus, ExceptionFilter, ArgumentsHost, ModuleMetadata, Type, LoggerService as LoggerService$1, NestInterceptor, CallHandler, NestModule, MiddlewareConsumer, NestMiddleware } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
-import { JwtService, JwtModuleOptions, JwtSignOptions } from '@nestjs/jwt';
-import { FastifyRequest, FastifyReply } from 'fastify';
-import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import * as drizzle_orm from 'drizzle-orm';
-import { Column, SQL, InferInsertModel, InferSelectModel } from 'drizzle-orm';
+import { JwtService, JwtSignOptions } from '@nestjs/jwt';
+import { ConfigService } from '@nestjs/config';
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-import { PgTable } from 'drizzle-orm/pg-core';
+import { PgTable, PgSequence, PgColumn } from 'drizzle-orm/pg-core';
+import { SQL, InferInsertModel, InferSelectModel, Column } from 'drizzle-orm';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { PoolClient } from 'pg';
+import { ValidationOptions } from 'class-validator';
 import { Observable } from 'rxjs';
 import { AsyncLocalStorage } from 'node:async_hooks';
-
-interface TenantInfo {
-    id: string;
-    subdomain: string;
-    type: 'SHARED' | 'DEDICATED';
-    status: string;
-    schemaName?: string;
-    databaseName?: string;
-    databaseHost?: string;
-    databasePort?: number;
-    databaseUsername?: string;
-    databasePassword?: string;
-    databaseSslMode?: string;
-    connectionPoolSize?: number;
-}
-
-declare module 'fastify' {
-    interface FastifyRequest {
-        sessionInfo?: {
-            userId: string;
-            sessionId: string;
-            sessionType: string;
-        };
-        tenant?: TenantInfo;
-        cookies?: Record<string, string>;
-    }
-}
-
-declare class AuthConfigModule {
-    static forRootAsync(): DynamicModule;
-}
-
-declare const AccessToken: (...dataOrPipes: unknown[]) => ParameterDecorator;
-
-declare const CookieDomain: (...dataOrPipes: unknown[]) => ParameterDecorator;
-
-declare const Onboarding: () => _nestjs_common.CustomDecorator<string>;
-
-declare const Public: () => _nestjs_common.CustomDecorator<string>;
-
-declare const RefreshCookieOptions: (...dataOrPipes: unknown[]) => ParameterDecorator;
-
-declare const RefreshTokenCookie: (...dataOrPipes: unknown[]) => ParameterDecorator;
-
-declare const RESET_KEY = "isReset";
-declare const Reset: () => _nestjs_common.CustomDecorator<string>;
-
-interface SessionInfo {
-    userId: string;
-    sessionId: string;
-    sessionType: string;
-}
-declare const SessionData: (...dataOrPipes: unknown[]) => ParameterDecorator;
-
-declare const UserId: (...dataOrPipes: unknown[]) => ParameterDecorator;
+export { Currency, CurrencyCode, SUPPORTED_CURRENCIES, majorToMinor, minorToMajor } from './money.js';
+import { ClientProxy } from '@nestjs/microservices';
+import 'dinero.js/bigint';
 
 declare class RequestService {
     private readonly request;
-    constructor(request: FastifyRequest);
-    getTenantIdentifier(): string | null;
+    private readonly config;
+    constructor(request: FastifyRequest, config: AuthConfig);
     getAccessToken(): string | null;
     getRefreshToken(): string | null;
     getHeader(key: string): string | string[] | undefined;
+    getHostname(): string;
     getAllHeaders(): FastifyRequest['headers'];
 }
 
-declare class VrittiAuthGuard implements CanActivate {
-    private readonly reflector;
-    readonly _configService: ConfigService;
-    private readonly jwtService;
-    private readonly requestService;
-    private readonly logger;
-    constructor(reflector: Reflector, _configService: ConfigService, jwtService: JwtService, requestService: RequestService);
-    canActivate(context: ExecutionContext): Promise<boolean>;
-    private validateAccessToken;
-    private validateRefreshTokenBinding;
-    private handleSseAuth;
-    private validateCsrf;
-}
-
-declare const jwtConfigFactory: (configService: ConfigService) => JwtModuleOptions;
+declare const AUTH_CONFIG: unique symbol;
+type OnAuthenticatedCallback = (requestService: RequestService, sessionInfo: NonNullable<FastifyRequest['sessionInfo']>) => void | Promise<void>;
 type TokenExpiryString = `${number}${'s' | 'm' | 'h' | 'd' | 'w' | 'y'}`;
 interface TokenExpiry {
     access: TokenExpiryString;
     refresh: TokenExpiryString;
 }
-declare const getTokenExpiry: (configService: ConfigService) => TokenExpiry;
+interface CookieConfig {
+    refreshCookieName: string;
+    refreshCookieMaxAge: number;
+    refreshCookiePath: string;
+    refreshCookieSecure: boolean;
+    refreshCookieSameSite: 'strict' | 'lax' | 'none';
+    refreshCookieDomain?: string;
+}
+interface GuardConfig {
+    authHeaderName: string;
+    tokenPrefix: string;
+    csrfExemptSessionTypes?: string[];
+    refreshTokenBindingExemptSessionTypes?: string[];
+    onAuthenticated?: OnAuthenticatedCallback;
+}
+interface AuthConfig {
+    tokenExpiry: TokenExpiry;
+    cookie: CookieConfig;
+    guard: GuardConfig;
+}
+declare const AUTH_CONFIG_DEFAULTS: {
+    cookie: {
+        refreshCookieName: string;
+        refreshCookieMaxAge: number;
+        refreshCookiePath: string;
+        refreshCookieSecure: boolean;
+        refreshCookieSameSite: "strict";
+        refreshCookieDomain: string;
+    };
+    guard: {
+        authHeaderName: string;
+        tokenPrefix: string;
+        csrfExemptSessionTypes: never[];
+        refreshTokenBindingExemptSessionTypes: never[];
+    };
+};
+interface CookieSerializeOptions {
+    httpOnly: boolean;
+    secure: boolean;
+    sameSite: 'strict' | 'lax' | 'none';
+    path: string;
+    maxAge: number;
+    domain: string;
+}
 declare enum TokenType {
     ACCESS = "access",
     REFRESH = "refresh"
 }
+interface JwtClaims {
+    exp: number;
+    iat: number;
+}
 interface AccessTokenPayload {
     sessionType: string;
     tokenType: TokenType.ACCESS;
@@ -109,21 +93,77 @@ interface AccessTokenPayload {
     sessionId: string;
     refreshTokenHash: string;
 }
+type DecodedAccessToken = AccessTokenPayload & JwtClaims;
 interface RefreshTokenPayload {
     sessionType: string;
     tokenType: TokenType.REFRESH;
     userId: string;
     sessionId: string;
 }
+type DecodedRefreshToken = RefreshTokenPayload & JwtClaims;
+
+declare module 'fastify' {
+    interface VrittiSessionInfo {
+        userId: string;
+        sessionId: string;
+        sessionType: string;
+    }
+    interface FastifyRequest {
+        sessionInfo?: VrittiSessionInfo;
+        authConfig?: AuthConfig;
+        cookies?: Record<string, string>;
+    }
+}
+
+interface AuthConfigInput {
+    tokenExpiry: TokenExpiry;
+    cookie?: Partial<CookieConfig>;
+    guard?: Partial<GuardConfig>;
+}
+interface AuthConfigModuleOptions<T extends unknown[] = unknown[]> {
+    useFactory: (...args: [...T]) => AuthConfigInput | Promise<AuthConfigInput>;
+    inject?: InjectionToken[];
+}
+declare class AuthConfigModule {
+    static forRootAsync<T extends unknown[] = unknown[]>(options: AuthConfigModuleOptions<T>): DynamicModule;
+}
+
+declare const AccessToken: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const CookieDomain: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const CookieName: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const Hostname: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const Public: () => _nestjs_common.CustomDecorator<string>;
+
+declare const RefreshCookieOptions: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const RefreshTokenCookie: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const REQUIRE_SESSION_KEY = "requiredSessionTypes";
+declare const RequireSession: (...types: string[]) => _nestjs_common.CustomDecorator<string>;
+
+interface SessionInfo$1 {
+    userId: string;
+    sessionId: string;
+    sessionType: string;
+}
+declare const SessionData: (...dataOrPipes: unknown[]) => ParameterDecorator;
 
-declare class JwtAuthService {
+declare const Subdomain: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const UserId: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+type SessionInfo = NonNullable<FastifyRequest['sessionInfo']>;
+declare class TokenService {
     private readonly jwtService;
-    readonly configService: ConfigService;
+    private readonly config;
     private readonly logger;
-    private readonly tokenExpiry;
-    constructor(jwtService: JwtService, configService: ConfigService);
-    generateAccessToken(userId: string, sessionId: string, sessionType: string, refreshToken: string): string;
-    generateRefreshToken(userId: string, sessionId: string, sessionType: string): string;
+    constructor(jwtService: JwtService, config: AuthConfig);
+    generateAccessToken(sessionInfo: SessionInfo, refreshToken: string): string;
+    generateRefreshToken(sessionInfo: SessionInfo): string;
     sign(payload: object, options?: JwtSignOptions): string;
     verify(token: string, expectedType: TokenType): {
         userId: string;
@@ -133,6 +173,22 @@ declare class JwtAuthService {
     };
     getExpiryTime(type: TokenType): Date;
     getExpiryInSeconds(type: TokenType): number;
+    validateAccessToken(token: string): DecodedAccessToken;
+    validateRefreshToken(token: string): DecodedRefreshToken;
+    validateTokenBinding(accessToken: DecodedAccessToken, refreshToken: string): void;
+}
+
+declare class VrittiAuthGuard implements CanActivate {
+    private readonly reflector;
+    private readonly requestService;
+    private readonly tokenService;
+    private readonly config;
+    private readonly logger;
+    constructor(reflector: Reflector, requestService: RequestService, tokenService: TokenService, config: AuthConfig);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    private handleHttpAuth;
+    private handleSseAuth;
+    private validateCsrf;
 }
 
 declare function hashToken(token: string): string;
@@ -179,116 +235,32 @@ declare class RedisCacheProvider implements ICacheProvider, OnModuleInit, OnModu
     getMemoryInfo(): Promise<string>;
 }
 
-interface CookieConfig {
-    refreshCookieName: string;
-    refreshCookieMaxAge: number;
-    refreshCookiePath: string;
-    refreshCookieSecure: boolean;
-    refreshCookieSameSite: 'strict' | 'lax' | 'none';
-    refreshCookieDomain?: string;
-}
-interface CookieSerializeOptions {
-    httpOnly: boolean;
-    secure: boolean;
-    sameSite: 'strict' | 'lax' | 'none';
-    path: string;
-    maxAge: number;
-    domain: string;
-}
-interface JwtConfig {
-    accessTokenExpiry: string;
-    refreshTokenExpiry: string;
-    onboardingTokenExpiry: string;
-}
-interface GuardConfig {
-    tenantHeaderName: string;
-    authHeaderName: string;
-    tokenPrefix: string;
-}
-interface ApiSdkConfig {
-    cookie?: Partial<CookieConfig>;
-    jwt?: Partial<JwtConfig>;
-    guard?: Partial<GuardConfig>;
-}
-interface FullConfig {
-    cookie: CookieConfig;
-    jwt: JwtConfig;
-    guard: GuardConfig;
-}
-declare function defineConfig(config: ApiSdkConfig): ApiSdkConfig;
-declare function configureApiSdk(userConfig: ApiSdkConfig): void;
-declare function getConfig(): FullConfig;
-declare function resetConfig(): void;
-declare function getRefreshCookieOptions(): Omit<CookieSerializeOptions, 'domain'> & {
-    domain?: string;
-};
-declare function getRefreshCookieOptionsForHost(hostname: string): CookieSerializeOptions;
-declare function getJwtExpiry(): {
-    access: string;
-    refresh: string;
-    onboarding: string;
-};
-
-type SchemaRegistry = {};
-type RegisteredSchema = SchemaRegistry extends {
-    schema: infer S;
-} ? S : Record<string, unknown>;
-type TypedDrizzleClient = NodePgDatabase<RegisteredSchema>;
-
-interface PrimaryDbConfig {
-    host: string;
-    port?: number;
-    username: string;
-    password: string;
-    database: string;
-    schema?: string;
-    sslMode?: 'require' | 'prefer' | 'disable' | 'no-verify';
-}
-interface DatabaseModuleOptions {
-    primaryDb: PrimaryDbConfig;
-    drizzleSchema: RegisteredSchema;
-    drizzleRelations?: Record<string, any>;
-    connectionCacheTTL?: number;
-    maxConnections?: number;
-    encryptionKey?: string;
-}
-
-declare class DatabaseModule {
-    static forServer(options: {
-        useFactory: (...args: unknown[]) => Promise<DatabaseModuleOptions> | DatabaseModuleOptions;
-        inject?: InjectionToken[];
-    }): DynamicModule;
-    static forMicroservice(options: {
-        useFactory: (...args: unknown[]) => Promise<DatabaseModuleOptions> | DatabaseModuleOptions;
-        inject?: InjectionToken[];
-    }): DynamicModule;
-    private static createDynamicModule;
-}
-
-declare const Tenant: (...dataOrPipes: unknown[]) => ParameterDecorator;
+declare const DATA_TABLE_VIEWS_TABLE: unique symbol;
 
-declare class SelectOptionsQueryDto {
-    search?: string;
-    limit?: number;
-    offset?: number;
-    values?: string;
-    excludeIds?: string;
-    valueKey?: string;
-    labelKey?: string;
-    descriptionKey?: string;
-    groupIdKey?: string;
+interface DataTableModuleOptions {
+    tableViews: PgTable;
 }
-
-declare class SuccessResponseDto {
-    success: boolean;
-    message: string;
+declare class DataTableModule {
+    static forRoot(options: DataTableModuleOptions): DynamicModule;
 }
 
-type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'gt' | 'gte' | 'lt' | 'lte';
+type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'gt' | 'gte' | 'lt' | 'lte' | 'isAnyOf' | 'isNotAnyOf';
+declare const FilterOperators: {
+    readonly EQUALS: "equals";
+    readonly NOT_EQUALS: "notEquals";
+    readonly CONTAINS: "contains";
+    readonly NOT_CONTAINS: "notContains";
+    readonly GT: "gt";
+    readonly GTE: "gte";
+    readonly LT: "lt";
+    readonly LTE: "lte";
+    readonly IS_ANY_OF: "isAnyOf";
+    readonly IS_NOT_ANY_OF: "isNotAnyOf";
+};
 interface FilterCondition {
     field: string;
     operator: FilterOperator;
-    value: string | number;
+    value: string | number | string[];
 }
 interface SortCondition {
     field: string;
@@ -314,32 +286,108 @@ interface TableViewState {
     density: DensityType;
     filterOrder: string[];
     filterVisibility: Record<string, boolean>;
-    search?: SearchState | null;
-    pagination?: {
+    search: SearchState | null;
+    pagination: {
         limit: number;
         offset: number;
     };
 }
 
-declare class TableResponseDto<T> {
-    result: T[];
-    count: number;
+declare function dataTableViewsColumns(): {
+    id: drizzle_orm_pg_core.SetHasDefault<drizzle_orm_pg_core.SetIsPrimaryKey<drizzle_orm_pg_core.PgUUIDBuilder>>;
+    userId: drizzle_orm_pg_core.SetNotNull<drizzle_orm_pg_core.PgUUIDBuilder>;
+    tableSlug: drizzle_orm_pg_core.SetNotNull<drizzle_orm_pg_core.PgVarcharBuilder<[string, ...string[]]>>;
+    name: drizzle_orm_pg_core.SetNotNull<drizzle_orm_pg_core.PgVarcharBuilder<[string, ...string[]]>>;
+    state: drizzle_orm_pg_core.Set$Type<drizzle_orm_pg_core.SetNotNull<drizzle_orm_pg_core.PgJsonbBuilder>, TableViewState>;
+    isShared: drizzle_orm_pg_core.SetHasDefault<drizzle_orm_pg_core.SetNotNull<drizzle_orm_pg_core.PgBooleanBuilder>>;
+    createdAt: drizzle_orm_pg_core.SetHasDefault<drizzle_orm_pg_core.SetNotNull<drizzle_orm_pg_core.PgTimestampBuilder>>;
+    updatedAt: drizzle_orm_pg_core.SetHasDefault<drizzle_orm_pg_core.PgTimestampBuilder>;
+};
+declare function dataTableViewsIndexes(table: any): drizzle_orm_pg_core.IndexBuilder[];
+interface DataTableViewRecord {
+    id: string;
+    userId: string;
+    tableSlug: string;
+    name: string;
     state: TableViewState;
-    activeViewId: string | null;
+    isShared: boolean;
+    createdAt: Date;
+    updatedAt: Date | null | undefined;
+}
+interface NewDataTableViewRecord {
+    userId: string;
+    tableSlug: string;
+    name: string;
+    state: TableViewState;
+    isShared?: boolean;
 }
 
-type FieldDefinition = {
-    column: Column;
-    type: 'string' | 'number' | 'boolean';
-} | {
-    expression: (value: string | number) => SQL;
-    type: 'string' | 'number' | 'boolean';
-};
-type FieldMap = Record<string, FieldDefinition>;
-declare class FilterProcessor {
-    static buildWhere(filters: FilterCondition[] | undefined, fieldMap: FieldMap): SQL | undefined;
-    static buildSearch(search: SearchState | null | undefined, fieldMap: FieldMap): SQL | undefined;
-    static buildOrderBy(sort: SortCondition[] | undefined, fieldMap: FieldMap): SQL[];
+declare class UpsertDataTableStateDto {
+    tableSlug: string;
+    state: TableViewState;
+    activeViewId?: string | null;
+}
+
+declare class DataTableStateService {
+    private readonly cacheService;
+    private readonly configService;
+    private readonly logger;
+    constructor(cacheService: CacheService, configService: ConfigService);
+    private get stateTtl();
+    upsertCurrentState(userId: string, dto: UpsertDataTableStateDto): Promise<void>;
+    getCurrentState(userId: string, tableSlug: string): Promise<{
+        state: TableViewState;
+        activeViewId: string | null;
+    }>;
+}
+
+declare class DataTableViewDto {
+    id: string;
+    name: string | null;
+    tableSlug: string;
+    state: TableViewState;
+    isShared: boolean;
+    isOwn: boolean;
+    createdAt: Date;
+    updatedAt: Date | null;
+    static from(view: DataTableViewRecord, userId: string): DataTableViewDto;
+}
+
+declare class CreateDataTableViewDto {
+    name: string;
+    tableSlug: string;
+    state: TableViewState;
+    isShared?: boolean;
+}
+
+declare class RenameDataTableViewDto {
+    name: string;
+}
+
+declare class ToggleShareDataTableViewDto {
+    isShared: boolean;
+}
+
+declare class UpdateDataTableViewDto {
+    state: TableViewState;
+}
+
+type TypedDrizzleClient = NodePgDatabase;
+
+interface PrimaryDbConfig {
+    host: string;
+    port?: number;
+    username: string;
+    password: string;
+    database: string;
+    schema?: string;
+    sslMode?: 'require' | 'prefer' | 'disable' | 'no-verify';
+}
+interface DatabaseModuleOptions {
+    primaryDb: PrimaryDbConfig;
+    drizzleRelations?: Record<string, any>;
+    maxConnections?: number;
+    applyRlsContext?: (client: PoolClient, ctx: unknown) => Promise<void>;
 }
 
 declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
@@ -347,18 +395,15 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
     private readonly logger;
     private pool;
     private db;
-    private readonly tenantConfigCache;
-    private readonly cacheTTL;
+    private readonly rlsAls;
+    private readonly txAls;
     constructor(options: DatabaseModuleOptions);
     onModuleInit(): Promise<void>;
     private initializeDrizzleClient;
-    getTenantInfo(tenantIdentifier: string): Promise<TenantInfo | null>;
-    private cacheInfo;
-    clearTenantCache(tenantIdentifier: string): void;
-    clearAllCaches(): void;
     get drizzleClient(): TypedDrizzleClient;
-    get schema(): typeof this$1.options.drizzleSchema;
-    private decrypt;
+    runWithRlsContext<T>(rls: unknown, fn: () => Promise<T>): Promise<T>;
+    runInTransaction<T>(fn: () => Promise<T>): Promise<T>;
+    runWithPinnedConnection<T>(fn: () => Promise<T>): Promise<T>;
     onModuleDestroy(): Promise<void>;
 }
 
@@ -366,6 +411,7 @@ interface SelectQueryOption {
     value: string | number | boolean;
     label: string;
     description?: string;
+    additionals?: Record<string, string | number | boolean | null>;
     groupId?: string | number;
 }
 interface SelectQueryGroup {
@@ -387,20 +433,25 @@ interface FindForSelectConfig {
     value: string;
     label: string;
     description?: string;
-    groupId?: string;
+    additionalKeys?: string | string[];
+    additionalExpressions?: Record<string, SQL>;
+    groupIdKey?: string;
     search?: string;
     limit?: number;
     offset?: number;
     where?: Record<string, unknown>;
+    orderByKey?: string;
+    orderDirection?: 'asc' | 'desc';
     orderBy?: Record<string, 'asc' | 'desc'>;
     groups?: SelectQueryGroup[];
     values?: string | (string | number | boolean)[];
     excludeIds?: string | (string | number | boolean)[];
     groupTable?: PgTable;
     groupLabelKey?: string;
-    groupIdKey?: string;
+    groupTableIdKey?: string;
     joins?: FindForSelectJoin[];
     conditions?: SQL[];
+    distinct?: boolean;
 }
 
 type RelationsWhereFilter = Record<string, unknown>;
@@ -423,11 +474,15 @@ declare abstract class PrimaryBaseRepository<TTable extends PgTable, TInsert = I
     protected readonly database: PrimaryDatabaseService;
     protected readonly table: TTable;
     protected readonly logger: Logger;
+    protected readonly sequence?: PgSequence;
     private readonly tableName;
     protected get db(): TypedDrizzleClient;
     protected get model(): TypedRelationalQueryBuilder<TSelect>;
-    constructor(database: PrimaryDatabaseService, table: TTable);
-    create(data: TInsert): Promise<TSelect>;
+    constructor(database: PrimaryDatabaseService, table: TTable, options?: {
+        sequence?: PgSequence;
+    });
+    protected nextSequenceValue(sequence?: PgSequence): Promise<number>;
+    create(data: TInsert, tx?: TypedDrizzleClient): Promise<TSelect>;
     findById(id: string): Promise<TSelect | undefined>;
     findOne(where: RelationsWhereFilter): Promise<TSelect | undefined>;
     findMany(options?: {
@@ -445,88 +500,185 @@ declare abstract class PrimaryBaseRepository<TTable extends PgTable, TInsert = I
         offset?: number;
         leftJoin?: {
             table: PgTable;
-            on: SQL;
+            on: SQL | undefined;
         };
+        leftJoins?: {
+            table: PgTable;
+            on: SQL | undefined;
+        }[];
+        groupBy?: (PgColumn | SQL)[];
     }): Promise<{
         result: TResult[];
         count: number;
     }>;
-    update(id: string, data: Partial<TInsert>): Promise<TSelect>;
-    updateMany(where: SQL, data: Partial<TInsert>): Promise<{
+    update(id: string, data: Partial<TInsert>, tx?: TypedDrizzleClient): Promise<TSelect>;
+    updateMany(where: SQL, data: Partial<TInsert>, tx?: TypedDrizzleClient): Promise<{
         count: number;
     }>;
-    delete(id: string): Promise<TSelect>;
-    deleteMany(where: SQL): Promise<{
+    delete(id: string, tx?: TypedDrizzleClient): Promise<TSelect>;
+    deleteMany(where: SQL, tx?: TypedDrizzleClient): Promise<{
         count: number;
     }>;
     count(where?: SQL): Promise<number>;
     exists(where: SQL): Promise<boolean>;
+    transaction<T>(callback: (tx: TypedDrizzleClient) => Promise<T>): Promise<T>;
     findForSelect(config: FindForSelectConfig): Promise<SelectQueryResult>;
 }
 
-declare class TenantContextService {
-    private tenantInfo;
-    setTenant(tenantInfo: TenantInfo): void;
-    getTenant(): TenantInfo;
-    hasTenant(): boolean;
-    clearTenant(): void;
-    getTenantIdSafe(): string | null;
-    getTenantSubdomainSafe(): string | null;
+declare class DataTableViewsRepository extends PrimaryBaseRepository<PgTable, NewDataTableViewRecord, DataTableViewRecord> {
+    constructor(database: PrimaryDatabaseService, table: PgTable);
+    findPersonalViewsBySlug(userId: string, tableSlug: string): Promise<DataTableViewRecord[]>;
+    findSharedViewsBySlug(tableSlug: string): Promise<DataTableViewRecord[]>;
 }
 
-declare class TenantDatabaseService implements OnModuleDestroy {
-    private readonly options;
-    private readonly tenantContext;
+declare class DataTableViewsService {
+    private readonly dataTableViewsRepository;
+    private readonly cacheService;
+    private readonly configService;
     private readonly logger;
-    private readonly clients;
-    private readonly clientLastUsed;
-    private cleanupInterval?;
-    constructor(options: DatabaseModuleOptions, tenantContext: TenantContextService);
-    get drizzleClient(): TypedDrizzleClient;
-    get schema(): Record<string, unknown>;
-    private getDbClient;
-    private createDbClientSync;
-    private buildTenantDbUrl;
-    private buildCacheKey;
-    private startConnectionCleaner;
-    private cleanupIdleConnections;
-    getPoolStats(): {
-        activeConnections: number;
-        tenants: string[];
-    };
-    private maskPassword;
-    onModuleDestroy(): Promise<void>;
+    constructor(dataTableViewsRepository: DataTableViewsRepository, cacheService: CacheService, configService: ConfigService);
+    private personalViewsKey;
+    private sharedViewsKey;
+    private get viewsTtl();
+    private getOrCachePersonalViews;
+    private getOrCacheSharedViews;
+    private invalidateViewsCache;
+    findViews(userId: string, tableSlug: string): Promise<DataTableViewDto[]>;
+    createView(userId: string, dto: CreateDataTableViewDto): Promise<DataTableViewDto>;
+    updateView(userId: string, id: string, dto: UpdateDataTableViewDto): Promise<DataTableViewDto>;
+    toggleShareView(userId: string, id: string, isShared: boolean): Promise<DataTableViewDto>;
+    renameView(userId: string, id: string, name: string): Promise<DataTableViewDto>;
+    deleteView(userId: string, id: string): Promise<DataTableViewDto>;
 }
 
-type ExtractTableName<TTable extends PgTable> = TTable['_']['name'];
-declare abstract class TenantBaseRepository<TTable extends PgTable, TInsert = InferInsertModel<TTable>, TSelect = InferSelectModel<TTable>> {
-    protected readonly database: TenantDatabaseService;
-    protected readonly table: TTable;
-    protected readonly logger: Logger;
-    private readonly tableName;
-    protected get db(): TypedDrizzleClient;
-    protected get model(): TypedDrizzleClient['query'][ExtractTableName<TTable> & keyof TypedDrizzleClient['query']];
-    constructor(database: TenantDatabaseService, table: TTable);
-    create(data: TInsert): Promise<TSelect>;
-    findById(id: string): Promise<TSelect | null>;
-    findOne(where: SQL): Promise<TSelect | null>;
-    findMany(options?: {
-        where?: SQL;
-        orderBy?: SQL;
-        limit?: number;
-        offset?: number;
-    }): Promise<TSelect[]>;
-    update(id: string, data: Partial<TInsert>): Promise<TSelect>;
-    updateMany(where: SQL, data: Partial<TInsert>): Promise<{
-        count: number;
-    }>;
-    delete(id: string): Promise<TSelect>;
-    deleteMany(where: SQL): Promise<{
-        count: number;
-    }>;
-    count(where?: SQL): Promise<number>;
-    exists(where: SQL): Promise<boolean>;
-    findForSelect(config: FindForSelectConfig): Promise<SelectQueryResult>;
+declare class DatabaseModule {
+    static forServer<T extends unknown[] = unknown[]>(options: {
+        useFactory: (...args: [...T]) => Promise<DatabaseModuleOptions> | DatabaseModuleOptions;
+        inject?: InjectionToken[];
+    }): DynamicModule;
+}
+
+declare class CreateResponseDto<T> {
+    success: boolean;
+    message: string;
+    data: T;
+}
+
+declare class ValidatedRowDto {
+    index: number;
+    data: Record<string, string>;
+    valid: boolean;
+    errors: string[];
+}
+declare class ImportSummaryDto {
+    total: number;
+    valid: number;
+    invalid: number;
+}
+declare class ImportResponseDto {
+    success: boolean;
+    message: string;
+    created?: number;
+    updated?: number;
+    skipped?: number;
+    rows?: ValidatedRowDto[];
+    summary?: ImportSummaryDto;
+}
+
+declare class SelectOptionsQueryDto {
+    search?: string;
+    limit?: number;
+    offset?: number;
+    values?: string;
+    excludeIds?: string;
+    valueKey?: string;
+    labelKey?: string;
+    descriptionKey?: string;
+    additionalKeys?: string;
+    groupIdKey?: string;
+    orderByKey?: string;
+    orderDirection?: 'asc' | 'desc';
+}
+
+declare class SuccessResponseDto {
+    success: boolean;
+    message: string;
+}
+
+declare class TableResponseDto<T> {
+    result: T[];
+    count: number;
+    state: TableViewState;
+    activeViewId: string | null;
+}
+
+type FieldDefinition = {
+    column: Column;
+    type: 'string' | 'number' | 'boolean';
+} | {
+    expression: (value: string | number, operator: FilterOperator) => SQL;
+    type: 'string' | 'number' | 'boolean';
+};
+type FieldMap = Record<string, FieldDefinition>;
+declare class FilterProcessor {
+    static buildWhere(filters: FilterCondition[] | undefined, fieldMap: FieldMap): SQL | undefined;
+    static buildSearch(search: SearchState | null | undefined, fieldMap: FieldMap): SQL | undefined;
+    static buildOrderBy(sort: SortCondition[] | undefined, fieldMap: FieldMap): SQL[];
+}
+
+declare function IsCurrency(validationOptions?: ValidationOptions): PropertyDecorator;
+
+declare function IsCurrencyCode(validationOptions?: ValidationOptions): PropertyDecorator;
+
+declare function IsDateTime(validationOptions?: ValidationOptions): PropertyDecorator;
+
+interface UploadedFileResult {
+    buffer: Buffer;
+    filename: string;
+    mimetype: string;
+}
+/**
+ * Extracts a single uploaded file from a Fastify multipart request.
+ * Pass an optional field name to match a specific form key.
+ *
+ * Requires `@fastify/multipart` to be registered on the Fastify instance.
+ * Throws `BadRequestException` if no file is present in the request.
+ *
+ * @example
+ * ```typescript
+ * @Post('upload')
+ * @ApiConsumes('multipart/form-data')
+ * async upload(
+ *   @UploadedFile() file: UploadedFileResult,          // grabs first file
+ *   @UploadedFile('avatar') avatar: UploadedFileResult, // grabs file with key "avatar"
+ * ) {}
+ * ```
+ */
+declare const UploadedFile: (...dataOrPipes: (string | _nestjs_common.PipeTransform<any, any> | _nestjs_common.Type<_nestjs_common.PipeTransform<any, any>> | undefined)[]) => ParameterDecorator;
+/**
+ * Extracts multiple uploaded files from a Fastify multipart request.
+ * Pass an optional field name to match only files under a specific form key.
+ *
+ * Requires `@fastify/multipart` to be registered on the Fastify instance.
+ * Throws `BadRequestException` if no files are present in the request.
+ *
+ * @example
+ * ```typescript
+ * @Post('upload')
+ * @ApiConsumes('multipart/form-data')
+ * async upload(
+ *   @UploadedFiles() files: UploadedFileResult[],              // grabs all files
+ *   @UploadedFiles('documents') docs: UploadedFileResult[],    // grabs files with key "documents"
+ * ) {}
+ * ```
+ */
+declare const UploadedFiles: (...dataOrPipes: (string | _nestjs_common.PipeTransform<any, any> | _nestjs_common.Type<_nestjs_common.PipeTransform<any, any>> | undefined)[]) => ParameterDecorator;
+
+declare class CurrencyAmountDto {
+    currency: string;
+    value: string;
+    static from(minor: bigint, currencyCode: string): CurrencyAmountDto;
+    static from(minor: bigint | null | undefined, currencyCode: string): CurrencyAmountDto | null;
 }
 
 declare class EmailModule {
@@ -543,6 +695,20 @@ declare class EmailService {
     sendPasswordResetEmail(email: string, otp: string, expiresAt: Date, displayName?: string): Promise<void>;
     sendEmailChangeNotification(oldEmail: string, newEmail: string, revertToken: string, revertExpiresAt: Date, displayName?: string): Promise<void>;
     sendEmailRevertConfirmation(email: string, displayName?: string): Promise<void>;
+    sendInviteEmail(params: {
+        to: string;
+        name: string;
+        inviteUrl: string;
+    }): Promise<void>;
+    sendTransactionalEmail(params: {
+        to: {
+            email: string;
+            name?: string;
+        };
+        subject: string;
+        htmlContent: string;
+        textContent: string;
+    }): Promise<void>;
     verifyConnection(): Promise<boolean>;
     private sendEmail;
 }
@@ -651,6 +817,14 @@ declare class HttpExceptionFilter implements ExceptionFilter {
     catch(exception: unknown, host: ArgumentsHost): void;
     private isHttpException;
     private isAxiosError;
+    private isProblemLikeObject;
+}
+
+declare class RpcProblemExceptionFilter {
+    private readonly logger;
+    catch(exception: unknown, _host: ArgumentsHost): Observable<never>;
+    private toProblemPayload;
+    private isHttpException;
 }
 
 type LogLevel = 'error' | 'warn' | 'log' | 'debug' | 'verbose';
@@ -682,11 +856,11 @@ interface LoggerModuleOptions {
 interface LoggerOptionsFactory {
     createLoggerOptions(): Promise<LoggerModuleOptions> | LoggerModuleOptions;
 }
-interface LoggerModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+interface LoggerModuleAsyncOptions<T extends unknown[] = unknown[]> extends Pick<ModuleMetadata, 'imports'> {
     useExisting?: Type<LoggerOptionsFactory>;
     useClass?: Type<LoggerOptionsFactory>;
-    useFactory?: (...args: unknown[]) => Promise<LoggerModuleOptions> | LoggerModuleOptions;
-    inject?: unknown[];
+    useFactory?: (...args: [...T]) => Promise<LoggerModuleOptions> | LoggerModuleOptions;
+    inject?: InjectionToken[];
 }
 interface CorrelationContext {
     correlationId: string;
@@ -739,7 +913,7 @@ declare class HttpLoggerInterceptor implements NestInterceptor {
 declare const LOGGER_MODULE_OPTIONS: unique symbol;
 declare class LoggerModule implements NestModule {
     static forRoot(options?: LoggerModuleOptions): DynamicModule;
-    static forRootAsync(options: LoggerModuleAsyncOptions): DynamicModule;
+    static forRootAsync<T extends unknown[] = unknown[]>(options: LoggerModuleAsyncOptions<T>): DynamicModule;
     configure(_consumer: MiddlewareConsumer): void;
     private static createAsyncProviders;
     private static createAsyncOptionsProvider;
@@ -765,126 +939,86 @@ declare const DEFAULT_CORRELATION_HEADER = "x-correlation-id";
 declare function generateCorrelationId(): string;
 declare function addCorrelationIdToResponse(reply: FastifyReply, correlationId: string, headerName?: string): void;
 
-declare class RootModule {
-}
-
-declare function extractCountryFromPhone(phone: string): string | undefined;
-declare function normalizePhoneNumber(phone: string): string;
-
-declare function parseExpiryToMs(expiry: string): number;
+declare const RpcNatsHeaders: (...dataOrPipes: unknown[]) => ParameterDecorator;
+declare const RpcBuId: (...dataOrPipes: unknown[]) => ParameterDecorator;
+declare const RpcBuCurrencyCode: (...dataOrPipes: unknown[]) => ParameterDecorator;
 
-declare const DATA_TABLE_VIEWS_TABLE: unique symbol;
+interface NatsHeaders {
+    orgId: string;
+    userId: string;
+    buId: string;
+    buTimezone: string;
+    buCurrencyCode: string;
+    buAncestorIds: string[];
+    buDescendantIds: string[];
+}
+declare const NATS_HEADER_KEYS: {
+    readonly ORG_ID: "x-org-id";
+    readonly USER_ID: "x-user-id";
+    readonly BU_ID: "x-bu-id";
+    readonly BU_TIMEZONE: "x-bu-timezone";
+    readonly BU_CURRENCY_CODE: "x-bu-currency-code";
+    readonly BU_ANCESTOR_IDS: "x-bu-ancestor-ids";
+    readonly BU_DESCENDANT_IDS: "x-bu-descendant-ids";
+};
+declare function parseNatsHeaders(headers: unknown): NatsHeaders | null;
 
-interface DataTableModuleOptions {
-    tableViews: PgTable;
+type ContextResolverFn = (sessionInfo: VrittiSessionInfo) => Promise<NatsHeaders>;
+interface NatsServiceConfig {
+    name: string;
 }
-declare class DataTableModule {
-    static forRoot(options: DataTableModuleOptions): DynamicModule;
+interface NatsModuleBaseOptions {
+    natsUrl?: string;
+    services: NatsServiceConfig[];
 }
-
-declare function dataTableViewsColumns(): {
-    id: drizzle_orm.HasDefault<drizzle_orm.IsPrimaryKey<drizzle_orm_pg_core.PgUUIDBuilder>>;
-    userId: drizzle_orm.NotNull<drizzle_orm_pg_core.PgUUIDBuilder>;
-    tableSlug: drizzle_orm.NotNull<drizzle_orm_pg_core.PgVarcharBuilder<[string, ...string[]]>>;
-    name: drizzle_orm.NotNull<drizzle_orm_pg_core.PgVarcharBuilder<[string, ...string[]]>>;
-    state: drizzle_orm.$Type<drizzle_orm.NotNull<drizzle_orm_pg_core.PgJsonbBuilder>, TableViewState>;
-    isShared: drizzle_orm.HasDefault<drizzle_orm.NotNull<drizzle_orm_pg_core.PgBooleanBuilder>>;
-    createdAt: drizzle_orm.HasDefault<drizzle_orm.NotNull<drizzle_orm_pg_core.PgTimestampBuilder>>;
-    updatedAt: drizzle_orm.HasDefault<drizzle_orm_pg_core.PgTimestampBuilder>;
-};
-declare function dataTableViewsIndexes(table: any): drizzle_orm_pg_core.IndexBuilder[];
-interface DataTableViewRecord {
-    id: string;
-    userId: string;
-    tableSlug: string;
-    name: string;
-    state: TableViewState;
-    isShared: boolean;
-    createdAt: Date;
-    updatedAt: Date | null | undefined;
+interface NatsRootModuleOptions extends NatsModuleBaseOptions {
+    contextResolver: ContextResolverFn;
 }
-interface NewDataTableViewRecord {
-    userId: string;
-    tableSlug: string;
-    name: string;
-    state: TableViewState;
-    isShared?: boolean;
+interface NatsMicroserviceModuleOptions extends NatsModuleBaseOptions {
 }
-
-declare class DataTableViewDto {
-    id: string;
-    name: string | null;
-    tableSlug: string;
-    state: TableViewState;
-    isShared: boolean;
-    isOwn: boolean;
-    createdAt: Date;
-    updatedAt: Date | null;
-    static from(view: DataTableViewRecord, userId: string): DataTableViewDto;
+interface NatsRootModuleAsyncOptions {
+    imports?: ModuleMetadata['imports'];
+    inject?: InjectionToken[];
+    useFactory: (...args: any[]) => Promise<NatsRootModuleOptions> | NatsRootModuleOptions;
 }
-
-declare class CreateDataTableViewDto {
-    name: string;
-    tableSlug: string;
-    state: TableViewState;
-    isShared?: boolean;
+interface NatsMicroserviceModuleAsyncOptions {
+    imports?: ModuleMetadata['imports'];
+    inject?: InjectionToken[];
+    useFactory: (...args: any[]) => Promise<NatsMicroserviceModuleOptions> | NatsMicroserviceModuleOptions;
 }
 
-declare class UpdateDataTableViewDto {
-    state: TableViewState;
+declare class NatsClientModule implements OnModuleDestroy {
+    private static readonly logger;
+    private static allClients;
+    onModuleDestroy(): Promise<void>;
+    private static buildClients;
+    static forRoot(asyncOptions: NatsRootModuleAsyncOptions): DynamicModule;
+    static forMicroservice(asyncOptions: NatsMicroserviceModuleAsyncOptions): DynamicModule;
 }
 
-declare class DataTableViewsRepository extends PrimaryBaseRepository<PgTable, NewDataTableViewRecord, DataTableViewRecord> {
-    constructor(database: PrimaryDatabaseService, table: PgTable);
-    findPersonalViewsBySlug(userId: string, tableSlug: string): Promise<DataTableViewRecord[]>;
-    findSharedViewsBySlug(tableSlug: string): Promise<DataTableViewRecord[]>;
+declare class NatsClientService {
+    private readonly request;
+    private readonly contextResolver;
+    private readonly clients;
+    private cachedContext;
+    constructor(request: FastifyRequest, contextResolver: ContextResolverFn, clients: Map<string, ClientProxy>);
+    send<T>(service: string, cmd: string, data?: object): Promise<T>;
 }
 
-declare class DataTableViewsService {
-    private readonly dataTableViewsRepository;
-    private readonly cacheService;
-    private readonly configService;
-    private readonly logger;
-    constructor(dataTableViewsRepository: DataTableViewsRepository, cacheService: CacheService, configService: ConfigService);
-    private personalViewsKey;
-    private sharedViewsKey;
-    private get viewsTtl();
-    private getOrCachePersonalViews;
-    private getOrCacheSharedViews;
-    private invalidateViewsCache;
-    findViews(userId: string, tableSlug: string): Promise<DataTableViewDto[]>;
-    createView(userId: string, dto: CreateDataTableViewDto): Promise<DataTableViewDto>;
-    updateView(userId: string, id: string, dto: UpdateDataTableViewDto): Promise<DataTableViewDto>;
-    toggleShareView(userId: string, id: string, isShared: boolean): Promise<DataTableViewDto>;
-    renameView(userId: string, id: string, name: string): Promise<DataTableViewDto>;
-    deleteView(userId: string, id: string): Promise<DataTableViewDto>;
+declare class NatsMicroserviceClientService {
+    private readonly clients;
+    constructor(clients: Map<string, ClientProxy>);
+    send<T>(service: string, cmd: string, natsHeaders: NatsHeaders, data?: object): Promise<T>;
 }
 
-declare class UpsertDataTableStateDto {
-    tableSlug: string;
-    state: TableViewState;
-    activeViewId?: string | null;
+declare class RootModule {
 }
 
-declare class DataTableStateService {
-    private readonly cacheService;
-    private readonly configService;
-    private readonly logger;
-    constructor(cacheService: CacheService, configService: ConfigService);
-    private get stateTtl();
-    upsertCurrentState(userId: string, dto: UpsertDataTableStateDto): Promise<void>;
-    getCurrentState(userId: string, tableSlug: string): Promise<{
-        state: TableViewState;
-        activeViewId: string | null;
-    }>;
-}
+declare function gcd(a: number, b: number): number;
 
-declare class RenameDataTableViewDto {
-    name: string;
-}
+declare function extractCountryFromPhone(phone: string): string | undefined;
+declare function normalizePhoneNumber(phone: string): string;
 
-declare class ToggleShareDataTableViewDto {
-    isShared: boolean;
-}
+declare function parseExpiryToMs(expiry: string): number;
 
-export { AccessToken, type AccessTokenPayload, type ApiErrorResponse, type ApiSdkConfig, AuthConfigModule, BadGatewayException, BadRequestException, CACHE_PROVIDER, CacheModule, CacheService, type ColumnPinning, ConflictException, type CookieConfig, CookieDomain, type CookieSerializeOptions, type CorrelationContext, CorrelationIdMiddleware, CreateDataTableViewDto, DATA_TABLE_VIEWS_TABLE, DEFAULT_CORRELATION_HEADER, DataTableModule, type DataTableModuleOptions, DataTableStateService, DataTableViewDto, type DataTableViewRecord, DataTableViewsService, DatabaseModule, type DatabaseModuleOptions, type DensityType, EmailModule, EmailService, type FieldDefinition, type FieldError, type FieldMap, type FilterCondition, type FilterOperator, FilterProcessor, type FindForSelectConfig, type FindForSelectJoin, ForbiddenException, GoneException, type GuardConfig, HttpExceptionFilter, HttpLoggerInterceptor, type HttpLoggerOptions, HttpProblemException, type ICacheProvider, InternalServerErrorException, JwtAuthService, type JwtConfig, LOGGER_MODULE_OPTIONS, type LogFormat, type LogLevel, type LogMetadata, LoggerModule, type LoggerModuleAsyncOptions, type LoggerModuleOptions, type LoggerOptionsFactory, LoggerService, MethodNotAllowedException, type NewDataTableViewRecord, NotAcceptableException, NotFoundException, NotImplementedException, Onboarding, PayloadTooLargeException, PrimaryBaseRepository, PrimaryDatabaseService, type PrimaryDbConfig, type ProblemDetails, type ProblemOptions, Public, RESET_KEY, RedisCacheProvider, RefreshCookieOptions, RefreshTokenCookie, type RefreshTokenPayload, type RegisteredSchema, RenameDataTableViewDto, RequestTimeoutException, Reset, RootModule, SKIP_CSRF_KEY, SelectOptionsQueryDto, type SelectQueryGroup, type SelectQueryOption, type SelectQueryResult, ServiceUnavailableException, SessionData, type SessionInfo, SkipCsrf, type SortCondition, SuccessResponseDto, TableResponseDto, type TableViewState, Tenant, TenantBaseRepository, TenantContextService, TenantDatabaseService, type TenantInfo, ToggleShareDataTableViewDto, type TokenExpiry, TokenType, TooManyRequestsException, type TypedDrizzleClient, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, UpdateDataTableViewDto, UpsertDataTableStateDto, UserId, ValidationException, VrittiAuthGuard, addCorrelationIdToResponse, configureApiSdk, correlationStorage, dataTableViewsColumns, dataTableViewsIndexes, defineConfig, extractCountryFromPhone, generateCorrelationId, getConfig, getCorrelationContext, getHttpStatusTitle, getJwtExpiry, getRefreshCookieOptions, getRefreshCookieOptionsForHost, getTokenExpiry, hashToken, jwtConfigFactory, normalizePhoneNumber, parseExpiryToMs, resetConfig, runWithCorrelationContext, updateCorrelationContext, verifyTokenHash };
+export { AUTH_CONFIG, AUTH_CONFIG_DEFAULTS, AccessToken, type AccessTokenPayload, type ApiErrorResponse, type AuthConfig, AuthConfigModule, BadGatewayException, BadRequestException, CACHE_PROVIDER, CacheModule, CacheService, type ColumnPinning, ConflictException, type ContextResolverFn, type CookieConfig, CookieDomain, CookieName, type CookieSerializeOptions, type CorrelationContext, CorrelationIdMiddleware, CreateDataTableViewDto, CreateResponseDto, CurrencyAmountDto, DATA_TABLE_VIEWS_TABLE, DEFAULT_CORRELATION_HEADER, DataTableModule, type DataTableModuleOptions, DataTableStateService, DataTableViewDto, type DataTableViewRecord, DataTableViewsService, DatabaseModule, type DatabaseModuleOptions, type DecodedAccessToken, type DecodedRefreshToken, type DensityType, EmailModule, EmailService, type FieldDefinition, type FieldError, type FieldMap, type FilterCondition, type FilterOperator, FilterOperators, FilterProcessor, type FindForSelectConfig, type FindForSelectJoin, ForbiddenException, GoneException, type GuardConfig, Hostname, HttpExceptionFilter, HttpLoggerInterceptor, type HttpLoggerOptions, HttpProblemException, type ICacheProvider, ImportResponseDto, ImportSummaryDto, InternalServerErrorException, IsCurrency, IsCurrencyCode, IsDateTime, LOGGER_MODULE_OPTIONS, type LogFormat, type LogLevel, type LogMetadata, LoggerModule, type LoggerModuleAsyncOptions, type LoggerModuleOptions, type LoggerOptionsFactory, LoggerService, MethodNotAllowedException, NATS_HEADER_KEYS, NatsClientModule, NatsClientService, type NatsHeaders, NatsMicroserviceClientService, type NatsMicroserviceModuleAsyncOptions, type NatsRootModuleAsyncOptions, type NatsServiceConfig, type NewDataTableViewRecord, NotAcceptableException, NotFoundException, NotImplementedException, type OnAuthenticatedCallback, PayloadTooLargeException, PrimaryBaseRepository, PrimaryDatabaseService, type PrimaryDbConfig, type ProblemDetails, type ProblemOptions, Public, REQUIRE_SESSION_KEY, RedisCacheProvider, RefreshCookieOptions, RefreshTokenCookie, type RefreshTokenPayload, RenameDataTableViewDto, RequestTimeoutException, RequireSession, RootModule, RpcBuCurrencyCode, RpcBuId, RpcNatsHeaders, RpcProblemExceptionFilter, SKIP_CSRF_KEY, type SearchState, SelectOptionsQueryDto, type SelectQueryGroup, type SelectQueryOption, type SelectQueryResult, ServiceUnavailableException, SessionData, type SessionInfo$1 as SessionInfo, SkipCsrf, type SortCondition, Subdomain, SuccessResponseDto, TableResponseDto, type TableViewState, ToggleShareDataTableViewDto, type TokenExpiry, type TokenExpiryString, TokenService, TokenType, TooManyRequestsException, type TypedDrizzleClient, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, UpdateDataTableViewDto, UploadedFile, type UploadedFileResult, UploadedFiles, UpsertDataTableStateDto, UserId, ValidatedRowDto, ValidationException, VrittiAuthGuard, addCorrelationIdToResponse, correlationStorage, dataTableViewsColumns, dataTableViewsIndexes, extractCountryFromPhone, gcd, generateCorrelationId, getCorrelationContext, getHttpStatusTitle, hashToken, normalizePhoneNumber, parseExpiryToMs, parseNatsHeaders, runWithCorrelationContext, updateCorrelationContext, verifyTokenHash };