From b3d5863f355edb0974c719e4329a923286dededc Mon Sep 17 00:00:00 2001
From: Jaime Leonardo Suncin Cruz <leosuncin@gmail.com>
Date: Wed, 18 May 2022 17:37:18 -0600
Subject: [PATCH] fix: amend typescript definition

Closes kartikk221/cached-lookup#2
---
 types/index.d.ts | 45 ++++++++++++++++++++++-----------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/types/index.d.ts b/types/index.d.ts
index be58d52..afe6a8a 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -1,69 +1,68 @@
-type LookupHandler<T extends any> = () => T | Promise<T>
+type LookupHandler<T extends unknown> = () => T | Promise<T>;
 type SupportedTypes = string | number | boolean;
-type SupportedArgumentTypes = SupportedTypes | SupportedTypes[];
 
-interface ValueRecord {
-    value: T,
-    updated_at: number
-};
+interface ValueRecord<T = unknown> {
+    value: T;
+    updated_at: number;
+}
 
-export default class CachedLookup<T extends any> {
+export default class CachedLookup<T extends unknown> {
     /**
      * Creates a new CachedLookup instance with the specified lookup function.
      * The lookup function can be both synchronous or asynchronous.
      *
-     * @param {function(...(SupportedArgumentTypes|Array<SupportedArgumentTypes>)):T} lookup
+     * @param {LookupHandler<T>} lookup
      */
-    constructor(lookup: LookupHandler<T>)
+    constructor(lookup: LookupHandler<T>);
 
     /**
      * Returns a cached value that is up to max_age milliseconds old for the provided set of arguments.
      * Falls back to a fresh value if the cache value is older than max_age.
-     * 
+     *
      * @param {Number} max_age In Milliseconds
-     * @param {...(SupportedArgumentTypes)} args
+     * @param {Array<SupportedTypes>} args
      * @returns {Promise<T>}
      */
-    cached(max_age: number, ...args: SupportedArgumentTypes): Promise<T>;
+    cached(max_age: number, ...args: SupportedTypes[]): Promise<T>;
 
     /**
      * Returns a fresh value and automatically updates the internal cache with this value for the provided set of arguments.
      *
-     * @param {...(SupportedArgumentTypes)} args
+     * @param {Array<SupportedTypes>} args
      * @returns {Promise<T>}
      */
-    fresh(...args: SupportedArgumentTypes): Promise<T>;
+    fresh(...args: SupportedTypes[]): Promise<T>;
 
     /**
      * Expires the cached value for the provided set of arguments.
      *
-     * @param {...(SupportedArgumentTypes)} args
+     * @param {Array<SupportedTypes>} args
      * @returns {Boolean} True if the cache value was expired, false otherwise.
      */
-    expire(...args: SupportedArgumentTypes): bool;
+    expire(...args: SupportedTypes[]): boolean;
 
     /**
      * Returns whether a fresh value is currently being resolved for the provided set of arguments.
      *
-     * @param {...(SupportedArgumentTypes)} args
+     * @param {Array<SupportedTypes>} args
      * @returns {Boolean}
      */
-    in_flight(...args: SupportedArgumentTypes): bool;
+    in_flight(...args: SupportedTypes[]): boolean;
 
     /**
      * Returns the last value update timestamp in milliseconds for the provided set of arguments.
      *
-     * @param {...(SupportedArgumentTypes)} args
+     * @param {Array<SupportedTypes>} args
      * @returns {Boolean}
      */
-    updated_at(...args: SupportedArgumentTypes): number | void;
+    updated_at(...args: SupportedTypes[]): number | void;
 
     /* CachedLookup Getters */
 
     /**
      * Returns the underlying cache object which contains the cached values identified by their serialized arguments.
      *
-     * @returns {Map<String, ValueRecord>}
+     * @returns {Map<String, ValueRecord<T>>}
      */
-    get cache(): Map<string, ValueRecord>;
-}
\ No newline at end of file
+    get cache(): Map<string, ValueRecord<T>>;
+}