gingersnap 0.23.13 → 0.24.0

package/data/bus.cjs

@@ -37,7 +37,7 @@ class DataBus extends stream_observable.Observable {
      * @param bufferSize
      * @param expiryPeriod
      */
-    republish(topic, consumer, topicTransformer = (v) => v, bufferSize = undefined, expiryPeriod = undefined) {
+    republish(topic, consumer, topicTransformer = (v) => v, bufferSize = undefined, expiryPeriod) {
         return this.subscribe(topic, bufferSize, expiryPeriod)
             .map(({ topic: consumerTopic, data }) => this.publish(`${consumer}.${topicTransformer(consumerTopic)}`, data))
             .consume()

package/data/bus.d.ts

@@ -1,6 +1,7 @@
 import { Observable } from "../stream/observable";
-import { Future, WaitPeriod } from "../future";
+import { Future } from "../future";
 import { Stream } from "../stream";
+import { Duration } from "../data-structures/object";
 /**
  * A controller than manages exchanging data between various consumers
  */
@@ -21,7 +22,7 @@ export declare class DataBus<T = any> extends Observable<T> {
      * @param bufferSize
      * @param expiryPeriod
      */
-    republish(topic: string, consumer: string, topicTransformer?: (v: string) => string, bufferSize?: number | undefined, expiryPeriod?: WaitPeriod | undefined): Future<void>;
+    republish(topic: string, consumer: string, topicTransformer?: (v: string) => string, bufferSize?: number | undefined, expiryPeriod?: Duration): Future<void>;
     /**
      * Dispatches message to specific consumers listen on the given topic
      * Format is [consumer/s].[topic]
@@ -45,7 +46,7 @@ export declare class DataBus<T = any> extends Observable<T> {
      * @param bufferSize
      * @param expiryPeriod
      */
-    subscribe(topic: string | RegExp, bufferSize?: number, expiryPeriod?: WaitPeriod): Stream<{
+    subscribe(topic: string | RegExp, bufferSize?: number, expiryPeriod?: Duration): Stream<{
         topic: string;
         data: T;
     }>;

package/data/bus.mjs

@@ -35,7 +35,7 @@ class DataBus extends Observable {
      * @param bufferSize
      * @param expiryPeriod
      */
-    republish(topic, consumer, topicTransformer = (v) => v, bufferSize = undefined, expiryPeriod = undefined) {
+    republish(topic, consumer, topicTransformer = (v) => v, bufferSize = undefined, expiryPeriod) {
         return this.subscribe(topic, bufferSize, expiryPeriod)
             .map(({ topic: consumerTopic, data }) => this.publish(`${consumer}.${topicTransformer(consumerTopic)}`, data))
             .consume()

package/data/model/extra.d.ts

@@ -1,5 +1,5 @@
 import { Model } from "./model";
 type UnionParserOptions = "json" | "string" | "blob" | "buffer";
 export declare const View: (modelClass: typeof Model, path: Array<string | number>, option: UnionParserOptions) => (data: any, ...otherArgs: any[]) => any;
-export declare const Union: (modelClasses: Array<typeof Model>, option: UnionParserOptions) => (data: any, ...otherArgs: any[]) => Model | Model[] | Promise<Model | Model[]>;
+export declare const Union: (modelClasses: Array<typeof Model>, option: UnionParserOptions) => (data: any, ...otherArgs: any[]) => Model | Promise<Model>;
 export {};

package/data/signal.d.ts

@@ -1,6 +1,5 @@
 import { Stream } from "../stream";
-import { WaitPeriod } from "../future";
-import { Queue } from "../data-structures/object";
+import { Duration, Queue } from "../data-structures/object";
 export interface Token {
     cancel: () => void;
 }
@@ -13,5 +12,5 @@ export declare class Signal<T> {
     start(): void;
     stop(): void;
     subscribe(callback: (value: T) => void): Token;
-    stream(objectMaxSize?: number, expiryPeriod?: WaitPeriod): Stream<T>;
+    stream(objectMaxSize?: number, expiryPeriod?: Duration): Stream<T>;
 }

package/data/store/manager.cjs

@@ -6,6 +6,7 @@ require('object-hash');
 require('ramda');
 var stream = require('../../stream.cjs');
 var future = require('../../future/future.cjs');
+var Time = require('../../data-structures/object/Time.cjs');
 require('uuid');
 var Pair = require('../../data-structures/array/Pair.cjs');
 var model = require('../model/model.cjs');
@@ -73,12 +74,12 @@ class Cache {
                     .thenApply(({ value, signal }) => _tslib.__awaiter(this, void 0, void 0, function* () {
                     if (value) {
                         if (this.expiryPeriod) {
-                            const remainingTime = Date.now() - value.lastModifiedOn - future.calculatePeriodValue(this.expiryPeriod);
+                            const remainingTime = Date.now() - value.lastModifiedOn - this.expiryPeriod.inWholeMilliseconds();
                             if (remainingTime <= 0) {
                                 yield this.persistStore.remove(transformedKey).registerSignal(signal);
                                 return;
                             }
-                            this.memStore.set(key, value.value, { milliseconds: remainingTime });
+                            this.memStore.set(key, value.value, Time.milliseconds(remainingTime));
                         }
                         else {
                             this.memStore.set(key, value.value);

package/data/store/manager.d.ts

@@ -1,4 +1,5 @@
-import { Future, WaitPeriod } from "../../future";
+import { Duration } from "../../data-structures/object";
+import { Future } from "../../future";
 import { Pair } from "../../data-structures/array";
 import { Stream } from "../../stream";
 export interface PersistenceStore {
@@ -17,7 +18,7 @@ export declare class Cache<T, K> implements AsyncIterable<Pair<T, K>> {
     private readonly encode;
     private readonly persistStore?;
     private readonly expiryPeriod?;
-    constructor(decode: (v: string) => K, encode: (v: K) => string | Future<string> | Promise<string>, persistStore?: PersistenceStore, maxSize?: number, expiryPeriod?: WaitPeriod);
+    constructor(decode: (v: string) => K, encode: (v: K) => string | Future<string> | Promise<string>, persistStore?: PersistenceStore, maxSize?: number, expiryPeriod?: Duration);
     private readonly memStore;
     get(key: T): Future<K | undefined>;
     getSync(key: T): K;
@@ -37,8 +38,8 @@ export declare class CacheManager {
     private readonly maxSize?;
     private readonly expiryPeriod?;
     private readonly memStores;
-    constructor(persistStore?: PersistenceStore, maxSize?: number, expiryPeriod?: WaitPeriod);
-    createCache<T, K>(name: string, persist: boolean, encoder?: (v: K) => string | Future<string> | Promise<string>, decoder?: (v: string) => K, maxSize?: number, expiryPeriod?: WaitPeriod): Cache<T, K>;
+    constructor(persistStore?: PersistenceStore, maxSize?: number, expiryPeriod?: Duration);
+    createCache<T, K>(name: string, persist: boolean, encoder?: (v: K) => string | Future<string> | Promise<string>, decoder?: (v: string) => K, maxSize?: number, expiryPeriod?: Duration): Cache<T, K>;
     getCache<T, K>(name: string): Cache<T, K>;
     removeCache(name: string): void;
 }

package/data/store/manager.mjs

@@ -3,7 +3,8 @@ import { WatchableObject } from '../../data-structures/object/WatchableObject.mj
 import 'object-hash';
 import 'ramda';
 import { Stream } from '../../stream.mjs';
-import { Future, calculatePeriodValue } from '../../future/future.mjs';
+import { Future } from '../../future/future.mjs';
+import { milliseconds } from '../../data-structures/object/Time.mjs';
 import 'uuid';
 import { pair } from '../../data-structures/array/Pair.mjs';
 import { Model } from '../model/model.mjs';
@@ -71,12 +72,12 @@ class Cache {
                     .thenApply(({ value, signal }) => __awaiter(this, void 0, void 0, function* () {
                     if (value) {
                         if (this.expiryPeriod) {
-                            const remainingTime = Date.now() - value.lastModifiedOn - calculatePeriodValue(this.expiryPeriod);
+                            const remainingTime = Date.now() - value.lastModifiedOn - this.expiryPeriod.inWholeMilliseconds();
                             if (remainingTime <= 0) {
                                 yield this.persistStore.remove(transformedKey).registerSignal(signal);
                                 return;
                             }
-                            this.memStore.set(key, value.value, { milliseconds: remainingTime });
+                            this.memStore.set(key, value.value, milliseconds(remainingTime));
                         }
                         else {
                             this.memStore.set(key, value.value);

package/data-structures/object/BufferQueue.d.ts

@@ -1,6 +1,7 @@
 import { WatchableObject } from "./WatchableObject";
-import { Future, WaitPeriod } from "../../future";
+import { Future } from "../../future";
 import { Stream } from "../../stream";
+import { Duration } from "./Time";
 /**
  * Queue data structure that is iterable, but never can dequeue
  */
@@ -8,7 +9,7 @@ export declare class BufferQueue<T> extends WatchableObject<number, T> {
     private tail;
     private head;
     private readonly tracker;
-    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    constructor(objectMaxSize?: number, expiryPeriod?: Duration);
     ingest(stream: Stream<T>): Future<void>;
     streamEntries(ignoreCache?: boolean): Stream<T>;
     flushableStream(ignoreCache?: boolean): Stream<{

package/data-structures/object/Queue.d.ts

@@ -1,7 +1,8 @@
 import { WatchableObject } from "./WatchableObject";
-import { Future, WaitPeriod } from "../../future";
+import { Future } from "../../future";
 import { Stream } from "../../stream";
 import { Publisher } from "./Publisher";
+import { Duration } from "./Time";
 /**
  * Queue data structure for First In First Out operation (FIFO)
  */
@@ -11,7 +12,7 @@ export declare class Queue<T> extends WatchableObject<number, T> implements Iter
     private closedSignal;
     private closed;
     private readonly dequeueEvt;
-    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    constructor(objectMaxSize?: number, expiryPeriod?: Duration);
     get streamEntries(): Stream<T>;
     /**
      * A stream where data is only removed from the queue once the terminal action of the stream is finished with the data.

package/data-structures/object/Time.cjs

@@ -0,0 +1,195 @@
+'use strict';
+
+const milliseconds = function (value) {
+    return new Duration(value);
+};
+const seconds = function (value) {
+    return new Duration(value * 1000);
+};
+const minutes = function (value) {
+    return new Duration(value * 60000);
+};
+const hours = function (value) {
+    return new Duration(value * 3.6e6);
+};
+const days = function (value) {
+    return new Duration(value * 8.64e7);
+};
+const months = function (value) {
+    return new Duration(value * 2.6298e9);
+};
+const years = function (value) {
+    return new Duration(value * 3.15576e10);
+};
+class Duration {
+    constructor(valueInMilli) {
+        this.valueInMilli = valueInMilli;
+    }
+    get isPositive() {
+        return this.valueInMilli > 0;
+    }
+    get isNegative() {
+        return this.valueInMilli < 0;
+    }
+    get days() {
+        return this.inWholeDays();
+    }
+    get hours() {
+        return this.inWholeHours();
+    }
+    get minutes() {
+        return this.inWholeMinutes();
+    }
+    get seconds() {
+        return this.inWholeSeconds();
+    }
+    get milliseconds() {
+        return this.inWholeMilliseconds();
+    }
+    inWholeDays() {
+        return Math.trunc(this.valueInMilli / 8.64e7);
+    }
+    inWholeHours() {
+        return Math.trunc(this.valueInMilli / 3.6e6);
+    }
+    inWholeMinutes() {
+        return Math.trunc(this.valueInMilli / 60000);
+    }
+    inWholeSeconds() {
+        return Math.trunc(this.valueInMilli / 1000);
+    }
+    inWholeMilliseconds() {
+        return Math.trunc(this.valueInMilli);
+    }
+    plus(other) {
+        return new Duration(this.valueInMilli + other.valueInMilli);
+    }
+    minus(other) {
+        return new Duration(this.valueInMilli - other.valueInMilli);
+    }
+    times(other) {
+        return new Duration(this.valueInMilli * (other instanceof Duration ? other.valueInMilli : other));
+    }
+    div(other) {
+        return new Duration(this.valueInMilli / (other instanceof Duration ? other.valueInMilli : other));
+    }
+    equals(other) {
+        return other.valueInMilli === this.valueInMilli;
+    }
+    gt(other) {
+        return this.valueInMilli > other.valueInMilli;
+    }
+    gte(other) {
+        return this.valueInMilli >= other.valueInMilli;
+    }
+    lt(other) {
+        return this.valueInMilli < other.valueInMilli;
+    }
+    lte(other) {
+        return this.valueInMilli <= other.valueInMilli;
+    }
+    valueOf() {
+        return this.inWholeMilliseconds();
+    }
+    toString() {
+        let value = this.valueInMilli;
+        const years = Math.trunc(value / 3.15576e10);
+        value %= 3.15576e10;
+        const months = Math.trunc(value / 2.6298e9);
+        value %= 2.6298e9;
+        const days = Math.trunc(value / 8.64e7);
+        value %= 8.64e7;
+        const hours = Math.trunc(value / 3.6e6);
+        value %= 3.6e6;
+        const minutes = Math.trunc(value / 60000);
+        value %= 60000;
+        const seconds = value / 1000;
+        let result = "P";
+        if (years)
+            result += `${years}Y`;
+        if (months)
+            result += `${months}M`;
+        if (days) {
+            if (years && !months) {
+                result += `0M${days}D`;
+            }
+            else {
+                result += `${days}D`;
+            }
+        }
+        result += `T`;
+        if (hours)
+            result += `${hours}H`;
+        if (minutes)
+            result += `${minutes}M`;
+        if (seconds) {
+            if (hours && !minutes) {
+                result += `0M${seconds}S`;
+            }
+        }
+        return result;
+    }
+}
+class Instant {
+    constructor(epochMilliValue) {
+        this.epochMilliValue = epochMilliValue;
+    }
+    static get DISTANT_FUTURE() {
+        return Instant.now().plus(years(100000));
+    }
+    static get DISTANT_PAST() {
+        return Instant.now().minus(years(100000));
+    }
+    static now() {
+        return new Instant(new Date().getTime());
+    }
+    get isDistantFuture() {
+        return this.minus(Instant.now()).gte(years(100000));
+    }
+    get isDistantPast() {
+        return Instant.now().minus(this).gte(years(100000));
+    }
+    get epochSeconds() {
+        return this.toEpochSeconds();
+    }
+    get epochMilliseconds() {
+        return this.toEpochMilliseconds();
+    }
+    get duration() {
+        return milliseconds(this.epochMilliValue);
+    }
+    plus(other) {
+        return new Instant(this.epochMilliValue + other.milliseconds);
+    }
+    minus(other) {
+        if (other instanceof Instant) {
+            return this.duration.minus(other.duration);
+        }
+        return new Instant(this.epochMilliValue - other.milliseconds);
+    }
+    toEpochMilliseconds() {
+        return this.epochMilliValue;
+    }
+    toEpochSeconds() {
+        return Math.trunc(this.epochMilliValue / 1000);
+    }
+    toString() {
+        return this.toDate().toISOString();
+    }
+    toDate() {
+        return new Date(this.epochMilliValue);
+    }
+    equals(other) {
+        return this.epochMilliValue === other.epochMilliValue;
+    }
+}
+
+exports.Duration = Duration;
+exports.Instant = Instant;
+exports.days = days;
+exports.hours = hours;
+exports.milliseconds = milliseconds;
+exports.minutes = minutes;
+exports.months = months;
+exports.seconds = seconds;
+exports.years = years;

package/data-structures/object/Time.d.ts

@@ -0,0 +1,56 @@
+export declare const milliseconds: (value: number) => Duration;
+export declare const seconds: (value: number) => Duration;
+export declare const minutes: (value: number) => Duration;
+export declare const hours: (value: number) => Duration;
+export declare const days: (value: number) => Duration;
+export declare const months: (value: number) => Duration;
+export declare const years: (value: number) => Duration;
+export declare class Duration {
+    private readonly valueInMilli;
+    constructor(valueInMilli: number);
+    get isPositive(): boolean;
+    get isNegative(): boolean;
+    get days(): number;
+    get hours(): number;
+    get minutes(): number;
+    get seconds(): number;
+    get milliseconds(): number;
+    inWholeDays(): number;
+    inWholeHours(): number;
+    inWholeMinutes(): number;
+    inWholeSeconds(): number;
+    inWholeMilliseconds(): number;
+    plus(other: Duration): Duration;
+    minus(other: Duration): Duration;
+    times(other: Duration): Duration;
+    times(other: number): Duration;
+    div(other: Duration): Duration;
+    div(other: number): Duration;
+    equals(other: Duration): boolean;
+    gt(other: Duration): boolean;
+    gte(other: Duration): boolean;
+    lt(other: Duration): boolean;
+    lte(other: Duration): boolean;
+    valueOf(): number;
+    toString(): string;
+}
+export declare class Instant {
+    private readonly epochMilliValue;
+    constructor(epochMilliValue: number);
+    static get DISTANT_FUTURE(): Instant;
+    static get DISTANT_PAST(): Instant;
+    static now(): Instant;
+    get isDistantFuture(): boolean;
+    get isDistantPast(): boolean;
+    get epochSeconds(): number;
+    get epochMilliseconds(): number;
+    get duration(): Duration;
+    plus(other: Duration): Instant;
+    minus(other: Instant): Duration;
+    minus(other: Duration): Instant;
+    toEpochMilliseconds(): number;
+    toEpochSeconds(): number;
+    toString(): string;
+    toDate(): Date;
+    equals(other: Instant): boolean;
+}

package/data-structures/object/Time.mjs

@@ -0,0 +1,185 @@
+const milliseconds = function (value) {
+    return new Duration(value);
+};
+const seconds = function (value) {
+    return new Duration(value * 1000);
+};
+const minutes = function (value) {
+    return new Duration(value * 60000);
+};
+const hours = function (value) {
+    return new Duration(value * 3.6e6);
+};
+const days = function (value) {
+    return new Duration(value * 8.64e7);
+};
+const months = function (value) {
+    return new Duration(value * 2.6298e9);
+};
+const years = function (value) {
+    return new Duration(value * 3.15576e10);
+};
+class Duration {
+    constructor(valueInMilli) {
+        this.valueInMilli = valueInMilli;
+    }
+    get isPositive() {
+        return this.valueInMilli > 0;
+    }
+    get isNegative() {
+        return this.valueInMilli < 0;
+    }
+    get days() {
+        return this.inWholeDays();
+    }
+    get hours() {
+        return this.inWholeHours();
+    }
+    get minutes() {
+        return this.inWholeMinutes();
+    }
+    get seconds() {
+        return this.inWholeSeconds();
+    }
+    get milliseconds() {
+        return this.inWholeMilliseconds();
+    }
+    inWholeDays() {
+        return Math.trunc(this.valueInMilli / 8.64e7);
+    }
+    inWholeHours() {
+        return Math.trunc(this.valueInMilli / 3.6e6);
+    }
+    inWholeMinutes() {
+        return Math.trunc(this.valueInMilli / 60000);
+    }
+    inWholeSeconds() {
+        return Math.trunc(this.valueInMilli / 1000);
+    }
+    inWholeMilliseconds() {
+        return Math.trunc(this.valueInMilli);
+    }
+    plus(other) {
+        return new Duration(this.valueInMilli + other.valueInMilli);
+    }
+    minus(other) {
+        return new Duration(this.valueInMilli - other.valueInMilli);
+    }
+    times(other) {
+        return new Duration(this.valueInMilli * (other instanceof Duration ? other.valueInMilli : other));
+    }
+    div(other) {
+        return new Duration(this.valueInMilli / (other instanceof Duration ? other.valueInMilli : other));
+    }
+    equals(other) {
+        return other.valueInMilli === this.valueInMilli;
+    }
+    gt(other) {
+        return this.valueInMilli > other.valueInMilli;
+    }
+    gte(other) {
+        return this.valueInMilli >= other.valueInMilli;
+    }
+    lt(other) {
+        return this.valueInMilli < other.valueInMilli;
+    }
+    lte(other) {
+        return this.valueInMilli <= other.valueInMilli;
+    }
+    valueOf() {
+        return this.inWholeMilliseconds();
+    }
+    toString() {
+        let value = this.valueInMilli;
+        const years = Math.trunc(value / 3.15576e10);
+        value %= 3.15576e10;
+        const months = Math.trunc(value / 2.6298e9);
+        value %= 2.6298e9;
+        const days = Math.trunc(value / 8.64e7);
+        value %= 8.64e7;
+        const hours = Math.trunc(value / 3.6e6);
+        value %= 3.6e6;
+        const minutes = Math.trunc(value / 60000);
+        value %= 60000;
+        const seconds = value / 1000;
+        let result = "P";
+        if (years)
+            result += `${years}Y`;
+        if (months)
+            result += `${months}M`;
+        if (days) {
+            if (years && !months) {
+                result += `0M${days}D`;
+            }
+            else {
+                result += `${days}D`;
+            }
+        }
+        result += `T`;
+        if (hours)
+            result += `${hours}H`;
+        if (minutes)
+            result += `${minutes}M`;
+        if (seconds) {
+            if (hours && !minutes) {
+                result += `0M${seconds}S`;
+            }
+        }
+        return result;
+    }
+}
+class Instant {
+    constructor(epochMilliValue) {
+        this.epochMilliValue = epochMilliValue;
+    }
+    static get DISTANT_FUTURE() {
+        return Instant.now().plus(years(100000));
+    }
+    static get DISTANT_PAST() {
+        return Instant.now().minus(years(100000));
+    }
+    static now() {
+        return new Instant(new Date().getTime());
+    }
+    get isDistantFuture() {
+        return this.minus(Instant.now()).gte(years(100000));
+    }
+    get isDistantPast() {
+        return Instant.now().minus(this).gte(years(100000));
+    }
+    get epochSeconds() {
+        return this.toEpochSeconds();
+    }
+    get epochMilliseconds() {
+        return this.toEpochMilliseconds();
+    }
+    get duration() {
+        return milliseconds(this.epochMilliValue);
+    }
+    plus(other) {
+        return new Instant(this.epochMilliValue + other.milliseconds);
+    }
+    minus(other) {
+        if (other instanceof Instant) {
+            return this.duration.minus(other.duration);
+        }
+        return new Instant(this.epochMilliValue - other.milliseconds);
+    }
+    toEpochMilliseconds() {
+        return this.epochMilliValue;
+    }
+    toEpochSeconds() {
+        return Math.trunc(this.epochMilliValue / 1000);
+    }
+    toString() {
+        return this.toDate().toISOString();
+    }
+    toDate() {
+        return new Date(this.epochMilliValue);
+    }
+    equals(other) {
+        return this.epochMilliValue === other.epochMilliValue;
+    }
+}
+
+export { Duration, Instant, days, hours, milliseconds, minutes, months, seconds, years };

package/data-structures/object/TimeableObject.cjs

@@ -5,6 +5,7 @@ var CyclicalObject = require('./CyclicalObject.cjs');
 var future = require('../../future/future.cjs');
 require('ramda');
 require('../../stream.cjs');
+var Time = require('./Time.cjs');
 
 /**
  * Object that has key value pairs that can expire
@@ -28,7 +29,7 @@ class TimeableObject extends CyclicalObject.CyclicalObject {
         timer === null || timer === void 0 ? void 0 : timer.cancel();
         super.set(key, value);
         if (expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod) {
-            this.timers.set(hashedKey, future.Future.sleep((_a = expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod) !== null && _a !== void 0 ? _a : 0)
+            this.timers.set(hashedKey, future.Future.sleep((_a = expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod) !== null && _a !== void 0 ? _a : Time.seconds(0))
                 .thenApply(() => this.delete(key))
                 .schedule());
         }
@@ -41,7 +42,7 @@ class TimeableObject extends CyclicalObject.CyclicalObject {
                 const hashedKey = this.computeHash(key);
                 const timer = this.timers.get(hashedKey);
                 timer === null || timer === void 0 ? void 0 : timer.cancel();
-                this.timers.set(hashedKey, future.Future.sleep((_a = this.expiryPeriod) !== null && _a !== void 0 ? _a : 0)
+                this.timers.set(hashedKey, future.Future.sleep((_a = this.expiryPeriod) !== null && _a !== void 0 ? _a : Time.seconds(0))
                     .thenApply(() => this.delete(key))
                     .schedule());
             }

package/data-structures/object/TimeableObject.d.ts

@@ -1,5 +1,5 @@
 import { CyclicalObject } from "./CyclicalObject";
-import { WaitPeriod } from "../../future";
+import { Duration } from "./Time";
 /**
  * Object that has key value pairs that can expire
  */
@@ -8,20 +8,20 @@ export declare class TimeableObject<T, K> extends CyclicalObject<T, K> {
      * default expiration time for each added key value pair
      * @private
      */
-    protected expiryPeriod?: WaitPeriod;
+    protected expiryPeriod?: Duration;
     /**
      * mapping of timings for each key value pair
      * @private
      */
     private readonly timers;
-    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    constructor(objectMaxSize?: number, expiryPeriod?: Duration);
     /**
      * Sets the value for the given key
      * @param key
      * @param value dat to be stored
      * @param expiryPeriod When should this value expire
      */
-    set(key: T, value: K, expiryPeriod?: WaitPeriod): void;
+    set(key: T, value: K, expiryPeriod?: Duration): void;
     get(key: T, defaultValue?: K | undefined): K | undefined;
     delete(key: T): void;
     clear(): void;