How to register different implementations of an interface in a tsyringe container based on a given parameter

3_syringe_cond.ts

import "reflect-metadata"
import {
  container,
  injectable,
  inject,
  predicateAwareClassFactory,
} from "tsyringe"

export interface Logger {
  info: (msg: string) => void
}

@injectable()
export class ConsoleLogger implements Logger {
  info(msg: string): void {
    console.log("Console Logger:    ", msg)
  }
}

@injectable()
export class PinoLogger implements Logger {
  info(msg: string): void {
    console.log("Pino Logger:    ", msg)
  }
}

const Tokens = Object.freeze({
  logger: "logger",
  consoleLogger: "consoleLogger",
  pinoLogger: "pinoLogger",
  paymentService: "paymentService",
})

@injectable()
export class PaymentService {
  constructor(@inject(Tokens.logger) private readonly logger: Logger) {
    this.logger = logger
  }

  sendMoney() {
    this.logger.info("inversify logger info")
    return true
  }
}

// Varint 1: Simple get
// const ps = container.resolve(PinoLogger)
// ps.info("Lol")

// Variant 2: Bind to interface
// container.register(Tokens.logger, {
//   useClass: ConsoleLogger,
// })
// const ps = container.resolve(PaymentService)
// ps.sendMoney()

// Variant 3
// container.register<Logger>(Tokens.logger, {
//   useFactory: predicateAwareClassFactory<Logger>(
//     (container) => {
//       return process.env.NODE_ENV === "production"
//     },
//     ConsoleLogger,
//     PinoLogger
//   ),
// })

container.register(Tokens.logger, {
  useFactory: () => {
    return process.env.NODE_ENV === "production"
      ? container.resolve(PinoLogger)
      : container.resolve(ConsoleLogger)
  },
})
const ps = container.resolve(PaymentService)
ps.sendMoney()

/**
 * instancePerContainerCachingFactory
 * instanceCachingFactory
 * DelayedConstructor
 */