@tastytrade/api 4.0.0 → 6.0.0

package/lib/logger.ts

@@ -0,0 +1,53 @@
+import _ from 'lodash'
+
+export default interface Logger {
+  error(...data: any[]): void;
+  info(...data: any[]): void;
+  warn(...data: any[]): void;
+}
+
+export enum LogLevel {
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3
+}
+
+export class TastytradeLogger implements Logger {
+  public logLevel: LogLevel
+  public logger: Logger | null = null
+
+  constructor(logger?: Logger, logLevel?: LogLevel) {
+    this.logger = logger ?? null
+    this.logLevel = logLevel ?? LogLevel.ERROR
+  }
+
+  public updateConfig(config: Partial<{logger: Logger, logLevel: LogLevel}>) {
+    const loggerConfig = _.pick(config, ['logger', 'logLevel'])
+    Object.assign(this, loggerConfig)
+  }
+
+  error(...data: any[]): void {
+    if (this.shouldLog(LogLevel.ERROR)) {
+      this.logger!.error(...data)
+    }
+  }
+
+  info(...data: any[]): void {
+    if (this.shouldLog(LogLevel.INFO)) {
+      this.logger!.info(...data)
+    }
+  }
+
+  warn(...data: any[]): void {
+    if (this.shouldLog(LogLevel.WARN)) {
+      this.logger!.warn(...data)
+    }
+  }
+
+  private shouldLog(level: LogLevel) {
+    if (_.isNil(this.logger)) {
+      return false
+    }
+    return LogLevel[level] >= LogLevel[this.logLevel]
+  }
+}

package/lib/models/access-token.ts

@@ -0,0 +1,40 @@
+import _ from 'lodash'
+
+export default class AccessToken {
+    public token = ''
+    public expiresIn = 0
+
+    get isExpired(): boolean {
+        return this.isEmpty || Date.now() >= this.expiration.getTime();
+    }
+
+    get isValid(): boolean {
+        return !_.isNil(this.token) && !this.isExpired;
+    }
+
+    get isEmpty(): boolean {
+        return _.isNil(this.token) || this.token.length === 0;
+    }
+
+    get expiration() {
+        // Set expiration a bit earlier to account for clock skew
+        return new Date(Date.now() + ((this.expiresIn - 30) * 1000));
+    }
+
+    public updateFromTokenResponse(tokenResponse: any): void {
+      this.token = _.get(tokenResponse, "data.access_token");
+      this.expiresIn = _.get(tokenResponse, "data.expires_in");
+    }
+
+    get authorizationHeader(): string | null {
+        if (this.isValid) {
+            return `Bearer ${this.token}`;
+        }
+        return null;
+    }
+
+    clear() {
+        this.token = ''
+        this.expiresIn = 0
+    }
+}

package/lib/models/tastytrade-session.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash'
 
 export default class TastytradeSession { 
-    authToken: string | null = null
+    public authToken: string | null = null
 
     get isValid() {
       return !_.isNil(this.authToken)

package/lib/quote-streamer.ts

@@ -0,0 +1,151 @@
+import { DXLinkWebSocketClient, DXLinkFeed, FeedContract, FeedDataFormat, type DXLinkFeedEventListener } from '@dxfeed/dxlink-api'
+import type AccountsAndCustomersService from './services/accounts-and-customers-service.js'
+import type Logger from './logger.js'
+import _ from 'lodash'
+
+// TODO: Make sure this works in node and we don't have to override the global Websocket class
+
+export enum MarketDataSubscriptionType {
+  Candle = 'Candle',
+  Quote = 'Quote',
+  Trade = 'Trade',
+  Summary = 'Summary',
+  Profile = 'Profile',
+  Greeks = 'Greeks',
+  Underlying = 'Underlying'
+}
+
+const ALL_EVENT_TYPES = [
+  MarketDataSubscriptionType.Quote,
+  MarketDataSubscriptionType.Trade,
+  MarketDataSubscriptionType.Summary,
+  MarketDataSubscriptionType.Profile,
+  MarketDataSubscriptionType.Greeks,
+  MarketDataSubscriptionType.Underlying
+]
+
+export enum CandleType {
+  Tick = 't',
+  Second = 's',
+  Minute = 'm',
+  Hour = 'h',
+  Day = 'd',
+  Week = 'w',
+  Month = 'mo',
+  ThirdFriday = 'o',
+  Year = 'y',
+  Volume = 'v',
+  Price = 'p'
+}
+
+export default class QuoteStreamer {
+  public dxLinkFeed: DXLinkFeed<any> | null = null
+  public dxLinkUrl: string | null = null
+  public dxLinkAuthToken: string | null = null
+  public eventListeners: DXLinkFeedEventListener[] = []
+
+  constructor(private readonly accountsAndCustomersService: AccountsAndCustomersService, private readonly logger: Logger) {
+  }
+
+  /**
+   * Connects to the DxLink WebSocket and sets up the feed
+   * Make sure to call disconnect() when done
+   * Calls `getApiQuoteToken` to get the connection URL and auth token
+   * Make sure you have a valid session or access token before calling this
+   */
+  async connect() {
+    const tokenResponse = await this.accountsAndCustomersService.getApiQuoteToken()
+    this.dxLinkUrl = _.get(tokenResponse, 'dxlink-url')
+    this.dxLinkAuthToken = _.get(tokenResponse, 'token')
+
+    const client = new DXLinkWebSocketClient()
+    client.connect(this.dxLinkUrl!)
+    client.setAuthToken(this.dxLinkAuthToken!)
+
+    this.dxLinkFeed = new DXLinkFeed(client, FeedContract.AUTO)
+
+    this.dxLinkFeed.configure({
+      acceptAggregationPeriod: 10,
+      acceptDataFormat: FeedDataFormat.COMPACT
+    })
+
+    this.eventListeners.forEach(listener => this.dxLinkFeed!.addEventListener(listener))
+  }
+
+  disconnect() {
+    if (_.isNil(this.dxLinkFeed)) {
+      return
+    }
+
+    this.eventListeners.forEach(listener => this.removeEventListener(listener))
+    this.dxLinkFeed = null
+  }
+
+  // Returns a function that can be called to remove the listener
+  addEventListener(listener: DXLinkFeedEventListener): () => void {
+    this.eventListeners.push(listener)
+    if (this.dxLinkFeed) {
+      this.dxLinkFeed.addEventListener(listener)
+    }
+
+    return () => {
+      this.removeEventListener(listener)
+    }
+  }
+
+  removeEventListener(listenerToRemove: DXLinkFeedEventListener) {
+    _.remove(this.eventListeners, listener => listener === listenerToRemove)
+    if (this.dxLinkFeed) {
+      this.dxLinkFeed.removeEventListener(listenerToRemove)
+    }
+  }
+
+  subscribe(streamerSymbols: string[], types: MarketDataSubscriptionType[] | null = null) {
+    if (_.isNil(this.dxLinkFeed)) {
+      throw new Error('DxLink feed is not connected')
+    }
+
+    types = types ?? ALL_EVENT_TYPES
+    streamerSymbols.forEach(symbol => {
+      types.forEach(type => {
+        this.dxLinkFeed!.addSubscriptions({ type, symbol })
+      })
+    })
+  }
+
+  unsubscribe(streamerSymbols: string[]) {
+    if (_.isNil(this.dxLinkFeed)) {
+      throw new Error('DxLink feed is not connected')
+    }
+
+    streamerSymbols.forEach(symbol => {
+      ALL_EVENT_TYPES.forEach(type => {
+        this.dxLinkFeed!.removeSubscriptions({ type, symbol })
+      })
+    })
+  }
+
+  /**
+   * Adds a candle subscription
+   * @param streamerSymbol Get this from an instrument's streamer-symbol json response field
+   * @param fromTime Epoch timestamp from where you want to start
+   * @param period The duration of each candle
+   * @param type The duration type of the period
+   * For example, a period/type of 5/m means you want each candle to represent 5 minutes of data
+   * From there, setting fromTime to 24 hours ago would give you 24 hours of data grouped in 5 minute intervals
+   * @returns 
+   */
+  subscribeCandles(streamerSymbol: string, fromTime: number, period: number, type: CandleType) {
+    // Example: AAPL{=5m} where each candle represents 5 minutes of data
+    const candleSymbol = `${streamerSymbol}{=${period}${type}}`
+    if (_.isNil(this.dxLinkFeed)) {
+      throw new Error('DxLink feed is not connected')
+    }
+
+    this.dxLinkFeed!.addSubscriptions({
+      type: MarketDataSubscriptionType.Candle,
+      symbol: candleSymbol,
+      fromTime
+    })
+  }
+}

package/lib/services/instruments-service.ts

@@ -118,7 +118,7 @@ export default class InstrumentsService {
         return extractResponseData(futureOptionChain)
     }
 
-    //Option-chains: Allows an API client to fetch futures option chains.
+    //Option-chains: Allows an API client to fetch equity option chains.
     async getNestedOptionChain(symbol: string){
         //Returns an option chain given an underlying symbol,
         //i.e. AAPL in a nested form to minimize redundant processing

package/lib/services/session-service.ts

@@ -5,6 +5,18 @@ export default class SessionService {
     constructor(public httpClient: TastytradeHttpClient) {
     }
 
+    private get clientId(): string {
+        return '9953f07a-5de4-408c-a8ab-688a6320f00f'
+    }
+
+    private get clientSecret(): string {
+        return 'baa245033420a05d013541c0c6ef4f98bb16a1ec'
+    }
+
+    private get refreshToken(): string {
+        return 'eyJhbGciOiJFZERTQSIsInR5cCI6InJ0K2p3dCIsImtpZCI6IkZqVTdUT25qVEQ2WnVySlg2cVlwWmVPbzBDQzQ5TnIzR1pUN1E4MTc0cUkiLCJqa3UiOiJodHRwczovL2ludGVyaW9yLWFwaS5hcjIudGFzdHl0cmFkZS5zeXN0ZW1zL29hdXRoL2p3a3MifQ.eyJpc3MiOiJodHRwczovL2FwaS50YXN0eXRyYWRlLmNvbSIsInN1YiI6IlUwMDAwMDM3MTg0IiwiaWF0IjoxNzU4MjQzNjY0LCJhdWQiOiI5OTUzZjA3YS01ZGU0LTQwOGMtYThhYi02ODhhNjMyMGYwMGYiLCJncmFudF9pZCI6Ikc0ZTc4MjFkYy03NTQyLTQ0NTQtODBkMy1iYjU3NGEwMGRkYWMiLCJzY29wZSI6InJlYWQgdHJhZGUifQ.ZsP51rUGQIXsP-cU0OCa-45AwwMp18YxOrT_mrrocClhRL7bfWctX8GOJ35Nn_E48WOuQPxUF3KMhSn1tkqLBQ'
+    }
+
     // Sessions: Allows an API client to interact with their session, or create a new one.
     async login(usernameOrEmail: string, password: string, rememberMe = false) {
         // Create a new user session.
@@ -30,6 +42,6 @@ export default class SessionService {
     async logout(){
         const response = await this.httpClient.deleteData('/sessions', {});// added this for the integration tests?
         this.httpClient.session.clear()
-        return extractResponseData(response);
+        return { status: response.status };
     }
 }

package/lib/services/tastytrade-http-client.ts

@@ -1,8 +1,11 @@
 import TastytradeSession from "../models/tastytrade-session.js"
+import AccessToken from "../models/access-token.js"
 import axios from "axios"
 import qs from 'qs'
 import { recursiveDasherizeKeys } from "../utils/json-util.js"
 import _ from 'lodash'
+import type Logger from "../logger.js"
+import type { ClientConfig } from "../tastytrade-api.js"
 
 const ParamsSerializer = {
   serialize: function (queryParams: object) {
@@ -10,20 +13,65 @@ const ParamsSerializer = {
   }
 }
 
-export default class TastytradeHttpClient{
+const ApiVersionRegex = /^\d{8}$/
+
+export default class TastytradeHttpClient {
+    private readonly logger?: Logger
+    public baseUrl: string
+    public clientSecret?: string
+    public refreshToken?: string
+    public oauthScopes?: string[]
+    public readonly accessToken: AccessToken
     public readonly session: TastytradeSession
+    private _targetApiVersion?: string
 
-    constructor(private readonly baseUrl: string) {
+    constructor(clientConfig: Partial<ClientConfig>, logger?: Logger) {
+      this.logger = logger
+      this.baseUrl = clientConfig.baseUrl!
+      this.accessToken = new AccessToken()
       this.session = new TastytradeSession()
+      this.updateConfig(clientConfig)
+    }
+
+    public updateConfig(config: Partial<ClientConfig>) {
+      const httpClientConfig = _.pick(config, ['clientSecret', 'refreshToken', 'oauthScopes', 'targetApiVersion'])
+      if (!_.isEmpty(httpClientConfig)) {
+        Object.assign(this, httpClientConfig)
+        this.accessToken.clear()
+      }
+    }
+
+    get needsTokenRefresh(): boolean {
+      if (this.session.isValid) {
+        return false
+      }
+      if (_.isNil(this.refreshToken) || _.isNil(this.clientSecret)) {
+        return false
+      }
+      return this.accessToken.isExpired
+    }
+
+    get authHeader(): string | null {
+      if (this.session.isValid) {
+        return this.session.authToken
+      }
+      if (this.accessToken.isValid) {
+        return this.accessToken.authorizationHeader
+      }
+      return null
     }
 
     private getDefaultHeaders(): any {
       const headers: { [key: string]: any } = {
         "Content-Type": "application/json",
         "Accept": "application/json",
-        "Authorization": this.session.authToken
+        "Authorization": this.authHeader
       };
 
+      if (!_.isNil(this.targetApiVersion)) {
+        headers["Accept-Version"] = this.targetApiVersion
+      }
+
       // Only set user agent if running in node
       if (typeof window === 'undefined') {
         headers["User-Agent"] = 'tastytrade-sdk-js'
@@ -32,21 +80,44 @@ export default class TastytradeHttpClient{
       return headers
     }
 
-    private async executeRequest(method: string, url: string, data: object = {}, headers: object = {}, params: object = {}) {
-      const dasherizedParams = recursiveDasherizeKeys(params)
-      const dasherizedData = recursiveDasherizeKeys(data)
-      const mergedHeaders = { ...headers, ...this.getDefaultHeaders() }
+    private axiosConfig(method: string, url: string, data: object = {}, headers: object = {}, params: object = {}): any {
+      return _.omitBy(
+        { method, url, baseURL: this.baseUrl, data, headers, params, paramsSerializer: ParamsSerializer},
+        _.isEmpty
+      )
+    }
+
+    public async generateAccessToken(): Promise<any> {
+      if (_.isNil(this.refreshToken) || _.isNil(this.clientSecret) || _.isNil(this.oauthScopes)) {
+        throw new Error('Missing required parameters to generate access token (refreshToken, clientSecret, oauthScopes)')
+      }
+      const params = { 
+        refresh_token: this.refreshToken,
+        client_secret: this.clientSecret,
+        scope: this.oauthScopes!.join(' '),
+        grant_type: 'refresh_token'
+      }
+
+      const config = this.axiosConfig('post', '/oauth/token', params)
+      this.logger?.info('Making request', config)
+      const tokenResponse = await axios.request(config)
+      this.accessToken.updateFromTokenResponse(tokenResponse)
+      return this.accessToken
+    }
+
+    private async executeRequest(method: string, url: string, data: object = {}, headers: object = {}, params: object = {}): Promise<any> {
+      if (this.needsTokenRefresh) {
+        await this.generateAccessToken()
+      }
+      let dasherizedParams = params
+      let dasherizedData = data
+      dasherizedParams = recursiveDasherizeKeys(params)
+      dasherizedData = recursiveDasherizeKeys(data)
 
-      const config = _.omitBy({
-        method,
-        url,
-        baseURL: this.baseUrl,
-        data: dasherizedData,
-        headers: mergedHeaders, 
-        params: dasherizedParams,
-        paramsSerializer: ParamsSerializer
-       }, _.isEmpty)
+      const mergedHeaders = { ...headers, ...this.getDefaultHeaders() }
 
+      const config = this.axiosConfig(method, url, dasherizedData, mergedHeaders, dasherizedParams)
+      this.logger?.info('Making request', config)
       return axios.request(config)
     }
 
@@ -69,4 +140,15 @@ export default class TastytradeHttpClient{
     async deleteData(url: string, headers: object): Promise<any> {
         return this.executeRequest('delete', url, headers);
     }
+
+    public get targetApiVersion(): string | undefined {
+      return this._targetApiVersion
+    }
+
+    public set targetApiVersion(version: string | undefined) {
+      if (!_.isNil(version) && !ApiVersionRegex.test(version)) {
+        throw new Error('Invalid API version format. Expected YYYYMMDD.')
+      }
+      this._targetApiVersion = version
+    }
 }

package/lib/tastytrade-api.ts

@@ -1,6 +1,6 @@
 import TastytradeHttpClient from "./services/tastytrade-http-client.js"
 import { AccountStreamer, STREAMER_STATE, type Disposer, type StreamerStateObserver } from './account-streamer.js'
-import MarketDataStreamer, { type CandleSubscriptionOptions, CandleType, MarketDataSubscriptionType, type MarketDataListener } from "./market-data-streamer.js"
+import _ from 'lodash'
 
 //Services:
 import SessionService from "./services/session-service.js"
@@ -17,11 +17,36 @@ import SymbolSearchService from "./services/symbol-search-service.js"
 import TransactionsService from "./services/transactions-service.js"
 import WatchlistsService from "./services/watchlists-service.js"
 import TastytradeSession from "./models/tastytrade-session.js"
+import type Logger from "./logger.js"
+import { TastytradeLogger, LogLevel } from "./logger.js"
+import QuoteStreamer, { MarketDataSubscriptionType, CandleType } from "./quote-streamer.js"
+import type AccessToken from "./models/access-token.js"
+
+export type ClientConfig = {
+  baseUrl: string,
+  accountStreamerUrl: string,
+  clientSecret?: string,
+  refreshToken?: string,
+  oauthScopes?: string[],
+  logger?: Logger,
+  logLevel?: LogLevel
+  targetApiVersion?: string
+}
 
 export default class TastytradeClient {
+  public static readonly ProdConfig: ClientConfig = {
+    baseUrl: 'https://api.tastyworks.com',
+    accountStreamerUrl: 'wss://streamer.tastyworks.com',
+  }
+  public static readonly SandboxConfig: ClientConfig = {
+    baseUrl: 'https://api.cert.tastyworks.com',
+    accountStreamerUrl: 'wss://streamer.cert.tastyworks.com',
+  }
+  public readonly logger: TastytradeLogger
   public readonly httpClient: TastytradeHttpClient
 
   public readonly accountStreamer: AccountStreamer
+  public readonly quoteStreamer: QuoteStreamer
 
   public readonly sessionService: SessionService
   public readonly accountStatusService: AccountStatusService
@@ -37,9 +62,9 @@ export default class TastytradeClient {
   public readonly transactionsService: TransactionsService
   public readonly watchlistsService: WatchlistsService
 
-  constructor(readonly baseUrl: string, readonly accountStreamerUrl: string) {
-    this.httpClient = new TastytradeHttpClient(baseUrl)
-    this.accountStreamer = new AccountStreamer(accountStreamerUrl, this.session)
+  constructor(config: ClientConfig) {
+    this.logger = new TastytradeLogger(config.logger, config.logLevel)
+    this.httpClient = new TastytradeHttpClient(config, this.logger)
 
     this.sessionService = new SessionService(this.httpClient)
     this.accountStatusService = new AccountStatusService(this.httpClient)
@@ -54,12 +79,27 @@ export default class TastytradeClient {
     this.symbolSearchService = new SymbolSearchService(this.httpClient)
     this.transactionsService = new TransactionsService(this.httpClient)
     this.watchlistsService = new WatchlistsService(this.httpClient)
+
+
+    this.accountStreamer = new AccountStreamer(config.accountStreamerUrl, this.session, this.accessToken, this.logger)
+    this.quoteStreamer = new QuoteStreamer(this.accountsAndCustomersService, this.logger)
+  }
+
+  public updateConfig(config: Partial<ClientConfig>) {
+    this.httpClient.updateConfig(config)
+    this.logger.updateConfig(config)
   }
 
   get session(): TastytradeSession {
     return this.httpClient.session
   }
+
+  get accessToken(): AccessToken {
+    return this.httpClient.accessToken
+  }
 }
 
-export { MarketDataStreamer, MarketDataSubscriptionType, type MarketDataListener, type CandleSubscriptionOptions, CandleType }
+export { MarketDataSubscriptionType, CandleType }
 export { AccountStreamer, STREAMER_STATE, type Disposer, type StreamerStateObserver }
+export { TastytradeLogger, LogLevel }
+export type { Logger }

package/lib/utils/json-util.ts

@@ -20,11 +20,9 @@ export class JsonBuilder {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function recursiveDasherizeKeys(body: any) {
   let dasherized = _.mapKeys(body, (_value, key) => dasherize(key))
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   dasherized = _.mapValues(dasherized, (value: any) => {
     if (_.isPlainObject(value)) {
       return recursiveDasherizeKeys(value)

package/lib/utils/response-util.ts

@@ -1,12 +1,11 @@
 import _ from 'lodash'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function extractResponseData(httpResponse: any){
+export default function extractResponseData(httpResponse: any) {
   if (_.has(httpResponse, 'data.data.items')) {
     return _.get(httpResponse, 'data.data.items')
-  } else if (_.has(httpResponse, 'data.data')){
+  } else if (_.has(httpResponse, 'data.data')) {
     return _.get(httpResponse, 'data.data')
-  }else{
+  } else {
     return httpResponse
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tastytrade/api",
-  "version": "4.0.0",
+  "version": "6.0.0",
   "type": "module",
   "module": "dist/tastytrade-api.js",
   "types": "dist/tastytrade-api.d.ts",
@@ -15,37 +15,45 @@
     "npm": ">=9.0.0",
     "node": ">=20.0.0"
   },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "none"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "jest -i --restoreMocks",
     "unit-test": "node --experimental-vm-modules ./node_modules/.bin/jest tests/unit",
     "integration-test": "node --experimental-vm-modules ./node_modules/.bin/jest tests/integration",
     "lint": "eslint lib/** tests/**",
+    "format": "prettier --write .",
     "prepublishOnly": "npm run unit-test && npm run build",
     "postpack": "git tag -a $npm_package_version -m $npm_package_version && git push origin $npm_package_version"
   },
   "dependencies": {
-    "@types/lodash": "^4.14.182",
-    "@types/qs": "^6.9.7",
-    "axios": "^1.3.4",
+    "@dxfeed/dxlink-api": "^0.3.0",
+    "@types/lodash": "^4.17.16",
+    "@types/qs": "^6.9.18",
+    "axios": "^1.9.0",
     "isomorphic-ws": "^5.0.0",
     "lodash": "^4.17.21",
-    "qs": "^6.11.1",
-    "uuid": "^9.0.0",
-    "ws": "^8.13.0"
+    "qs": "^6.14.0",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.2"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.0",
-    "@types/node": "20.9.0",
-    "@types/uuid": "^9.0.2",
-    "@types/ws": "^8.5.9",
-    "@typescript-eslint/eslint-plugin": "^5.57.1",
-    "@typescript-eslint/parser": "^5.57.1",
-    "dotenv": "^16.0.3",
-    "eslint": "^8.14.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "22.15.14",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.32.0",
+    "@typescript-eslint/parser": "^8.32.0",
+    "dotenv": "^16.5.0",
+    "eslint": "^9.26.0",
     "jest": "^29.7.0",
-    "nock": "^13.5.4",
-    "ts-jest": "^29.1.2",
-    "typescript": "^5.4.2"
+    "nock": "^14.0.4",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.3.2",
+    "typescript": "^5.8.3"
   }
 }

package/tsconfig.json

@@ -41,14 +41,14 @@
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
 
     /* Module Resolution Options */
-    // "moduleResolution": "node",               /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    "moduleResolution": "nodenext",               /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
     // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    // "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
     // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
@@ -65,7 +65,7 @@
     /* Advanced Options */
     "skipLibCheck": true,                     /* Skip type checking of declaration files. */
     "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
-    "verbatimModuleSyntax": true,             /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "verbatimModuleSyntax": true,             /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
   },
   "include": ["lib/**/*"],
   "exclude": ["node_modules", "dist", "tests/**/*", "examples", ".env", ".env.sample"]