SYMBOL INDEX (995 symbols across 144 files)

FILE: apps/api/migrations/001_create_orders_tables.sql
  type orders (line 2) | CREATE TABLE IF NOT EXISTS orders (
  type order_items (line 12) | CREATE TABLE IF NOT EXISTS order_items (
  type idx_orders_customer_id (line 23) | CREATE INDEX IF NOT EXISTS idx_orders_customer_id ON orders(customer_id)
  type idx_orders_status (line 24) | CREATE INDEX IF NOT EXISTS idx_orders_status ON orders(status)
  type idx_order_items_order_id (line 25) | CREATE INDEX IF NOT EXISTS idx_order_items_order_id ON order_items(order...

FILE: apps/api/src/app.module.ts
  class AppModule (line 111) | class AppModule {}

FILE: apps/api/src/main.ts
  function bootstrap (line 9) | async function bootstrap() {

FILE: apps/api/src/modules/order/application/commands/cancel-order/cancel-order.command.ts
  class CancelOrderCommand (line 1) | class CancelOrderCommand {
    method constructor (line 2) | constructor(public readonly orderId: string) {}

FILE: apps/api/src/modules/order/application/commands/cancel-order/cancel-order.dto.ts
  class CancelOrderDto (line 4) | class CancelOrderDto {

FILE: apps/api/src/modules/order/application/commands/cancel-order/cancel-order.handler.ts
  class CancelOrderHandler (line 9) | class CancelOrderHandler implements ICommandHandler<CancelOrderCommand> {
    method constructor (line 10) | constructor(
    method execute (line 17) | async execute(command: CancelOrderCommand): Promise<void> {

FILE: apps/api/src/modules/order/application/commands/confirm-order/confirm-order.command.ts
  class ConfirmOrderCommand (line 1) | class ConfirmOrderCommand {
    method constructor (line 2) | constructor(public readonly orderId: string) {}

FILE: apps/api/src/modules/order/application/commands/confirm-order/confirm-order.dto.ts
  class ConfirmOrderDto (line 4) | class ConfirmOrderDto {

FILE: apps/api/src/modules/order/application/commands/confirm-order/confirm-order.handler.ts
  class ConfirmOrderHandler (line 9) | class ConfirmOrderHandler implements ICommandHandler<ConfirmOrderCommand> {
    method constructor (line 10) | constructor(
    method execute (line 17) | async execute(command: ConfirmOrderCommand): Promise<void> {

FILE: apps/api/src/modules/order/application/commands/create-order/create-order.command.ts
  class CreateOrderCommand (line 1) | class CreateOrderCommand {
    method constructor (line 2) | constructor(

FILE: apps/api/src/modules/order/application/commands/create-order/create-order.dto.ts
  class CreateOrderItemDto (line 5) | class CreateOrderItemDto {
  class CreateOrderDto (line 21) | class CreateOrderDto {

FILE: apps/api/src/modules/order/application/commands/create-order/create-order.handler.ts
  class CreateOrderHandler (line 13) | class CreateOrderHandler implements ICommandHandler<CreateOrderCommand> {
    method constructor (line 14) | constructor(
    method execute (line 21) | async execute(command: CreateOrderCommand): Promise<string> {

FILE: apps/api/src/modules/order/application/event-handlers/order-confirmed.handler.ts
  class OrderConfirmedHandler (line 6) | class OrderConfirmedHandler implements IEventHandler<OrderConfirmedEvent> {
    method handle (line 9) | async handle(event: OrderConfirmedEvent) {

FILE: apps/api/src/modules/order/application/event-handlers/order-created.handler.ts
  class OrderCreatedHandler (line 6) | class OrderCreatedHandler implements IEventHandler<OrderCreatedEvent> {
    method handle (line 9) | async handle(event: OrderCreatedEvent) {

FILE: apps/api/src/modules/order/application/queries/get-order/get-order.handler.ts
  class GetOrderHandler (line 9) | class GetOrderHandler implements IQueryHandler<GetOrderQuery> {
    method constructor (line 10) | constructor(
    method execute (line 15) | async execute(query: GetOrderQuery): Promise<OrderResponseDto> {

FILE: apps/api/src/modules/order/application/queries/get-order/get-order.query.ts
  class GetOrderQuery (line 1) | class GetOrderQuery {
    method constructor (line 2) | constructor(public readonly orderId: string) {}

FILE: apps/api/src/modules/order/application/queries/get-order/order.response.dto.ts
  class OrderItemResponseDto (line 3) | class OrderItemResponseDto {
  class OrderResponseDto (line 20) | class OrderResponseDto {

FILE: apps/api/src/modules/order/application/queries/list-orders/list-orders.handler.ts
  class ListOrdersHandler (line 8) | class ListOrdersHandler implements IQueryHandler<ListOrdersQuery> {
    method constructor (line 9) | constructor(
    method execute (line 14) | async execute(query: ListOrdersQuery): Promise<OrderListResponseDto> {

FILE: apps/api/src/modules/order/application/queries/list-orders/list-orders.query.ts
  class ListOrdersQuery (line 1) | class ListOrdersQuery {
    method constructor (line 2) | constructor(public readonly customerId?: string) {}

FILE: apps/api/src/modules/order/application/queries/list-orders/order-list.response.dto.ts
  class OrderListResponseDto (line 4) | class OrderListResponseDto {

FILE: apps/api/src/modules/order/domain/entities/order-item.entity.ts
  type OrderItemProps (line 5) | interface OrderItemProps {
  class OrderItem (line 12) | class OrderItem extends Entity<string> {
    method productId (line 17) | get productId(): string {
    method quantity (line 21) | get quantity(): Quantity {
    method unitPrice (line 25) | get unitPrice(): Money {
    method constructor (line 29) | private constructor(props: OrderItemProps) {
    method create (line 36) | public static create(props: OrderItemProps): OrderItem {
    method getTotalPrice (line 40) | public getTotalPrice(): Money {
    method updateQuantity (line 44) | public updateQuantity(quantity: Quantity): void {

FILE: apps/api/src/modules/order/domain/entities/order.entity.ts
  type OrderProps (line 11) | interface OrderProps {
  class Order (line 20) | class Order extends AggregateRoot<string> {
    method customerId (line 27) | get customerId(): string {
    method items (line 31) | get items(): OrderItem[] {
    method status (line 35) | get status(): OrderStatus {
    method createdAt (line 39) | get createdAt(): Date {
    method updatedAt (line 43) | get updatedAt(): Date {
    method constructor (line 47) | private constructor(props: OrderProps) {
    method create (line 56) | public static create(customerId: string, items: OrderItem[], id?: Orde...
    method reconstitute (line 74) | public static reconstitute(props: OrderProps): Order {
    method getTotalAmount (line 78) | public getTotalAmount(): Money {
    method confirm (line 86) | public confirm(): void {
    method cancel (line 97) | public cancel(): void {
    method addItem (line 108) | public addItem(item: OrderItem): void {
    method removeItem (line 117) | public removeItem(itemId: string): void {

FILE: apps/api/src/modules/order/domain/events/order-cancelled.event.ts
  class OrderCancelledEvent (line 3) | class OrderCancelledEvent extends DomainEvent {
    method constructor (line 4) | constructor(public readonly orderId: string) {
    method getAggregateId (line 8) | getAggregateId(): string {

FILE: apps/api/src/modules/order/domain/events/order-confirmed.event.ts
  class OrderConfirmedEvent (line 3) | class OrderConfirmedEvent extends DomainEvent {
    method constructor (line 4) | constructor(public readonly orderId: string) {
    method getAggregateId (line 8) | getAggregateId(): string {

FILE: apps/api/src/modules/order/domain/events/order-created.event.ts
  class OrderCreatedEvent (line 4) | class OrderCreatedEvent extends DomainEvent {
    method constructor (line 5) | constructor(
    method getAggregateId (line 13) | getAggregateId(): string {

FILE: apps/api/src/modules/order/domain/exceptions/invalid-order-state.exception.ts
  class InvalidOrderStateException (line 3) | class InvalidOrderStateException extends DomainException {
    method constructor (line 4) | constructor(message: string) {

FILE: apps/api/src/modules/order/domain/exceptions/order-not-found.exception.ts
  class OrderNotFoundException (line 3) | class OrderNotFoundException extends DomainException {
    method constructor (line 4) | constructor(orderId: string) {

FILE: apps/api/src/modules/order/domain/repositories/order.repository.interface.ts
  type IOrderRepository (line 3) | interface IOrderRepository {
  constant ORDER_REPOSITORY (line 10) | const ORDER_REPOSITORY = Symbol('ORDER_REPOSITORY');

FILE: apps/api/src/modules/order/domain/services/order-pricing.service.ts
  class OrderPricingService (line 6) | class OrderPricingService {
    method calculateTotal (line 7) | calculateTotal(order: Order): Money {
    method applyDiscount (line 11) | applyDiscount(total: Money, discountPercent: number): Money {

FILE: apps/api/src/modules/order/domain/value-objects/money.vo.ts
  type MoneyProps (line 4) | interface MoneyProps {
  class Money (line 9) | class Money extends ValueObject<MoneyProps> {
    method amount (line 10) | get amount(): number {
    method currency (line 14) | get currency(): string {
    method constructor (line 18) | private constructor(props: MoneyProps) {
    method create (line 22) | public static create(amount: number, currency: string = 'USD'): Money {
    method add (line 35) | public add(money: Money): Money {
    method multiply (line 42) | public multiply(multiplier: number): Money {

FILE: apps/api/src/modules/order/domain/value-objects/order-id.vo.ts
  type OrderIdProps (line 4) | interface OrderIdProps {
  class OrderId (line 8) | class OrderId extends ValueObject<OrderIdProps> {
    method value (line 9) | get value(): string {
    method constructor (line 13) | private constructor(props: OrderIdProps) {
    method create (line 17) | public static create(id?: string): OrderId {
    method toString (line 21) | public toString(): string {

FILE: apps/api/src/modules/order/domain/value-objects/order-status.vo.ts
  type OrderStatusEnum (line 3) | enum OrderStatusEnum {
  type OrderStatusProps (line 10) | interface OrderStatusProps {
  class OrderStatus (line 14) | class OrderStatus extends ValueObject<OrderStatusProps> {
    method value (line 15) | get value(): OrderStatusEnum {
    method constructor (line 19) | private constructor(props: OrderStatusProps) {
    method create (line 23) | public static create(status: OrderStatusEnum): OrderStatus {
    method pending (line 27) | public static pending(): OrderStatus {
    method confirmed (line 31) | public static confirmed(): OrderStatus {
    method cancelled (line 35) | public static cancelled(): OrderStatus {
    method completed (line 39) | public static completed(): OrderStatus {
    method isPending (line 43) | public isPending(): boolean {
    method isConfirmed (line 47) | public isConfirmed(): boolean {
    method isCancelled (line 51) | public isCancelled(): boolean {
    method isCompleted (line 55) | public isCompleted(): boolean {

FILE: apps/api/src/modules/order/domain/value-objects/quantity.vo.ts
  type QuantityProps (line 3) | interface QuantityProps {
  class Quantity (line 7) | class Quantity extends ValueObject<QuantityProps> {
    method value (line 8) | get value(): number {
    method constructor (line 12) | private constructor(props: QuantityProps) {
    method create (line 16) | public static create(value: number): Quantity {

FILE: apps/api/src/modules/order/infrastructure/cache/order-cache.service.ts
  constant ORDER_CACHE_PREFIX (line 5) | const ORDER_CACHE_PREFIX = 'order:';
  constant ORDER_LIST_CACHE_PREFIX (line 6) | const ORDER_LIST_CACHE_PREFIX = 'orders:customer:';
  constant DEFAULT_TTL (line 7) | const DEFAULT_TTL = 3600;
  class OrderCacheService (line 10) | class OrderCacheService {
    method constructor (line 13) | constructor(private readonly redisson: RedissonService) {}
    method cacheOrder (line 18) | async cacheOrder(order: Order, ttl: number = DEFAULT_TTL): Promise<voi...
    method getCachedOrder (line 28) | async getCachedOrder(orderId: string): Promise<SerializedOrder | null> {
    method invalidateOrder (line 36) | async invalidateOrder(orderId: string): Promise<void> {
    method cacheCustomerOrders (line 45) | async cacheCustomerOrders(
    method getCachedCustomerOrders (line 59) | async getCachedCustomerOrders(customerId: string): Promise<SerializedO...
    method invalidateCustomerOrders (line 67) | async invalidateCustomerOrders(customerId: string): Promise<void> {
    method getOrSetOrder (line 76) | async getOrSetOrder(
    method withOrderLock (line 97) | async withOrderLock<T>(
    method incrementOrderViewCount (line 110) | async incrementOrderViewCount(orderId: string): Promise<number> {
    method getOrderViewCount (line 118) | async getOrderViewCount(orderId: string): Promise<number> {
    method serializeOrder (line 124) | private serializeOrder(order: Order): SerializedOrder {
  type SerializedOrder (line 143) | interface SerializedOrder {
  type SerializedOrderItem (line 153) | interface SerializedOrderItem {

FILE: apps/api/src/modules/order/infrastructure/persistence/kysely-order.repository.ts
  class OrderRepository (line 13) | class OrderRepository implements IOrderRepository {
    method constructor (line 14) | constructor(private readonly db: KyselyService<Database>) {}
    method findById (line 16) | async findById(id: string): Promise<Order | null> {
    method findByCustomerId (line 36) | async findByCustomerId(customerId: string): Promise<Order[]> {
    method save (line 58) | async save(order: Order): Promise<Order> {
    method delete (line 125) | async delete(id: string): Promise<void> {
    method mapStatusToDb (line 139) | private mapStatusToDb(status: OrderStatusEnum): 'pending' | 'confirmed...
    method mapStatusFromDb (line 152) | private mapStatusFromDb(status: string): OrderStatusEnum {
    method toDomain (line 165) | private toDomain(

FILE: apps/api/src/modules/order/order.module.ts
  class OrderModule (line 42) | class OrderModule {}

FILE: apps/api/src/modules/order/presentation/order.controller.ts
  class OrderController (line 15) | class OrderController {
    method constructor (line 16) | constructor(
    method createOrder (line 24) | async createOrder(@Body() dto: CreateOrderDto): Promise<{ orderId: str...
    method getOrder (line 33) | async getOrder(@Param('id') id: string): Promise<OrderResponseDto> {
    method listOrders (line 41) | async listOrders(@Query('customerId') customerId?: string): Promise<Or...
    method confirmOrder (line 50) | async confirmOrder(@Param('id') id: string): Promise<void> {
    method cancelOrder (line 59) | async cancelOrder(@Param('id') id: string): Promise<void> {

FILE: apps/api/src/shared/api-response/api-response.dto.ts
  class ApiResponseDto (line 7) | class ApiResponseDto<T> {
    method constructor (line 23) | constructor(partial: Partial<ApiResponseDto<T>>) {
  class PaginatedResponseDto (line 29) | class PaginatedResponseDto<T> {
    method constructor (line 51) | constructor(partial: Partial<PaginatedResponseDto<T>>) {
  class ApiErrorResponseDto (line 56) | class ApiErrorResponseDto {
    method constructor (line 72) | constructor(partial: Partial<ApiErrorResponseDto>) {

FILE: apps/api/src/shared/api-response/api-response.interceptor.ts
  class ApiResponseInterceptor (line 17) | class ApiResponseInterceptor implements NestInterceptor {
    method intercept (line 18) | intercept(context: ExecutionContext, next: CallHandler): Observable<un...

FILE: apps/api/src/shared/api-response/api-response.service.ts
  class ApiResponseService (line 14) | class ApiResponseService {
    method success (line 20) | success<T>(data?: T, message = 'Success', requestId?: string): ApiResp...
    method created (line 32) | created<T>(data?: T, message = 'Created', requestId?: string): ApiResp...
    method accepted (line 44) | accepted<T>(data?: T, message = 'Accepted', requestId?: string): ApiRe...
    method noContent (line 56) | noContent(requestId?: string): ApiResponseDto<null> {
    method paginated (line 67) | paginated<T>(
    method error (line 91) | error(
    method getRequestId (line 108) | getRequestId(request: Request): string | undefined {

FILE: apps/api/src/shared/api-versioning/api-versioning.decorator.ts
  constant API_VERSION_KEY (line 7) | const API_VERSION_KEY = 'api_version';

FILE: apps/api/src/shared/api-versioning/api-versioning.interceptor.ts
  type ApiVersionOptions (line 9) | interface ApiVersionOptions {
  constant DEFAULT_API_VERSION (line 21) | const DEFAULT_API_VERSION = '1';
  function extractVersionFromUrl (line 27) | function extractVersionFromUrl(url: string): string | null {
  function extractVersionFromHeader (line 36) | function extractVersionFromHeader(header: string | string[] | undefined)...
  function extractVersionFromCustomHeader (line 48) | function extractVersionFromCustomHeader(
  class ApiVersioningInterceptor (line 57) | class ApiVersioningInterceptor implements NestInterceptor {
    method intercept (line 58) | intercept(context: ExecutionContext, next: CallHandler): Observable<an...

FILE: apps/api/src/shared/application/dto.base.ts
  method constructor (line 2) | constructor(partial?: Partial<any>) {

FILE: apps/api/src/shared/application/query.interface.ts
  type IQuery (line 1) | interface IQuery<IResponse> {

FILE: apps/api/src/shared/application/use-case.interface.ts
  type IUseCase (line 1) | interface IUseCase<IRequest, IResponse> {

FILE: apps/api/src/shared/audit/audit.decorator.ts
  constant AUDIT_KEY (line 7) | const AUDIT_KEY = 'audit';

FILE: apps/api/src/shared/audit/audit.interceptor.ts
  constant AUDIT_ACTION_KEY (line 17) | const AUDIT_ACTION_KEY = 'audit_action';
  constant AUDIT_RESOURCE_KEY (line 18) | const AUDIT_RESOURCE_KEY = 'audit_resource';
  function AuditedAction (line 23) | function AuditedAction(action: string) {
  function AuditedResource (line 33) | function AuditedResource(resource: string) {
  class AuditInterceptor (line 41) | class AuditInterceptor implements NestInterceptor {
    method constructor (line 44) | constructor(private readonly auditService: AuditService) {}
    method intercept (line 46) | intercept(context: ExecutionContext, next: CallHandler): Observable<an...
    method getAction (line 103) | private getAction(context: ExecutionContext): string | undefined {
    method getResource (line 110) | private getResource(context: ExecutionContext): string | undefined {
    method inferAction (line 117) | private inferAction(context: ExecutionContext): string {
    method inferResource (line 133) | private inferResource(context: ExecutionContext): string {
    method getClientIp (line 138) | private getClientIp(request: Request): string {

FILE: apps/api/src/shared/audit/audit.service.ts
  type AuditLogEntry (line 9) | interface AuditLogEntry {
  type AuditQueryOptions (line 25) | interface AuditQueryOptions {
  type PaginatedAuditResult (line 36) | interface PaginatedAuditResult {
  class AuditService (line 47) | class AuditService {
    method constructor (line 51) | constructor(private readonly kysely: KyselyService<any>) {}
    method log (line 56) | async log(entry: AuditLogEntry): Promise<void> {
    method logCreate (line 85) | async logCreate(
    method logUpdate (line 110) | async logUpdate(
    method logDelete (line 144) | async logDelete(
    method logFailure (line 169) | async logFailure(
    method query (line 191) | async query(options: AuditQueryOptions): Promise<PaginatedAuditResult> {
    method getById (line 246) | async getById(id: string, organizationId: string): Promise<AuditLogEnt...

FILE: apps/api/src/shared/auth/auth.module.ts
  class AuthModule (line 29) | class AuthModule {}

FILE: apps/api/src/shared/auth/dto/auth.dto.ts
  class LoginDto (line 11) | class LoginDto {
  class RegisterDto (line 25) | class RegisterDto {
  class RefreshTokenDto (line 55) | class RefreshTokenDto {
  class ChangePasswordDto (line 64) | class ChangePasswordDto {
  class ForgotPasswordDto (line 78) | class ForgotPasswordDto {
  class ResetPasswordDto (line 87) | class ResetPasswordDto {
  class VerifyEmailDto (line 101) | class VerifyEmailDto {
  class TokenResponseDto (line 110) | class TokenResponseDto {
  class UserResponseDto (line 127) | class UserResponseDto {

FILE: apps/api/src/shared/auth/guards/jwt-auth.guard.ts
  constant IS_PUBLIC_KEY (line 19) | const IS_PUBLIC_KEY = 'isPublic';
  class JwtAuthGuard (line 27) | class JwtAuthGuard implements CanActivate {
    method constructor (line 28) | constructor(private readonly jwtService: JwtService) {}
    method canActivate (line 30) | async canActivate(context: ExecutionContext): Promise<boolean> {
    method extractTokenFromHeader (line 51) | private extractTokenFromHeader(request: Request): string | undefined {

FILE: apps/api/src/shared/auth/guards/permissions.guard.ts
  constant PERMISSIONS_KEY (line 19) | const PERMISSIONS_KEY = 'permissions';
  class PermissionsGuard (line 32) | class PermissionsGuard implements CanActivate {
    method constructor (line 33) | constructor(
    method canActivate (line 38) | canActivate(context: ExecutionContext): boolean {

FILE: apps/api/src/shared/auth/guards/roles.guard.ts
  constant ROLES_KEY (line 19) | const ROLES_KEY = 'roles';
  class RolesGuard (line 30) | class RolesGuard implements CanActivate {
    method constructor (line 31) | constructor(
    method canActivate (line 36) | canActivate(context: ExecutionContext): boolean {

FILE: apps/api/src/shared/auth/jwt/jwt.service.ts
  class JwtService (line 11) | class JwtService {
    method constructor (line 17) | constructor(private readonly configService: ConfigService) {
    method generateAccessToken (line 27) | generateAccessToken(payload: JwtPayload): string {
    method generateRefreshToken (line 36) | generateRefreshToken(payload: JwtPayload): string {
    method generateTokenPair (line 45) | generateTokenPair(payload: JwtPayload): TokenPair {
    method verifyAccessToken (line 55) | verifyAccessToken(token: string): JwtPayload {
    method verifyRefreshToken (line 66) | verifyRefreshToken(token: string): JwtPayload {
    method decodeToken (line 77) | decodeToken(token: string): JwtPayload | null {
    method isTokenExpiringSoon (line 88) | isTokenExpiringSoon(token: string): boolean {

FILE: apps/api/src/shared/auth/jwt/jwt.types.ts
  type JwtPayload (line 8) | interface JwtPayload {
  type AccessToken (line 30) | interface AccessToken {
  type RefreshToken (line 38) | interface RefreshToken {
  type TokenPair (line 46) | interface TokenPair {
  type TokenResponse (line 54) | interface TokenResponse {

FILE: apps/api/src/shared/auth/rbac/rbac.service.ts
  type Permission (line 11) | interface Permission {
  type Role (line 19) | interface Role {
  constant DEFAULT_PERMISSIONS (line 27) | const DEFAULT_PERMISSIONS: Permission[] = [
  constant DEFAULT_ROLES (line 38) | const DEFAULT_ROLES: Role[] = [
  class RbacService (line 75) | class RbacService {
    method constructor (line 78) | constructor() {
    method getRole (line 88) | getRole(roleName: string): Role | undefined {
    method hasPermission (line 95) | hasPermission(roleName: string, resource: string, action: string): boo...
    method hasAnyPermission (line 112) | hasAnyPermission(roleNames: string[], resource: string, action: string...
    method hasAllPermissions (line 119) | hasAllPermissions(roleNames: string[], resource: string, action: strin...
    method getPermissions (line 126) | getPermissions(roleName: string): Permission[] {
    method registerRole (line 134) | registerRole(role: Role): void {
    method hasRole (line 141) | hasRole(userRoles: string[], requiredRole: string): boolean {
    method hasAnyRole (line 148) | hasAnyRole(userRoles: string[], requiredRoles: string[]): boolean {

FILE: apps/api/src/shared/base/base.entity.ts
  type BaseEntity (line 5) | interface BaseEntity {
  type TenantEntity (line 11) | interface TenantEntity extends BaseEntity {
  type SoftDeleteEntity (line 15) | interface SoftDeleteEntity extends BaseEntity {
  type VersionedEntity (line 20) | interface VersionedEntity extends BaseEntity {

FILE: apps/api/src/shared/base/base.service.ts
  type FindOptions (line 9) | interface FindOptions<FilterDto, SortDto> {
  type PaginatedResult (line 15) | interface PaginatedResult<T> {
  method constructor (line 31) | constructor(
  method create (line 39) | async create(dto: CreateDto, additionalData?: Partial<Entity>): Promise<...
  method findById (line 61) | async findById(id: string): Promise<Entity | null> {
  method findByIdOrThrow (line 73) | async findByIdOrThrow(id: string): Promise<Entity> {
  method findAll (line 84) | async findAll(options?: FindOptions<FilterDto, SortDto>): Promise<Pagina...
  method findAllCursor (line 125) | async findAllCursor(
  method update (line 157) | async update(id: string, dto: UpdateDto): Promise<Entity> {
  method updateMany (line 180) | async updateMany(filter: FilterDto, dto: Partial<UpdateDto>): Promise<nu...
  method delete (line 196) | async delete(id: string): Promise<void> {
  method softDelete (line 208) | async softDelete(id: string, deletedBy?: string): Promise<void> {
  method softDeleteMany (line 225) | async softDeleteMany(filter: FilterDto, deletedBy?: string): Promise<num...
  method exists (line 242) | async exists(id: string): Promise<boolean> {
  method count (line 255) | async count(filter?: FilterDto): Promise<number> {
  method createMany (line 272) | async createMany(dtos: CreateDto[]): Promise<Entity[]> {
  method applyFilters (line 295) | protected applyFilters(qb: any, filter: FilterDto): any {
  method applySort (line 303) | protected applySort(qb: any, sort: SortDto): any {

FILE: apps/api/src/shared/base/pagination.dto.ts
  class PaginationQueryDto (line 9) | class PaginationQueryDto {
  class CursorPaginationQueryDto (line 26) | class CursorPaginationQueryDto {
  type PaginationOptions (line 47) | interface PaginationOptions {
  type CursorPaginationOptions (line 54) | interface CursorPaginationOptions {
  function parsePaginationOptions (line 60) | function parsePaginationOptions(query: PaginationQueryDto): PaginationOp...
  function parseCursorPaginationOptions (line 69) | function parseCursorPaginationOptions(query: CursorPaginationQueryDto): ...
  class PaginatedResponseDto (line 77) | class PaginatedResponseDto<T> {
    method constructor (line 99) | constructor(partial: Partial<PaginatedResponseDto<T>>) {
  class CursorPaginatedResponseDto (line 104) | class CursorPaginatedResponseDto<T> {
    method constructor (line 114) | constructor(partial: Partial<CursorPaginatedResponseDto<T>>) {

FILE: apps/api/src/shared/cache/cache.decorator.ts
  constant CACHE_KEY (line 8) | const CACHE_KEY = 'cache_options';
  function Cache (line 13) | function Cache(options: CacheDecoratorOptions) {

FILE: apps/api/src/shared/cache/cache.interceptor.ts
  class CacheInterceptor (line 19) | class CacheInterceptor implements NestInterceptor {
    method constructor (line 22) | constructor(
    method intercept (line 27) | async intercept(context: ExecutionContext, next: CallHandler): Promise...
    method buildCacheKey (line 60) | private buildCacheKey(context: ExecutionContext, options: CacheDecorat...

FILE: apps/api/src/shared/cache/cache.service.ts
  type CacheOptions (line 8) | interface CacheOptions {
  type CacheStats (line 17) | interface CacheStats {
  type CacheDecoratorOptions (line 28) | interface CacheDecoratorOptions extends CacheOptions {
  constant DEFAULT_CACHE_OPTIONS (line 38) | const DEFAULT_CACHE_OPTIONS: Required<CacheOptions> = {
  class CacheService (line 48) | class CacheService implements OnModuleDestroy {
    method constructor (line 53) | constructor(private readonly redis: RedissonService) {}
    method get (line 58) | async get<T>(key: string, options?: CacheOptions): Promise<T | null> {
    method set (line 83) | async set<T>(key: string, value: T, options?: CacheOptions): Promise<v...
    method delete (line 95) | async delete(key: string, options?: CacheOptions): Promise<void> {
    method deleteByPattern (line 104) | async deleteByPattern(pattern: string): Promise<number> {
    method has (line 114) | async has(key: string, options?: CacheOptions): Promise<boolean> {
    method getOrSet (line 122) | async getOrSet<T>(
    method getMany (line 140) | async getMany<T>(keys: string[], options?: CacheOptions): Promise<Arra...
    method setMany (line 148) | async setMany<T>(entries: Array<{ key: string; value: T }>, options?: ...
    method increment (line 156) | async increment(key: string, amount = 1, options?: CacheOptions): Prom...
    method decrement (line 168) | async decrement(key: string, amount = 1, options?: CacheOptions): Prom...
    method getStats (line 177) | getStats(): CacheStats {
    method resetStats (line 188) | resetStats(): void {
    method buildKey (line 195) | private buildKey(key: string, options?: CacheOptions): string {
    method onModuleDestroy (line 200) | onModuleDestroy(): void {

FILE: apps/api/src/shared/circuit-breaker/circuit-breaker.decorator.ts
  constant CIRCUIT_BREAKER_KEY (line 8) | const CIRCUIT_BREAKER_KEY = 'circuit_breaker';
  constant CIRCUIT_BREAKER_OPTIONS (line 9) | const CIRCUIT_BREAKER_OPTIONS = 'circuit_breaker_options';
  function CircuitBreaker (line 14) | function CircuitBreaker(options: CircuitBreakerOptions) {

FILE: apps/api/src/shared/circuit-breaker/circuit-breaker.module.ts
  class CircuitBreakerModule (line 13) | class CircuitBreakerModule {}

FILE: apps/api/src/shared/circuit-breaker/circuit-breaker.service.ts
  type CircuitState (line 7) | enum CircuitState {
  type CircuitBreakerOptions (line 13) | interface CircuitBreakerOptions {
  type CircuitBreakerStats (line 24) | interface CircuitBreakerStats {
  constant DEFAULT_OPTIONS (line 37) | const DEFAULT_OPTIONS: Required<CircuitBreakerOptions> = {
  class CircuitBreakerService (line 51) | class CircuitBreakerService implements OnModuleDestroy {
    method constructor (line 55) | constructor() {}
    method getCircuitBreaker (line 60) | getCircuitBreaker(name: string, options?: CircuitBreakerOptions): Circ...
    method execute (line 76) | async execute<T>(
    method getAllStats (line 100) | getAllStats(): CircuitBreakerStats[] {
    method getStats (line 107) | getStats(name: string): CircuitBreakerStats | undefined {
    method reset (line 114) | reset(name: string): void {
    method resetAll (line 121) | resetAll(): void {
    method onModuleDestroy (line 127) | onModuleDestroy(): void {
  class CircuitBreaker (line 135) | class CircuitBreaker {
    method constructor (line 145) | constructor(name: string, options: Required<CircuitBreakerOptions>) {
    method canExecute (line 153) | canExecute(): boolean {
    method recordSuccess (line 175) | recordSuccess(): void {
    method recordFailure (line 189) | recordFailure(): void {
    method getStats (line 206) | getStats(): CircuitBreakerStats {
    method getNextAttempt (line 221) | getNextAttempt(): Date | undefined {
    method reset (line 228) | reset(): void {
    method transitionToOpen (line 240) | private transitionToOpen(): void {
    method transitionToHalfOpen (line 249) | private transitionToHalfOpen(): void {
    method transitionToClosed (line 257) | private transitionToClosed(): void {
  class CircuitBreakerOpenError (line 268) | class CircuitBreakerOpenError extends Error {
    method constructor (line 269) | constructor(

FILE: apps/api/src/shared/database/database.module.ts
  class DatabaseModule (line 34) | class DatabaseModule { }

FILE: apps/api/src/shared/database/database.types.ts
  type Database (line 6) | interface Database {
  type OrderTable (line 14) | interface OrderTable {
  type OrderItemTable (line 26) | interface OrderItemTable {
  type Order (line 39) | type Order = Selectable<OrderTable>;
  type NewOrder (line 40) | type NewOrder = Insertable<OrderTable>;
  type OrderUpdate (line 41) | type OrderUpdate = Updateable<OrderTable>;
  type OrderItem (line 43) | type OrderItem = Selectable<OrderItemTable>;
  type NewOrderItem (line 44) | type NewOrderItem = Insertable<OrderItemTable>;
  type OrderItemUpdate (line 45) | type OrderItemUpdate = Updateable<OrderItemTable>;

FILE: apps/api/src/shared/domain/aggregate-root.ts
  method domainEvents (line 7) | get domainEvents(): DomainEvent[] {
  method addDomainEvent (line 11) | protected addDomainEvent(domainEvent: DomainEvent): void {
  method clearEvents (line 15) | public clearEvents(): void {

FILE: apps/api/src/shared/domain/domain-event-publisher.ts
  type IDomainEventPublisher (line 3) | interface IDomainEventPublisher {
  constant DOMAIN_EVENT_PUBLISHER (line 8) | const DOMAIN_EVENT_PUBLISHER = Symbol('DOMAIN_EVENT_PUBLISHER');

FILE: apps/api/src/shared/domain/domain-event.ts
  type IDomainEvent (line 1) | interface IDomainEvent {
  method constructor (line 9) | constructor() {

FILE: apps/api/src/shared/domain/entity.ts
  method constructor (line 12) | constructor(id: T) {
  method id (line 16) | get id(): T {
  method equals (line 23) | equals(entity?: Entity<T>): boolean {
  method equalsById (line 42) | equalsById(id: T): boolean {
  method toString (line 49) | toString(): string {
  method toObject (line 56) | toObject(): { id: T } {
  type IAuditableEntity (line 64) | interface IAuditableEntity {
  type ISoftDeletable (line 74) | interface ISoftDeletable {
  method constructor (line 88) | constructor(
  method isCreatedAfter (line 105) | isCreatedAfter(date: Date): boolean {
  method isUpdatedAfter (line 112) | isUpdatedAfter(date: Date): boolean {
  method isUpdatedBy (line 119) | isUpdatedBy(userId: string): boolean {
  method constructor (line 131) | constructor(
  method isDeleted (line 148) | isDeleted(): boolean {
  method isDeletedBy (line 155) | isDeletedBy(userId: string): boolean {
  method daysSinceDeletion (line 162) | daysSinceDeletion(): number | null {

FILE: apps/api/src/shared/domain/value-object.ts
  type ValueObjectProps (line 1) | interface ValueObjectProps {
  method constructor (line 8) | constructor(props: T) {
  method equals (line 12) | public equals(vo?: ValueObject<T>): boolean {

FILE: apps/api/src/shared/errors/business.exception.ts
  type BusinessExceptionOptions (line 8) | interface BusinessExceptionOptions {
  class BusinessException (line 15) | class BusinessException extends HttpException {
    method constructor (line 19) | constructor(options: BusinessExceptionOptions) {
    method getResponse (line 35) | getResponse(): Record<string, unknown> {
  class ValidationException (line 48) | class ValidationException extends BusinessException {
    method constructor (line 49) | constructor(message: string, details?: Record<string, unknown>) {
  class NotFoundException (line 58) | class NotFoundException extends BusinessException {
    method constructor (line 59) | constructor(resource: string, identifier?: string | number) {
  class DuplicateEntryException (line 72) | class DuplicateEntryException extends BusinessException {
    method constructor (line 73) | constructor(resource: string, field: string, value: string) {
  class ForbiddenException (line 82) | class ForbiddenException extends BusinessException {
    method constructor (line 83) | constructor(message = 'You do not have permission to perform this acti...
  class UnauthorizedException (line 92) | class UnauthorizedException extends BusinessException {
    method constructor (line 93) | constructor(message = 'Authentication required') {
  class OperationFailedException (line 102) | class OperationFailedException extends BusinessException {
    method constructor (line 103) | constructor(operation: string, reason?: string) {

FILE: apps/api/src/shared/errors/error-codes.ts
  type ErrorCode (line 5) | enum ErrorCode {

FILE: apps/api/src/shared/errors/error.filter.ts
  type ErrorResponse (line 17) | interface ErrorResponse {
  class GlobalErrorFilter (line 28) | class GlobalErrorFilter implements ExceptionFilter {
    method catch (line 31) | catch(exception: unknown, host: ArgumentsHost): void {
    method getErrorCode (line 143) | private getErrorCode(status: number): string {

FILE: apps/api/src/shared/feature-flags/feature-flags.guard.ts
  constant FEATURE_FLAG_KEY (line 15) | const FEATURE_FLAG_KEY = 'feature_flag';
  class FeatureFlagsGuard (line 24) | class FeatureFlagsGuard implements CanActivate {
    method constructor (line 25) | constructor(
    method canActivate (line 30) | async canActivate(context: ExecutionContext): Promise<boolean> {

FILE: apps/api/src/shared/feature-flags/feature-flags.service.ts
  type FeatureFlag (line 8) | interface FeatureFlag {
  type FeatureFlagEvaluation (line 26) | interface FeatureFlagEvaluation {
  constant DEFAULT_FEATURE_FLAGS (line 35) | const DEFAULT_FEATURE_FLAGS: Record<string, Omit<FeatureFlag, 'name' | '...
  class FeatureFlagsService (line 46) | class FeatureFlagsService implements OnModuleDestroy {
    method constructor (line 51) | constructor(private readonly redis: RedissonService) {}
    method isEnabled (line 56) | async isEnabled(flagName: string): Promise<boolean> {
    method evaluate (line 64) | async evaluate(
    method getFlag (line 125) | async getFlag(flagName: string): Promise<FeatureFlag | null> {
    method enable (line 167) | async enable(flagName: string, metadata?: Record<string, unknown>): Pr...
    method disable (line 187) | async disable(flagName: string): Promise<void> {
    method setRollout (line 207) | async setRollout(flagName: string, percentage: number): Promise<void> {
    method setExpiration (line 227) | async setExpiration(flagName: string, expiresAt: Date): Promise<void> {
    method getAllFlags (line 248) | async getAllFlags(): Promise<FeatureFlag[]> {
    method saveFlag (line 285) | private async saveFlag(flag: FeatureFlag): Promise<void> {
    method hashUserId (line 294) | private hashUserId(userId: string, flagName: string): number {
    method onModuleDestroy (line 305) | onModuleDestroy(): void {

FILE: apps/api/src/shared/file-upload/file-upload.decorator.ts
  constant FILE_UPLOAD_KEY (line 7) | const FILE_UPLOAD_KEY = 'file_upload';

FILE: apps/api/src/shared/file-upload/file-upload.interceptor.ts
  type UploadedFile (line 16) | interface UploadedFile {
  type FileUploadMetadata (line 25) | interface FileUploadMetadata {
  class FileUploadInterceptor (line 42) | class FileUploadInterceptor implements NestInterceptor {
    method constructor (line 43) | constructor(private readonly fileUploadService: FileUploadService) {}
    method intercept (line 45) | async intercept(context: ExecutionContext, next: CallHandler): Promise...
    method extractFiles (line 86) | private extractFiles(request: any): UploadedFile[] {
  class SingleFileUploadInterceptor (line 112) | class SingleFileUploadInterceptor implements NestInterceptor {
    method constructor (line 113) | constructor(private readonly fileUploadService: FileUploadService) {}
    method intercept (line 115) | async intercept(context: ExecutionContext, next: CallHandler): Promise...

FILE: apps/api/src/shared/file-upload/file-upload.service.ts
  type UploadedFile (line 8) | interface UploadedFile {
  type FileValidationOptions (line 25) | interface FileValidationOptions {
  constant DEFAULT_FILE_VALIDATION (line 37) | const DEFAULT_FILE_VALIDATION: FileValidationOptions = {
  class FileUploadService (line 54) | class FileUploadService {
    method constructor (line 57) | constructor(private readonly rustFsService: RustFSService) {}
    method uploadFile (line 62) | async uploadFile(
    method uploadFiles (line 95) | async uploadFiles(
    method deleteFile (line 112) | async deleteFile(storedName: string): Promise<void> {
    method getFileUrl (line 121) | async getFileUrl(storedName: string, expiresInSeconds = 3600): Promise...
    method fileExists (line 129) | async fileExists(storedName: string): Promise<boolean> {
    method validateFile (line 137) | private validateFile(
    method generateStoredName (line 171) | private generateStoredName(originalName: string): string {
    method getExtension (line 181) | private getExtension(filename: string): string {

FILE: apps/api/src/shared/health/health.controller.ts
  class HealthController (line 17) | class HealthController {
    method constructor (line 18) | constructor(
    method check (line 29) | async check(): Promise<HealthCheckResult> {
    method live (line 39) | live(): { status: string } {
    method ready (line 48) | async ready(): Promise<HealthCheckResult> {

FILE: apps/api/src/shared/health/health.module.ts
  class HealthModule (line 23) | class HealthModule {}

FILE: apps/api/src/shared/health/indicators/database.indicator.ts
  class DatabaseHealthIndicator (line 10) | class DatabaseHealthIndicator extends HealthIndicator {
    method constructor (line 11) | constructor(private readonly kysely: KyselyService) {
    method isHealthy (line 15) | async isHealthy(key: string): Promise<HealthIndicatorResult> {

FILE: apps/api/src/shared/health/indicators/nats.indicator.ts
  class NatsHealthIndicator (line 11) | class NatsHealthIndicator extends HealthIndicator {
    method constructor (line 12) | constructor(private readonly nats: IMessagingService) {
    method isHealthy (line 16) | async isHealthy(key: string): Promise<HealthIndicatorResult> {

FILE: apps/api/src/shared/health/indicators/redis.indicator.ts
  class RedisHealthIndicator (line 10) | class RedisHealthIndicator extends HealthIndicator {
    method constructor (line 11) | constructor(private readonly redis: RedissonService) {
    method isHealthy (line 15) | async isHealthy(key: string): Promise<HealthIndicatorResult> {

FILE: apps/api/src/shared/health/indicators/rustfs.indicator.ts
  class RustFSHealthIndicator (line 11) | class RustFSHealthIndicator extends HealthIndicator {
    method constructor (line 12) | constructor(private readonly rustfs: IStorageService) {
    method isHealthy (line 16) | async isHealthy(key: string): Promise<HealthIndicatorResult> {

FILE: apps/api/src/shared/infrastructure/messaging/event-bus.interface.ts
  type IEventBus (line 3) | interface IEventBus {
  constant EVENT_BUS (line 8) | const EVENT_BUS = Symbol('EVENT_BUS');

FILE: apps/api/src/shared/infrastructure/messaging/event-bus.service.ts
  class EventBusService (line 7) | class EventBusService implements IEventBus {
    method constructor (line 8) | constructor(private readonly eventBus: NestEventBus) {}
    method publish (line 10) | async publish(event: DomainEvent): Promise<void> {
    method publishAll (line 14) | async publishAll(events: DomainEvent[]): Promise<void> {

FILE: apps/api/src/shared/infrastructure/messaging/messaging.interface.ts
  type ISubscription (line 8) | interface ISubscription {
  type IMessagingService (line 16) | interface IMessagingService {

FILE: apps/api/src/shared/infrastructure/persistence/repository.interface.ts
  type IRepository (line 1) | interface IRepository<T> {

FILE: apps/api/src/shared/infrastructure/persistence/unit-of-work.interface.ts
  type IUnitOfWork (line 1) | interface IUnitOfWork {

FILE: apps/api/src/shared/infrastructure/storage/storage.interface.ts
  type IStorageService (line 7) | interface IStorageService {
  constant STORAGE_SERVICE (line 81) | const STORAGE_SERVICE = Symbol('STORAGE_SERVICE');

FILE: apps/api/src/shared/metrics/metrics.controller.ts
  class MetricsController (line 11) | class MetricsController {
    method constructor (line 12) | constructor(private readonly metricsService: MetricsService) {}
    method getMetrics (line 18) | getMetrics(): string {
    method getMetricsJson (line 25) | getMetricsJson(): Record<string, unknown> {

FILE: apps/api/src/shared/metrics/metrics.interceptor.ts
  class MetricsInterceptor (line 18) | class MetricsInterceptor implements NestInterceptor {
    method constructor (line 21) | constructor(private readonly metricsService: MetricsService) {}
    method intercept (line 23) | intercept(context: ExecutionContext, next: CallHandler): Observable<an...
    method recordMetrics (line 49) | private recordMetrics(request: Request, response: Response, duration: ...
    method normalizePath (line 75) | private normalizePath(path: string): string {
    method getDuration (line 86) | private getDuration(startTime: bigint): number {

FILE: apps/api/src/shared/metrics/metrics.service.ts
  type CounterMetric (line 10) | interface CounterMetric {
  type GaugeMetric (line 19) | interface GaugeMetric {
  type HistogramMetric (line 28) | interface HistogramMetric {
  constant DEFAULT_HISTOGRAM_BUCKETS (line 38) | const DEFAULT_HISTOGRAM_BUCKETS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, ...
  constant DEFAULT_SIZE_BUCKETS (line 43) | const DEFAULT_SIZE_BUCKETS = [100, 1000, 10000, 100000, 1000000, 10000000];
  class MetricsService (line 49) | class MetricsService implements OnModuleDestroy {
    method constructor (line 79) | constructor() {
    method initializeMetrics (line 83) | private initializeMetrics(): void {
    method getKey (line 105) | private getKey(name: string, labelNames?: string[]): string {
    method getLabelValues (line 109) | private getLabelValues(labelNames: string[], labels: Record<string, st...
    method incCounter (line 120) | incCounter(name: string, labels?: Record<string, string>, amount = 1):...
    method getCounter (line 129) | getCounter(name: string, labels?: Record<string, string>): number {
    method setGauge (line 141) | setGauge(name: string, value: number, labels?: Record<string, string>)...
    method incGauge (line 149) | incGauge(name: string, labels?: Record<string, string>, amount = 1): v...
    method decGauge (line 158) | decGauge(name: string, labels?: Record<string, string>, amount = 1): v...
    method getGauge (line 167) | getGauge(name: string, labels?: Record<string, string>): number {
    method observeHistogram (line 179) | observeHistogram(name: string, value: number, labels?: Record<string, ...
    method getHistogram (line 189) | getHistogram(name: string, labels?: Record<string, string>): number[] {
    method getHistogramStats (line 197) | getHistogramStats(name: string, labels?: Record<string, string>): { co...
    method recordHttpRequest (line 226) | recordHttpRequest(method: string, path: string, status: number, durati...
    method recordDbQuery (line 238) | recordDbQuery(operation: string, table: string, duration: number): void {
    method recordCacheHit (line 246) | recordCacheHit(cache: string): void {
    method recordCacheMiss (line 253) | recordCacheMiss(cache: string): void {
    method toPrometheusFormat (line 264) | toPrometheusFormat(): string {
    method toJSON (line 298) | toJSON(): Record<string, unknown> {
    method onModuleDestroy (line 308) | onModuleDestroy(): void {

FILE: apps/api/src/shared/openapi/openapi-common.dto.ts
  class PaginationParamsDto (line 7) | class PaginationParamsDto {
  class IdParamDto (line 15) | class IdParamDto {
  class SlugParamDto (line 20) | class SlugParamDto {
  class CreatedAtFilterDto (line 25) | class CreatedAtFilterDto {
  class StatusFilterDto (line 33) | class StatusFilterDto {
  class SearchQueryDto (line 38) | class SearchQueryDto {

FILE: apps/api/src/shared/openapi/openapi-decorators.ts
  function ApiAuth (line 22) | function ApiAuth(summary?: string) {
  function ApiPermission (line 39) | function ApiPermission(resource: string, action: string, summary?: strin...
  function ApiStandardResponse (line 59) | function ApiStandardResponse<T>(options: {
  function ApiCreatedResponse (line 97) | function ApiCreatedResponse<T>(options: {
  function ApiNoContentResponse (line 108) | function ApiNoContentResponse(summary?: string) {
  function ApiPaginatedResponse (line 122) | function ApiPaginatedResponse<T>(options: {
  function ApiBadRequestResponse (line 167) | function ApiBadRequestResponse(description = 'Bad Request - Invalid inpu...
  function ApiNotFoundResponse (line 184) | function ApiNotFoundResponse(resource = 'Resource') {
  function ApiConflictResponse (line 200) | function ApiConflictResponse(description = 'Conflict - Resource already ...
  function ApiServerErrorResponse (line 216) | function ApiServerErrorResponse() {

FILE: apps/api/src/shared/presentation/filters/domain-exception.filter.ts
  class DomainException (line 4) | class DomainException extends Error {
    method constructor (line 5) | constructor(message: string) {
  class DomainExceptionFilter (line 13) | class DomainExceptionFilter implements ExceptionFilter {
    method catch (line 16) | catch(exception: DomainException, host: ArgumentsHost) {

FILE: apps/api/src/shared/presentation/filters/http-exception.filter.ts
  class HttpExceptionFilter (line 5) | class HttpExceptionFilter implements ExceptionFilter {
    method catch (line 8) | catch(exception: HttpException, host: ArgumentsHost) {

FILE: apps/api/src/shared/presentation/interceptors/logging.interceptor.ts
  class LoggingInterceptor (line 6) | class LoggingInterceptor implements NestInterceptor {
    method intercept (line 9) | intercept(context: ExecutionContext, next: CallHandler): Observable<an...

FILE: apps/api/src/shared/rate-limiting/rate-limiting.decorator.ts
  type RateLimitOptions (line 11) | interface RateLimitOptions {
  constant RATE_LIMIT_KEY (line 18) | const RATE_LIMIT_KEY = 'rate_limit_config';

FILE: apps/api/src/shared/rate-limiting/rate-limiting.guard.ts
  constant RATE_LIMIT_KEY (line 17) | const RATE_LIMIT_KEY = 'rate_limit';
  constant RATE_LIMIT_CONFIG_KEY (line 18) | const RATE_LIMIT_CONFIG_KEY = 'rate_limit_config';
  type RateLimitMetadata (line 20) | interface RateLimitMetadata {
  class RateLimitingGuard (line 35) | class RateLimitingGuard implements CanActivate {
    method constructor (line 36) | constructor(
    method canActivate (line 41) | async canActivate(context: ExecutionContext): Promise<boolean> {
    method getIdentifier (line 85) | private getIdentifier(request: Request): string {
    method getClientIp (line 99) | private getClientIp(request: Request): string {

FILE: apps/api/src/shared/rate-limiting/rate-limiting.service.ts
  type RateLimitConfig (line 8) | interface RateLimitConfig {
  type RateLimitResult (line 17) | interface RateLimitResult {
  constant DEFAULT_RATE_LIMITS (line 27) | const DEFAULT_RATE_LIMITS: Record<string, RateLimitConfig> = {
  class RateLimitingService (line 41) | class RateLimitingService implements OnModuleDestroy {
    method constructor (line 45) | constructor(private readonly redis: RedissonService) {}
    method checkLimit (line 50) | async checkLimit(
    method checkLimitLocal (line 107) | private checkLimitLocal(
    method resetLimit (line 150) | async resetLimit(identifier: string): Promise<void> {
    method getUsage (line 159) | async getUsage(identifier: string): Promise<{ count: number; resetAt: ...
    method onModuleDestroy (line 180) | onModuleDestroy(): void {
  class RateLimitExceededException (line 188) | class RateLimitExceededException extends HttpException {
    method constructor (line 189) | constructor(retryAfter: number) {

FILE: apps/api/src/shared/redis/redis.module.ts
  class RedisModule (line 25) | class RedisModule {}

FILE: apps/api/src/shared/retry/retry.module.ts
  class RetryModule (line 13) | class RetryModule {}

FILE: apps/api/src/shared/retry/retry.service.ts
  type RetryOptions (line 7) | interface RetryOptions {
  type RetryResult (line 24) | interface RetryResult<T> {
  constant DEFAULT_OPTIONS (line 35) | const DEFAULT_OPTIONS: Required<Omit<RetryOptions, 'onRetry' | 'retryabl...
  constant DEFAULT_RETRYABLE_HTTP_CODES (line 47) | const DEFAULT_RETRYABLE_HTTP_CODES = [408, 429, 500, 502, 503, 504];
  class RetryService (line 53) | class RetryService {
    method constructor (line 56) | constructor() {}
    method execute (line 61) | async execute<T>(
    method executeOrThrow (line 126) | async executeOrThrow<T>(
    method isRetryable (line 146) | private isRetryable(error: Error, options: { retryableErrors: any[]; i...
    method calculateDelay (line 163) | private calculateDelay(attempt: number, options: { initialDelay: numbe...
    method calculateJitter (line 171) | private calculateJitter(delay: number): number {
    method sleep (line 179) | private sleep(ms: number): Promise<void> {
  class RetryExhaustedError (line 187) | class RetryExhaustedError extends Error {
    method constructor (line 188) | constructor(
  type RetryDecoratorOptions (line 201) | interface RetryDecoratorOptions extends RetryOptions {
  function Retry (line 209) | function Retry(options: RetryDecoratorOptions = {}) {

FILE: apps/api/src/shared/serialization/example.ts
  type UserEntity (line 10) | interface UserEntity {
  class UserDto (line 26) | class UserDto {
  class CreateUserDto (line 58) | class CreateUserDto {
  class UpdateUserDto (line 75) | class UpdateUserDto {
  function userToDto (line 90) | function userToDto(user: UserEntity): UserDto {
  function userToCreateDto (line 107) | function userToCreateDto(user: UserEntity): CreateUserDto {
  function userListToDto (line 119) | function userListToDto(users: UserEntity[]): UserDto[] {
  class UserSerializer (line 129) | class UserSerializer extends Serializer<UserEntity, UserDto> {
    method instance (line 132) | static get instance(): UserSerializer {
    method toDto (line 136) | toDto(user: UserEntity): UserDto {
  class CreateUserSerializer (line 151) | class CreateUserSerializer extends Serializer<UserEntity, CreateUserDto> {
    method instance (line 154) | static get instance(): CreateUserSerializer {
    method toDto (line 158) | toDto(user: UserEntity): CreateUserDto {

FILE: apps/api/src/shared/serialization/serializer.ts
  method toDtoList (line 49) | toDtoList(entities: Entity[]): Dto[] {
  type ClassType (line 58) | type ClassType<T = any> = new (...args: any[]) => T;
  function transformToInstance (line 63) | function transformToInstance<T>(
  function transformToPlain (line 77) | function transformToPlain<T>(entity: T, options?: { excludeExtraneousVal...
  function transformListToInstance (line 86) | function transformListToInstance<T>(
  function transformListToPlain (line 100) | function transformListToPlain<T>(entities: T[]): Record<string, unknown>...
  type Mapper (line 107) | type Mapper<Entity, Dto> = (entity: Entity) => Dto;
  function toDto (line 112) | function toDto<Entity, Dto>(mapper: Mapper<Entity, Dto>): Mapper<Entity,...
  function toDtoList (line 119) | function toDtoList<Entity, Dto>(mapper: Mapper<Entity, Dto>): (entities:...

FILE: apps/api/src/shared/tenant/tenant.guard.ts
  class TenantGuard (line 18) | class TenantGuard implements CanActivate {
    method constructor (line 19) | constructor(private readonly tenantService: TenantService) {}
    method canActivate (line 21) | canActivate(context: ExecutionContext): boolean {
  class OptionalTenantGuard (line 44) | class OptionalTenantGuard implements CanActivate {
    method constructor (line 45) | constructor(private readonly tenantService: TenantService) {}
    method canActivate (line 47) | canActivate(context: ExecutionContext): boolean {

FILE: apps/api/src/shared/tenant/tenant.interceptor.ts
  class TenantInterceptor (line 15) | class TenantInterceptor implements NestInterceptor {
    method constructor (line 16) | constructor(private readonly tenantService: TenantService) {}
    method intercept (line 18) | intercept(context: ExecutionContext, next: CallHandler): Observable<an...

FILE: apps/api/src/shared/tenant/tenant.service.ts
  type TenantContext (line 12) | interface TenantContext {
  class TenantService (line 23) | class TenantService {
    method constructor (line 26) | constructor(@Optional() @Inject(REQUEST) private readonly request: Req...
    method setContext (line 31) | setContext(context: TenantContext): void {
    method getOrganizationId (line 38) | getOrganizationId(): string {
    method getUserId (line 48) | getUserId(): string | undefined {
    method getContext (line 55) | getContext(): TenantContext | null {
    method hasContext (line 62) | hasContext(): boolean {
    method getMetadata (line 69) | getMetadata<T>(key: string): T | undefined {
  class TenantStorage (line 77) | class TenantStorage {
    method set (line 80) | static set(context: TenantContext): void {
    method get (line 84) | static get(): TenantContext | null {
    method clear (line 88) | static clear(): void {

FILE: apps/api/src/shared/testing/testing.utils.ts
  function createTestingModule (line 11) | async function createTestingModule(options: {
  function createMock (line 37) | function createMock<T>(overrides?: Partial<T>): jest.Mocked<T> {
  function createMockInstance (line 53) | function createMockInstance<T>(classType: new (...args: any[]) => T): je...
  class FixtureBuilder (line 73) | class FixtureBuilder<T> {
    method constructor (line 76) | constructor(private defaultData: T) {
    method with (line 80) | with<K extends keyof T>(key: K, value: T[K]): this {
    method withPartial (line 85) | withPartial(partial: Partial<T>): this {
    method build (line 90) | build(): T {
    method buildMany (line 94) | buildMany(count: number): T[] {
  function fixture (line 102) | function fixture<T>(defaultData: T): FixtureBuilder<T> {
  function createPaginatedFixture (line 109) | function createPaginatedFixture<T>(items: T[], total: number, page = 1, ...
  function createMockRequest (line 136) | function createMockRequest(overrides?: Partial<Request>): Request {
  method freeze (line 152) | freeze(date: Date = new Date()): void {
  method useReal (line 158) | useReal(): void {
  method advance (line 163) | advance(ms: number): void {
  method setFuture (line 168) | setFuture(days = 1): Date {
  function createMockResponse (line 179) | function createMockResponse() {
  function createMockQueryBuilder (line 192) | function createMockQueryBuilder() {
  function createMockRedis (line 215) | function createMockRedis() {

FILE: apps/api/src/shared/tracking/tracking.interceptor.ts
  type TrackingContext (line 18) | interface TrackingContext {
  class TrackingInterceptor (line 27) | class TrackingInterceptor implements NestInterceptor {
    method intercept (line 28) | intercept(context: ExecutionContext, next: CallHandler): Observable<un...
  function getTrackingContext (line 67) | function getTrackingContext(): TrackingContext | undefined {
  function getRequestId (line 72) | function getRequestId(): string | undefined {
  function getCorrelationId (line 77) | function getCorrelationId(): string | undefined {

FILE: apps/api/src/shared/transform/transform.interceptor.ts
  type TransformOptions (line 16) | interface TransformOptions {
  type ResponseMetadata (line 30) | interface ResponseMetadata {
  class TransformInterceptor (line 42) | class TransformInterceptor implements NestInterceptor {
    method constructor (line 46) | constructor(options: TransformOptions = {}) {
    method intercept (line 55) | intercept(context: ExecutionContext, next: CallHandler): Observable<an...
    method buildMetadata (line 91) | private buildMetadata(request: Request, response: Response, duration: ...
    method wrapResponse (line 104) | private wrapResponse(data: any, metadata: ResponseMetadata): any {
    method isPrimitive (line 119) | private isPrimitive(value: any): boolean {
    method isWrappedResponse (line 129) | private isWrappedResponse(value: any): boolean {
    method getDuration (line 139) | private getDuration(startTime: bigint): bigint {
  function transformKeysToCamelCase (line 147) | function transformKeysToCamelCase<T>(obj: any): T {
  function transformKeysToSnakeCase (line 168) | function transformKeysToSnakeCase<T>(obj: any): T {
  class KeyTransformInterceptor (line 190) | class KeyTransformInterceptor implements NestInterceptor {
    method constructor (line 191) | constructor(
    method intercept (line 195) | intercept(context: ExecutionContext, next: CallHandler): Observable<an...

FILE: apps/api/src/shared/utils/guard.ts
  class Guard (line 1) | class Guard {
    method againstNullOrUndefined (line 2) | public static againstNullOrUndefined(argument: any, argumentName: stri...
    method againstNullOrUndefinedBulk (line 9) | public static againstNullOrUndefinedBulk(args: GuardArgument[]): Result {
    method isOneOf (line 17) | public static isOneOf(value: any, validValues: any[], argumentName: st...
    method inRange (line 37) | public static inRange(num: number, min: number, max: number, argumentN...
    method allInRange (line 48) | public static allInRange(numbers: number[], min: number, max: number, ...
  type GuardArgument (line 62) | interface GuardArgument {
  type Result (line 67) | interface Result {

FILE: apps/api/src/shared/utils/result.ts
  class Result (line 9) | class Result<T> {
    method constructor (line 15) | private constructor(isSuccess: boolean, error: string | null, value: T...
    method getValue (line 27) | getValue(): T {
    method getValueOrElse (line 37) | getValueOrElse(defaultValue: T): T {
    method getValueOrUndefined (line 44) | getValueOrUndefined(): T | undefined {
    method map (line 51) | map<U>(fn: (value: T) => U): Result<U> {
    method mapAsync (line 61) | async mapAsync<U>(fn: (value: T) => Promise<U>): Promise<Result<U>> {
    method flatMap (line 71) | flatMap<U>(fn: (value: T) => Result<U>): Result<U> {
    method flatMapAsync (line 81) | async flatMapAsync<U>(fn: (value: T) => Promise<Result<U>>): Promise<R...
    method fold (line 91) | fold<U>(onSuccess: (value: T) => U, onFailure: (error: string) => U): U {
    method foldAsync (line 101) | async foldAsync<U>(
    method tap (line 114) | tap(fn: (value: T) => void): Result<T> {
    method tapAsync (line 124) | async tapAsync(fn: (value: T) => Promise<void>): Promise<Result<T>> {
    method contains (line 134) | contains(value: T): boolean {
    method existsError (line 141) | existsError(predicate: (error: string) => boolean): boolean {
    method ok (line 149) | static ok<U>(value?: U): Result<U> {
    method fail (line 153) | static fail<U>(error: string): Result<U> {
    method fromTry (line 160) | static fromTry<U>(fn: () => U): Result<U> {
    method fromTryAsync (line 171) | static async fromTryAsync<U>(fn: () => Promise<U>): Promise<Result<U>> {
    method combine (line 182) | static combine<T extends Result<any>[]>(...results: T): Result<{ [K in...
    method combineAll (line 201) | static combineAll<T>(...results: Array<Result<T>>): Result<T[]> {
  type UnwrapResult (line 224) | type UnwrapResult<T> = T extends Result<infer U> ? U : T;
  type VoidResult (line 229) | type VoidResult = Result<null>;

FILE: apps/api/src/shared/validation/validation-options.ts
  function IsPassword (line 53) | function IsPassword(options?: { minLength?: number; ValidationOptions?: ...
  function IsStrongPassword (line 80) | function IsStrongPassword(options?: { minLength?: number; ValidationOpti...
  function IsUsername (line 108) | function IsUsername(options?: { minLength?: number; maxLength?: number; ...
  function IsSlug (line 133) | function IsSlug(options?: { maxLength?: number; ValidationOptions?: Vali...
  function IsJsonString (line 157) | function IsJsonString(ValidationOptions?: ValidationOptions) {
  function IsObjectId (line 188) | function IsObjectId(ValidationOptions?: ValidationOptions) {
  function IsPrefixedId (line 210) | function IsPrefixedId(prefix: string, ValidationOptions?: ValidationOpti...
  function IsNonEmptyArray (line 237) | function IsNonEmptyArray(ValidationOptions?: ValidationOptions) {
  function IsUniqueArray (line 258) | function IsUniqueArray(ValidationOptions?: ValidationOptions) {
  function IsIso8601Date (line 284) | function IsIso8601Date(ValidationOptions?: ValidationOptions) {
  function IsFutureDate (line 291) | function IsFutureDate(ValidationOptions?: ValidationOptions) {
  function IsPastDate (line 314) | function IsPastDate(ValidationOptions?: ValidationOptions) {
  function IsInRange (line 341) | function IsInRange(min: number, max: number, ValidationOptions?: Validat...
  function IsLengthInRange (line 362) | function IsLengthInRange(min: number, max: number, ValidationOptions?: V...
  function MatchesField (line 388) | function MatchesField(
  function IsInstanceOf (line 418) | function IsInstanceOf<T extends new (...args: unknown[]) => unknown>(
  function IsArrayOf (line 442) | function IsArrayOf<T>(

FILE: apps/api/src/shared/validation/validation.pipe.ts
  constant DEFAULT_VALIDATOR_OPTIONS (line 15) | const DEFAULT_VALIDATOR_OPTIONS: ValidatorOptions = {
  constant DEFAULT_TRANSFORM_OPTIONS (line 24) | const DEFAULT_TRANSFORM_OPTIONS = {
  function formatValidationErrors (line 31) | function formatValidationErrors(
  function createValidationPipe (line 62) | function createValidationPipe(

FILE: packages/bullmq/src/bullmq.module-definition.ts
  constant MODULE_OPTIONS_TOKEN (line 8) | const MODULE_OPTIONS_TOKEN = 'BULLMQ_MODULE_OPTIONS';

FILE: packages/bullmq/src/bullmq.module.ts
  class BullMQModule (line 14) | class BullMQModule {
    method register (line 18) | static register(options: BullMQModuleOptions): DynamicModule {
    method registerAsync (line 34) | static registerAsync(options: {

FILE: packages/bullmq/src/bullmq.service.ts
  type JobData (line 9) | interface JobData {
  type JobResult (line 13) | interface JobResult {
  type JobProcessor (line 19) | type JobProcessor<T extends JobData = JobData> = (job: Job<T>) => Promis...
  type QueueMetrics (line 24) | interface QueueMetrics {
  class BullMQService (line 33) | class BullMQService implements OnModuleDestroy {
    method constructor (line 39) | constructor(private readonly options: BullMQModuleOptions) {}
    method getQueue (line 44) | getQueue(name: string): Queue {
    method addJob (line 63) | async addJob<T extends JobData>(
    method addDelayedJob (line 92) | async addDelayedJob<T extends JobData>(
    method addRepeatableJob (line 104) | async addRepeatableJob<T extends JobData>(
    method createWorker (line 118) | createWorker<T extends JobData = JobData>(
    method getQueueEvents (line 166) | getQueueEvents(queueName: string): QueueEvents {
    method getQueueMetrics (line 182) | async getQueueMetrics(queueName: string): Promise<QueueMetrics> {
    method pauseQueue (line 199) | async pauseQueue(queueName: string): Promise<void> {
    method resumeQueue (line 208) | async resumeQueue(queueName: string): Promise<void> {
    method drainQueue (line 217) | async drainQueue(queueName: string): Promise<void> {
    method cleanQueue (line 226) | async cleanQueue(
    method removeJob (line 238) | async removeJob(queueName: string, jobId: string): Promise<void> {
    method getJob (line 249) | async getJob(queueName: string, jobId: string): Promise<Job | undefine...
    method onModuleDestroy (line 257) | async onModuleDestroy(): Promise<void> {

FILE: packages/bullmq/src/bullmq.types.ts
  type BullMQModuleOptions (line 5) | interface BullMQModuleOptions {
  type BullMQOptionsFactory (line 27) | interface BullMQOptionsFactory {

FILE: packages/etcd/src/config.service.ts
  type ConfigSubscriber (line 4) | type ConfigSubscriber = (value: unknown) => void;
  class EtcdConfigService (line 10) | class EtcdConfigService implements OnModuleInit {
    method constructor (line 17) | constructor(private readonly etcd: EtcdService) {}
    method onModuleInit (line 19) | async onModuleInit() {
    method get (line 25) | async get<T = string>(key: string, useCache = true): Promise<T | null> {
    method getJSON (line 40) | async getJSON<T = unknown>(key: string, useCache = true): Promise<T | ...
    method getByPrefix (line 55) | async getByPrefix<T = unknown>(prefix: string): Promise<Map<string, T>> {
    method set (line 61) | async set(key: string, value: string | number | boolean | object, opti...
    method setJSON (line 66) | async setJSON<T extends object>(key: string, value: T, options?: { ttl...
    method delete (line 72) | async delete(key: string): Promise<boolean> {
    method deleteByPrefix (line 78) | async deleteByPrefix(prefix: string): Promise<number> {
    method subscribe (line 90) | subscribe<T = string>(key: string, callback: (value: T) => void): () =...
    method subscribePrefix (line 125) | subscribePrefix<T = string>(prefix: string, callback: (event: { key: s...
    method exists (line 135) | async exists(key: string): Promise<boolean> {
    method clearCache (line 139) | clearCache(): void {
    method setCacheTtl (line 143) | setCacheTtl(ttl: number): void {

FILE: packages/etcd/src/etcd.module.ts
  class EtcdModule (line 11) | class EtcdModule {
    method register (line 12) | static register(options: EtcdModuleOptions): DynamicModule {
    method registerAsync (line 25) | static registerAsync(options: {

FILE: packages/etcd/src/etcd.service.ts
  class EtcdService (line 6) | class EtcdService implements OnModuleInit, OnModuleDestroy {
    method constructor (line 11) | constructor(private readonly options: EtcdModuleOptions) {
    method onModuleInit (line 28) | async onModuleInit() {
    method onModuleDestroy (line 42) | async onModuleDestroy() {
    method get (line 58) | async get<T = string>(key: string): Promise<T | null> {
    method getJSON (line 69) | async getJSON<T = unknown>(key: string): Promise<T | null> {
    method set (line 79) | async set(key: string, value: string | number | boolean | object, opti...
    method delete (line 92) | async delete(key: string): Promise<boolean> {
    method deleteByPrefix (line 97) | async deleteByPrefix(prefix: string): Promise<number> {
    method exists (line 102) | async exists(key: string): Promise<boolean> {
    method getKeysByPrefix (line 106) | async getKeysByPrefix(prefix: string): Promise<string[]> {
    method getEntries (line 112) | async getEntries<T = string>(prefix: string): Promise<ConfigEntry<T>[]> {
    method getEntriesAsJSON (line 129) | async getEntriesAsJSON<T = unknown>(prefix: string): Promise<Map<strin...
    method createLease (line 146) | async createLease(ttl: number): Promise<LeaseInfo> {
    method grantLease (line 152) | async grantLease(ttl: number): Promise<string> {
    method keepAlive (line 157) | async keepAlive(leaseId: string): Promise<void> {
    method revokeLease (line 162) | async revokeLease(leaseId: string): Promise<void> {
    method watch (line 168) | watch<T = string>(key: string, callback: WatchCallback<T>): () => void {
    method watchPrefix (line 207) | watchPrefix<T = string>(prefix: string, callback: WatchCallback<T>): (...
    method healthCheck (line 248) | async healthCheck(): Promise<HealthResult> {
    method getMembers (line 261) | async getMembers(): Promise<string[]> {
    method getLeader (line 266) | async getLeader(): Promise<string | null> {
    method compareAndSet (line 277) | async compareAndSet(
    method getClient (line 301) | getClient(): Etcd3 {

FILE: packages/etcd/src/etcd.types.ts
  type EtcdModuleOptions (line 4) | interface EtcdModuleOptions {
  type WatchEventType (line 28) | type WatchEventType = 'put' | 'delete';
  type WatchEvent (line 33) | interface WatchEvent<T = unknown> {
  type WatchCallback (line 44) | type WatchCallback<T = unknown> = (event: WatchEvent<T>) => void;
  type ConfigEntry (line 49) | interface ConfigEntry<T = unknown> {
  type LeaseInfo (line 60) | interface LeaseInfo {
  type HealthResult (line 69) | interface HealthResult {

FILE: packages/kysely/src/kysely-module-options.interface.ts
  type KyselyModuleOptions (line 4) | interface KyselyModuleOptions<DB = unknown> {
  type KyselyModuleOptionsFactory (line 12) | interface KyselyModuleOptionsFactory<DB = unknown> {
  type KyselyModuleAsyncOptions (line 18) | interface KyselyModuleAsyncOptions<DB = unknown>

FILE: packages/kysely/src/kysely.logger.ts
  constant SQL_KEYWORDS (line 12) | const SQL_KEYWORDS = [

FILE: packages/kysely/src/kysely.module.ts
  class KyselyModule (line 10) | class KyselyModule extends ConfigurableModuleClass {
    method register (line 11) | static register(options: typeof OPTIONS_TYPE): DynamicModule {
    method registerAsync (line 20) | static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {

FILE: packages/kysely/src/kysely.service.ts
  class KyselyService (line 7) | class KyselyService<T> extends Kysely<T> implements OnModuleDestroy {
    method constructor (line 13) | constructor(
    method onModuleDestroy (line 29) | async onModuleDestroy(): Promise<void> {

FILE: packages/logger/src/logger.module.ts
  class LoggerModule (line 12) | class LoggerModule extends ConfigurableModuleClass {
    method register (line 13) | static register(options: typeof OPTIONS_TYPE) {
    method registerAsync (line 31) | static registerAsync(options: typeof ASYNC_OPTIONS_TYPE) {

FILE: packages/logger/src/logger.service.ts
  class LoggerServiceImpl (line 15) | class LoggerServiceImpl implements NestLoggerService {
    method constructor (line 20) | constructor(options: LoggerModuleOptions = {}) {
    method log (line 61) | log(levelOrMessage: string | LogLevel, messageOrContext?: string | Log...
    method fatal (line 77) | fatal(message: string, context?: Partial<LogContext>): void {
    method error (line 83) | error(errorOrMessage: Error | string, context?: Partial<LogContext>): ...
    method warn (line 91) | warn(message: string, context?: Partial<LogContext>): void {
    method info (line 95) | info(message: string, context?: Partial<LogContext>): void {
    method debug (line 99) | debug(message: string, context?: Partial<LogContext>): void {
    method trace (line 103) | trace(message: string, context?: Partial<LogContext>): void {
    method verbose (line 107) | verbose(message: string, context?: Partial<LogContext>): void {
    method child (line 115) | child(context: Partial<LogContext>): LoggerService {
    method getRequestContext (line 130) | static getRequestContext(): LogContext | undefined {
    method runWithContext (line 134) | static runWithContext<T>(context: LogContext, fn: () => T): T {
    method setRequestContext (line 138) | static setRequestContext(context: LogContext): void {
    method logRequest (line 146) | logRequest(options: {
    method logAtLevel (line 179) | private logAtLevel(level: LogLevel, message: string, context?: Partial...
    method logError (line 190) | private logError(error: Error, context?: Partial<LogContext>): void {
    method getMergedContext (line 207) | private getMergedContext(context?: Partial<LogContext>): Record<string...
    method isLogLevel (line 216) | private isLogLevel(value: string): value is LogLevel {

FILE: packages/logger/src/logger.types.ts
  type LoggerModuleOptions (line 5) | interface LoggerModuleOptions {
  type LogLevel (line 14) | type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' ...
  type LogContext (line 16) | interface LogContext {
  type LogEntry (line 30) | interface LogEntry {
  type ErrorLog (line 40) | interface ErrorLog {
  type RequestLoggingOptions (line 48) | interface RequestLoggingOptions {
  type LogInterceptorOptions (line 56) | interface LogInterceptorOptions {

FILE: packages/logger/src/logging.interceptor.ts
  class LoggingInterceptor (line 15) | class LoggingInterceptor implements NestInterceptor {
    method constructor (line 23) | constructor(
    method intercept (line 30) | intercept(context: ExecutionContext, next: CallHandler): Observable<un...
    method isExcludedPath (line 85) | private isExcludedPath(url: string): boolean {
    method getClientIp (line 91) | private getClientIp(request: Request): string {

FILE: packages/nats/src/nats.module.ts
  class NatsModule (line 10) | class NatsModule extends ConfigurableModuleClass {
    method register (line 11) | static register(options: typeof OPTIONS_TYPE): DynamicModule {
    method registerAsync (line 20) | static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {

FILE: packages/nats/src/nats.service.ts
  type Subscription (line 21) | interface Subscription {
  class NatsServiceImpl (line 30) | class NatsServiceImpl implements OnModuleInit, OnModuleDestroy {
    method constructor (line 38) | constructor(private readonly options: NatsPackageOptions) {
    method onModuleInit (line 46) | async onModuleInit() {
    method onModuleDestroy (line 50) | async onModuleDestroy() {
    method connect (line 58) | private async connect(): Promise<void> {
    method disconnect (line 124) | private async disconnect(): Promise<void> {
    method getConnection (line 143) | async getConnection(): Promise<NatsConnection> {
    method getJetStream (line 150) | async getJetStream(): Promise<JetStreamClient> {
    method getState (line 157) | getState(): NatsConnectionState {
    method isHealthy (line 161) | async isHealthy(): Promise<boolean> {
    method publish (line 176) | async publish(options: PublishOptions): Promise<void> {
    method pubsub (line 195) | async pubsub(subject: string, data: object): Promise<void> {
    method request (line 206) | async request(options: RequestOptions): Promise<NatsMessage> {
    method request$ (line 226) | async request$<T>(subject: string, data?: object): Promise<T> {
    method subscribe (line 239) | async subscribe(
    method subscribe$ (line 276) | async subscribe$(
    method unsubscribe (line 289) | unsubscribe(subscription: Subscription): void {
    method handleSubscription (line 297) | private async handleSubscription(
    method jsPublish (line 326) | async jsPublish(options: JetStreamPublishOptions): Promise<PubAck> {
    method jsSubscribe (line 360) | async jsSubscribe(
    method encodeData (line 416) | private encodeData(data?: Uint8Array | string | object): Uint8Array {
    method decodeData (line 432) | private decodeData(data: Uint8Array): unknown {
    method convertMessage (line 449) | private convertMessage(msg: Msg): NatsMessage {

FILE: packages/nats/src/nats.types.ts
  type NatsPackageOptions (line 7) | interface NatsPackageOptions {
  type NatsModuleOptions (line 24) | type NatsModuleOptions = NatsPackageOptions;
  type TlsOptions (line 26) | interface TlsOptions {
  type AuthOptions (line 33) | interface AuthOptions {
  type JetStreamOptions (line 39) | interface JetStreamOptions {
  type NatsConnectionState (line 45) | interface NatsConnectionState {
  type PublishOptions (line 56) | interface PublishOptions {
  type RequestOptions (line 64) | interface RequestOptions extends PublishOptions {
  type PubAckPromise (line 69) | interface PubAckPromise {
  type SubscribeOptions (line 79) | interface SubscribeOptions {
  type SubscriptionConfig (line 88) | interface SubscriptionConfig {
  type DeliverPolicy (line 101) | type DeliverPolicy =
  type AckPolicy (line 110) | type AckPolicy =
  type ReplayPolicy (line 116) | type ReplayPolicy =
  type NatsMessage (line 122) | interface NatsMessage {
  type SubscriptionHandler (line 131) | interface SubscriptionHandler {
  type JetStreamPublishOptions (line 139) | interface JetStreamPublishOptions {
  type JetStreamSubscribeOptions (line 148) | interface JetStreamSubscribeOptions extends SubscribeOptions {
  type StreamSubscriptionConfig (line 154) | interface StreamSubscriptionConfig extends SubscriptionConfig {
  type StreamInfo (line 167) | interface StreamInfo {
  type StreamConfig (line 174) | interface StreamConfig {
  type RetentionPolicy (line 190) | type RetentionPolicy =
  type StorageType (line 195) | type StorageType =
  type StreamState (line 199) | interface StreamState {
  type ClusterInfo (line 210) | interface ClusterInfo {
  type PeerInfo (line 215) | interface PeerInfo {
  class NatsError (line 227) | class NatsError extends Error {
    method constructor (line 228) | constructor(
  class NatsConnectionError (line 238) | class NatsConnectionError extends NatsError {
    method constructor (line 239) | constructor(server: string, reason?: string) {
  class NatsPublishError (line 248) | class NatsPublishError extends NatsError {
    method constructor (line 249) | constructor(subject: string, reason?: string) {
  class NatsSubscribeError (line 258) | class NatsSubscribeError extends NatsError {
    method constructor (line 259) | constructor(subject: string, reason?: string) {
  class NatsRequestError (line 268) | class NatsRequestError extends NatsError {
    method constructor (line 269) | constructor(subject: string, reason?: string) {

FILE: packages/redisson/src/redisson-module-options.interface.ts
  type RedissonModuleOptions (line 3) | interface RedissonModuleOptions extends IRedissonConfig {}

FILE: packages/redisson/src/redisson.module.ts
  class RedissonModule (line 6) | class RedissonModule extends ConfigurableModuleClass {
    method register (line 7) | static register(options: typeof OPTIONS_TYPE): DynamicModule {
    method registerAsync (line 16) | static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {

FILE: packages/redisson/src/redisson.service.ts
  class RedissonService (line 7) | class RedissonService extends Redisson implements OnModuleInit, OnModule...
    method constructor (line 10) | constructor(
    method onModuleInit (line 20) | async onModuleInit() {
    method onModuleDestroy (line 31) | async onModuleDestroy() {
    method withLock (line 48) | async withLock<T>(key: string, callback: () => Promise<T> | T, waitTim...
    method getOrSet (line 72) | async getOrSet<T>(key: string, factory: () => Promise<T> | T, ttl?: nu...
    method deleteByPattern (line 103) | async deleteByPattern(pattern: string): Promise<number> {
    method setJSON (line 121) | async setJSON<T>(key: string, value: T, ttl?: number): Promise<void> {
    method getJSON (line 136) | async getJSON<T>(key: string): Promise<T | null> {
    method exists (line 156) | async exists(key: string): Promise<boolean> {
    method expire (line 167) | async expire(key: string, ttl: number): Promise<boolean> {
    method delete (line 177) | async delete(...keys: string[]): Promise<number> {
    method increment (line 187) | async increment(key: string, increment = 1): Promise<number> {
    method decrement (line 197) | async decrement(key: string, decrement = 1): Promise<number> {
    method get (line 206) | async get(key: string): Promise<string | null> {
    method set (line 216) | async set(key: string, value: string, ttl?: number): Promise<void> {
    method hset (line 230) | async hset(key: string, field: string, value: string): Promise<void> {
    method hget (line 240) | async hget(key: string, field: string): Promise<string | null> {
    method hgetall (line 249) | async hgetall(key: string): Promise<Record<string, string>> {
    method hdel (line 259) | async hdel(key: string, ...fields: string[]): Promise<number> {
    method eval (line 270) | async eval(script: string, keys: string[], args: string[]): Promise<an...
    method evalsha (line 282) | async evalsha(sha1: string, keys: string[], args: string[]): Promise<a...
    method scriptLoad (line 292) | async scriptLoad(script: string): Promise<string> {
    method getRedis (line 301) | getRedis(): ReturnType<Redisson['getRedis']> {
    method tryLock (line 312) | async tryLock(key: string, waitTime = 5000, leaseTime = 10000): Promis...
    method unlock (line 321) | async unlock(key: string): Promise<void> {

FILE: packages/redisson/src/types.ts
  type CacheOptions (line 4) | interface CacheOptions {
  type LockOptions (line 14) | interface LockOptions {
  type CacheMetadata (line 24) | interface CacheMetadata {
  type LockMetadata (line 34) | interface LockMetadata {
  type BatchResult (line 46) | interface BatchResult<T = any> {

FILE: packages/rustfs/src/rustfs.module.ts
  class RustFSModule (line 10) | class RustFSModule extends ConfigurableModuleClass {
    method register (line 11) | static register(options: typeof OPTIONS_TYPE): DynamicModule {
    method registerAsync (line 20) | static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {

FILE: packages/rustfs/src/rustfs.service.ts
  class RustFSServiceImpl (line 50) | class RustFSServiceImpl implements OnModuleInit {
    method constructor (line 55) | constructor(private readonly options: RustFSPackageOptions) {
    method onModuleInit (line 60) | async onModuleInit() {
    method createClient (line 70) | private createClient(): S3Client {
    method createBucket (line 100) | async createBucket(options: CreateBucketOptions): Promise<Bucket> {
    method listBuckets (line 128) | async listBuckets(): Promise<Bucket[]> {
    method getBucketAcl (line 138) | async getBucketAcl(bucketName: string): Promise<BucketAcl> {
    method setBucketAcl (line 156) | async setBucketAcl(bucketName: string, acl: BucketAcl): Promise<void> {
    method deleteBucket (line 165) | async deleteBucket(bucketName: string): Promise<void> {
    method bucketExists (line 171) | async bucketExists(bucketName: string): Promise<boolean> {
    method putObject (line 185) | async putObject(bucketName: string, options: PutObjectOptions): Promis...
    method getObject (line 216) | async getObject(bucketName: string, options: GetObjectOptions): Promis...
    method getObjectMetadata (line 249) | async getObjectMetadata(bucketName: string, key: string): Promise<Stor...
    method copyObject (line 278) | async copyObject(bucketName: string, options: CopyObjectOptions): Prom...
    method deleteObject (line 304) | async deleteObject(bucketName: string, key: string): Promise<void> {
    method deleteObjects (line 314) | async deleteObjects(bucketName: string, keys: string[]): Promise<void> {
    method listObjects (line 329) | async listObjects(bucketName: string, options?: ListObjectsOptions): P...
    method getPresignedUrl (line 363) | async getPresignedUrl(
    method getPresignedPostUrl (line 380) | async getPresignedPostUrl(
    method createMultipartUpload (line 405) | async createMultipartUpload(
    method uploadPart (line 427) | async uploadPart(bucketName: string, options: UploadPartOptions): Prom...
    method completeMultipartUpload (line 442) | async completeMultipartUpload(
    method abortMultipartUpload (line 469) | async abortMultipartUpload(bucketName: string, key: string, uploadId: ...
    method listParts (line 479) | async listParts(bucketName: string, options: ListPartsOptions): Promis...
    method isHealthy (line 508) | async isHealthy(): Promise<boolean> {

FILE: packages/rustfs/src/rustfs.types.ts
  type RustFSPackageOptions (line 5) | interface RustFSPackageOptions {
  type RustFSModuleOptions (line 18) | type RustFSModuleOptions = RustFSPackageOptions;
  type Bucket (line 24) | interface Bucket {
  type CreateBucketOptions (line 29) | interface CreateBucketOptions {
  type BucketCannedAcl (line 35) | type BucketCannedAcl =
  type BucketAcl (line 42) | interface BucketAcl {
  type BucketGrant (line 47) | interface BucketGrant {
  type Grantee (line 52) | interface Grantee {
  type BucketPermission (line 59) | type BucketPermission = 'READ' | 'WRITE' | 'READ_ACP' | 'WRITE_ACP' | 'F...
  type StorageObject (line 65) | interface StorageObject {
  type StorageClass (line 77) | type StorageClass =
  type PutObjectOptions (line 85) | interface PutObjectOptions {
  type ObjectCannedAcl (line 99) | type ObjectCannedAcl =
  type GetObjectOptions (line 108) | interface GetObjectOptions {
  type CopyObjectOptions (line 120) | interface CopyObjectOptions {
  type ListObjectsOptions (line 130) | interface ListObjectsOptions {
  type ListObjectsResult (line 139) | interface ListObjectsResult {
  type PresignedUrlOptions (line 152) | interface PresignedUrlOptions {
  type PresignedPostOptions (line 160) | interface PresignedPostOptions {
  type CreateMultipartUploadOptions (line 177) | interface CreateMultipartUploadOptions {
  type UploadPartOptions (line 185) | interface UploadPartOptions {
  type CompleteMultipartUploadOptions (line 194) | interface CompleteMultipartUploadOptions {
  type UploadPart (line 200) | interface UploadPart {
  type ListPartsOptions (line 206) | interface ListPartsOptions {
  type ListPartsResult (line 213) | interface ListPartsResult {
  class RustFSError (line 226) | class RustFSError extends Error {
    method constructor (line 227) | constructor(
  class BucketNotFoundError (line 237) | class BucketNotFoundError extends RustFSError {
    method constructor (line 238) | constructor(bucketName: string) {
  class ObjectNotFoundError (line 247) | class ObjectNotFoundError extends RustFSError {
    method constructor (line 248) | constructor(key: string, bucketName: string) {
  class BucketAlreadyExistsError (line 257) | class BucketAlreadyExistsError extends RustFSError {
    method constructor (line 258) | constructor(bucketName: string) {
  class InvalidAccessKeyIdError (line 267) | class InvalidAccessKeyIdError extends RustFSError {
    method constructor (line 268) | constructor() {
  class SignatureDoesNotMatchError (line 277) | class SignatureDoesNotMatchError extends RustFSError {
    method constructor (line 278) | constructor() {
  class RegionMismatchError (line 287) | class RegionMismatchError extends RustFSError {
    method constructor (line 288) | constructor(expected: string, actual: string) {