harperdb 4.5.7 → 4.6.0-alpha.1

package/resources/analytics/hostnames.d.ts

@@ -0,0 +1,483 @@
+export declare const nodeIds: Map<string, number>;
+export declare function getAnalyticsHostnameTable(): {
+    new (identifier: import("../ResourceInterface.js").Id, source: any): {
+        "__#5@#record": any;
+        "__#5@#changes": any;
+        "__#5@#version": number;
+        "__#5@#entry": {
+            key: any;
+            value: any;
+            version: number;
+            localTime: number;
+            expiresAt: number;
+            deref?: () => any;
+        };
+        "__#5@#saveMode": boolean;
+        "__#5@#loadedFromSource": boolean;
+        ensureLoaded(): any;
+        get(query?: import("../ResourceInterface.js").Query | string): Promise<object | void> | object | void;
+        allowRead(user: any, query: any): any;
+        allowUpdate(user: any, updatedData: any): boolean;
+        allowCreate(user: any, newData: {}): boolean;
+        allowDelete(user: any): boolean;
+        update(updates?: any, fullUpdate?: boolean): /*elided*/ any;
+        addTo(property: any, value: any): void;
+        subtractFrom(property: any, value: any): void;
+        getMetadata(): {
+            key: any;
+            value: any;
+            version: number;
+            localTime: number;
+            expiresAt: number;
+            deref?: () => any;
+        };
+        getRecord(): any;
+        getChanges(): any;
+        _setChanges(changes: any): void;
+        setRecord(record: any): void;
+        invalidate(): void;
+        _writeInvalidate(partialRecord?: any, options?: any): void;
+        _writeRelocate(options: any): void;
+        lock(): void;
+        put(record: any): void;
+        patch(recordUpdate: any): void;
+        _writeUpdate(recordUpdate: any, fullUpdate: boolean, options?: any): void;
+        delete(request?: import("../ResourceInterface.js").Query | string): Promise<boolean>;
+        _writeDelete(options?: any): boolean;
+        search(request: import("../ResourceInterface.js").Query): AsyncIterable<any>;
+        subscribe(request: import("../ResourceInterface.js").SubscriptionRequest): Promise<{
+            listener: (key: any) => any;
+            subscriptions: [];
+            startTime?: number;
+            end(): void;
+            toJSON(): {
+                name: string;
+            };
+            resolveNext: Function;
+            queue: any[];
+            hasDataListeners: boolean;
+            drainCloseListener: boolean;
+            currentDrainResolver: Function;
+            push(message: any): void;
+            send(message: any): void;
+            getNextMessage(): any;
+            waitForDrain(): Promise<boolean>;
+            on(eventName: any, listener: any): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                queue: import("../IterableEventQueue.js").IterableEventQueue;
+                push(message: any): void;
+                next(): Promise<unknown> | {
+                    value: any;
+                };
+                return(value: any): {
+                    value: any;
+                    done: boolean;
+                };
+                throw(error: any): {
+                    done: boolean;
+                };
+            };
+            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+            addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            off<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            removeAllListeners(eventName?: string | symbol): /*elided*/ any;
+            setMaxListeners(n: number): /*elided*/ any;
+            getMaxListeners(): number;
+            listeners<K>(eventName: string | symbol): Function[];
+            rawListeners<K>(eventName: string | symbol): Function[];
+            emit<K>(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<K>(eventName: string | symbol, listener?: Function): number;
+            prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            eventNames(): (string | symbol)[];
+        }>;
+        doesExist(): boolean;
+        publish(message: any, options?: any): void;
+        _writePublish(message: any, options?: any): void;
+        validate(record: any, patch?: any): void;
+        getUpdatedTime(): number;
+        wasLoadedFromSource(): boolean | void;
+        readonly "__#6@#id": import("../ResourceInterface.js").Id;
+        readonly "__#6@#context": import("../ResourceInterface.js").Context;
+        "__#6@#isCollection": boolean;
+        post(newRecord: any): Promise<any>;
+        readonly isCollection: boolean;
+        connect(query?: {}): AsyncIterable<any>;
+        getId(): import("../ResourceInterface.js").Id;
+        getContext(): import("../ResourceInterface.js").Context;
+    };
+    name: any;
+    primaryStore: any;
+    auditStore: any;
+    primaryKey: any;
+    tableName: any;
+    tableId: any;
+    indices: any;
+    audit: any;
+    databasePath: any;
+    databaseName: any;
+    attributes: any;
+    replicate: any;
+    sealed: any;
+    splitSegments: any;
+    createdTimeProperty: {
+        name: string;
+        type: string;
+        assignCreatedTime?: boolean;
+        assignUpdatedTime?: boolean;
+        expiresAt?: boolean;
+        isPrimaryKey?: boolean;
+    };
+    updatedTimeProperty: {
+        name: string;
+        type: string;
+        assignCreatedTime?: boolean;
+        assignUpdatedTime?: boolean;
+        expiresAt?: boolean;
+        isPrimaryKey?: boolean;
+    };
+    propertyResolvers: any;
+    userResolvers: {};
+    sources: any[];
+    getResidencyById: (id: import("../ResourceInterface.js").Id) => number | void;
+    readonly expirationMS: any;
+    dbisDB: any;
+    schemaDefined: any;
+    sourcedFrom(source: any, options: any): /*elided*/ any;
+    readonly isCaching: any;
+    readonly shouldRevalidateEvents: boolean;
+    getResource(id: import("../ResourceInterface.js").Id, request: import("../ResourceInterface.js").Context, resourceOptions?: any): Promise<{
+        "__#5@#record": any;
+        "__#5@#changes": any;
+        "__#5@#version": number;
+        "__#5@#entry": {
+            key: any;
+            value: any;
+            version: number;
+            localTime: number;
+            expiresAt: number;
+            deref?: () => any;
+        };
+        "__#5@#saveMode": boolean;
+        "__#5@#loadedFromSource": boolean;
+        ensureLoaded(): any;
+        get(query?: import("../ResourceInterface.js").Query | string): Promise<object | void> | object | void;
+        allowRead(user: any, query: any): any;
+        allowUpdate(user: any, updatedData: any): boolean;
+        allowCreate(user: any, newData: {}): boolean;
+        allowDelete(user: any): boolean;
+        update(updates?: any, fullUpdate?: boolean): /*elided*/ any;
+        addTo(property: any, value: any): void;
+        subtractFrom(property: any, value: any): void;
+        getMetadata(): {
+            key: any;
+            value: any;
+            version: number;
+            localTime: number;
+            expiresAt: number;
+            deref?: () => any;
+        };
+        getRecord(): any;
+        getChanges(): any;
+        _setChanges(changes: any): void;
+        setRecord(record: any): void;
+        invalidate(): void;
+        _writeInvalidate(partialRecord?: any, options?: any): void;
+        _writeRelocate(options: any): void;
+        lock(): void;
+        put(record: any): void;
+        patch(recordUpdate: any): void;
+        _writeUpdate(recordUpdate: any, fullUpdate: boolean, options?: any): void;
+        delete(request?: import("../ResourceInterface.js").Query | string): Promise<boolean>;
+        _writeDelete(options?: any): boolean;
+        search(request: import("../ResourceInterface.js").Query): AsyncIterable<any>;
+        subscribe(request: import("../ResourceInterface.js").SubscriptionRequest): Promise<{
+            listener: (key: any) => any;
+            subscriptions: [];
+            startTime?: number;
+            end(): void;
+            toJSON(): {
+                name: string;
+            };
+            resolveNext: Function;
+            queue: any[];
+            hasDataListeners: boolean;
+            drainCloseListener: boolean;
+            currentDrainResolver: Function;
+            push(message: any): void;
+            send(message: any): void;
+            getNextMessage(): any;
+            waitForDrain(): Promise<boolean>;
+            on(eventName: any, listener: any): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                queue: import("../IterableEventQueue.js").IterableEventQueue;
+                push(message: any): void;
+                next(): Promise<unknown> | {
+                    value: any;
+                };
+                return(value: any): {
+                    value: any;
+                    done: boolean;
+                };
+                throw(error: any): {
+                    done: boolean;
+                };
+            };
+            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+            addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            off<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            removeAllListeners(eventName?: string | symbol): /*elided*/ any;
+            setMaxListeners(n: number): /*elided*/ any;
+            getMaxListeners(): number;
+            listeners<K>(eventName: string | symbol): Function[];
+            rawListeners<K>(eventName: string | symbol): Function[];
+            emit<K>(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<K>(eventName: string | symbol, listener?: Function): number;
+            prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            eventNames(): (string | symbol)[];
+        }>;
+        doesExist(): boolean;
+        publish(message: any, options?: any): void;
+        _writePublish(message: any, options?: any): void;
+        validate(record: any, patch?: any): void;
+        getUpdatedTime(): number;
+        wasLoadedFromSource(): boolean | void;
+        readonly "__#6@#id": import("../ResourceInterface.js").Id;
+        readonly "__#6@#context": import("../ResourceInterface.js").Context;
+        "__#6@#isCollection": boolean;
+        post(newRecord: any): Promise<any>;
+        readonly isCollection: boolean;
+        connect(query?: {}): AsyncIterable<any>;
+        getId(): import("../ResourceInterface.js").Id;
+        getContext(): import("../ResourceInterface.js").Context;
+    }> | {
+        "__#5@#record": any;
+        "__#5@#changes": any;
+        "__#5@#version": number;
+        "__#5@#entry": {
+            key: any;
+            value: any;
+            version: number;
+            localTime: number;
+            expiresAt: number;
+            deref?: () => any;
+        };
+        "__#5@#saveMode": boolean;
+        "__#5@#loadedFromSource": boolean;
+        ensureLoaded(): any;
+        get(query?: import("../ResourceInterface.js").Query | string): Promise<object | void> | object | void;
+        allowRead(user: any, query: any): any;
+        allowUpdate(user: any, updatedData: any): boolean;
+        allowCreate(user: any, newData: {}): boolean;
+        allowDelete(user: any): boolean;
+        update(updates?: any, fullUpdate?: boolean): /*elided*/ any;
+        addTo(property: any, value: any): void;
+        subtractFrom(property: any, value: any): void;
+        getMetadata(): {
+            key: any;
+            value: any;
+            version: number;
+            localTime: number;
+            expiresAt: number;
+            deref?: () => any;
+        };
+        getRecord(): any;
+        getChanges(): any;
+        _setChanges(changes: any): void;
+        setRecord(record: any): void;
+        invalidate(): void;
+        _writeInvalidate(partialRecord?: any, options?: any): void;
+        _writeRelocate(options: any): void;
+        lock(): void;
+        put(record: any): void;
+        patch(recordUpdate: any): void;
+        _writeUpdate(recordUpdate: any, fullUpdate: boolean, options?: any): void;
+        delete(request?: import("../ResourceInterface.js").Query | string): Promise<boolean>;
+        _writeDelete(options?: any): boolean;
+        search(request: import("../ResourceInterface.js").Query): AsyncIterable<any>;
+        subscribe(request: import("../ResourceInterface.js").SubscriptionRequest): Promise<{
+            listener: (key: any) => any;
+            subscriptions: [];
+            startTime?: number;
+            end(): void;
+            toJSON(): {
+                name: string;
+            };
+            resolveNext: Function;
+            queue: any[];
+            hasDataListeners: boolean;
+            drainCloseListener: boolean;
+            currentDrainResolver: Function;
+            push(message: any): void;
+            send(message: any): void;
+            getNextMessage(): any;
+            waitForDrain(): Promise<boolean>;
+            on(eventName: any, listener: any): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                queue: import("../IterableEventQueue.js").IterableEventQueue;
+                push(message: any): void;
+                next(): Promise<unknown> | {
+                    value: any;
+                };
+                return(value: any): {
+                    value: any;
+                    done: boolean;
+                };
+                throw(error: any): {
+                    done: boolean;
+                };
+            };
+            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+            addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            off<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            removeAllListeners(eventName?: string | symbol): /*elided*/ any;
+            setMaxListeners(n: number): /*elided*/ any;
+            getMaxListeners(): number;
+            listeners<K>(eventName: string | symbol): Function[];
+            rawListeners<K>(eventName: string | symbol): Function[];
+            emit<K>(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<K>(eventName: string | symbol, listener?: Function): number;
+            prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
+            eventNames(): (string | symbol)[];
+        }>;
+        doesExist(): boolean;
+        publish(message: any, options?: any): void;
+        _writePublish(message: any, options?: any): void;
+        validate(record: any, patch?: any): void;
+        getUpdatedTime(): number;
+        wasLoadedFromSource(): boolean | void;
+        readonly "__#6@#id": import("../ResourceInterface.js").Id;
+        readonly "__#6@#context": import("../ResourceInterface.js").Context;
+        "__#6@#isCollection": boolean;
+        post(newRecord: any): Promise<any>;
+        readonly isCollection: boolean;
+        connect(query?: {}): AsyncIterable<any>;
+        getId(): import("../ResourceInterface.js").Id;
+        getContext(): import("../ResourceInterface.js").Context;
+    };
+    _updateResource(resource: any, entry: any): void;
+    getNewId(): any;
+    setTTLExpiration(expiration: number | {
+        expiration: number;
+        eviction?: number;
+        scanInterval?: number;
+    }): void;
+    getResidencyRecord(id: any): any;
+    setResidency(getResidency?: (record: object, context: import("../ResourceInterface.js").Context) => number | void | string[]): void;
+    setResidencyById(getResidencyById?: (id: import("../ResourceInterface.js").Id) => number | void): void;
+    getResidency(record: object, context: import("../ResourceInterface.js").Context): number | void | string[];
+    enableAuditing(auditEnabled?: boolean): void;
+    coerceId(id: string): number | string;
+    dropTable(): Promise<void>;
+    _recordRelocate(existingEntry: any, entry: any): void;
+    evict(id: any, existingRecord: any, existingVersion: any): Promise<void>;
+    operation(operation: any, context: any): any;
+    transformToOrderedSelect(entries: any[], select: (string | import("../ResourceInterface.js").SubSelect)[], sort: import("../ResourceInterface.js").Sort, context: import("../ResourceInterface.js").Context, readTxn: any, transformToRecord: Function): any;
+    transformEntryForSelect(select: any, context: any, readTxn: any, filtered: any, ensure_loaded?: any, canSkip?: any): (entry: any) => any;
+    subscribeOnThisThread(workerIndex: any, options: any): boolean;
+    addAttributes(attributesToAdd: any): Promise<any>;
+    removeAttributes(names: string[]): Promise<any>;
+    getSize(): number;
+    getAuditSize(): number;
+    getStorageStats(): {
+        available: number;
+        free: number;
+        size: number;
+    };
+    getRecordCount(options?: any): Promise<{
+        recordCount: number;
+        estimatedRange: number[];
+    } | {
+        recordCount: number;
+        estimatedRange?: undefined;
+    }>;
+    updatedAttributes(): void;
+    setComputedAttribute(attribute_name: any, resolver: any): void;
+    deleteHistory(endTime?: number, cleanupDeletedRecords?: boolean): Promise<void>;
+    getHistory(startTime?: number, endTime?: number): AsyncGenerator<{
+        id: import("ordered-binary").Key;
+        localTime: any;
+        version: any;
+        type: any;
+        value: any;
+        user: import("ordered-binary").Key;
+        operation: any;
+    }, void, unknown>;
+    getHistoryOfRecord(id: any): Promise<any[]>;
+    cleanup(): void;
+    transactions: import("../DatabaseTransaction.js").Transaction[] & {
+        timestamp: number;
+    };
+    directURLMapping: boolean;
+    get(identifier: import("../ResourceInterface.js").Id, context?: import("../ResourceInterface.js").Context): Promise<import("../Resource.js").Resource>;
+    get(query: import("../ResourceInterface.js").Query, context?: import("../ResourceInterface.js").Context): Promise<AsyncIterable<object>>;
+    put: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    patch: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    delete(identifier: import("../ResourceInterface.js").Id, context?: import("../ResourceInterface.js").Context): Promise<boolean>;
+    delete(request: import("../ResourceInterface.js").Context, context?: import("../ResourceInterface.js").Context): Promise<object>;
+    create(idPrefix: import("../ResourceInterface.js").Id, record: any, context: import("../ResourceInterface.js").Context): Promise<import("../ResourceInterface.js").Id>;
+    create(record: any, context: import("../ResourceInterface.js").Context): Promise<import("../ResourceInterface.js").Id>;
+    invalidate: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    post: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    connect: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    subscribe(request: import("../ResourceInterface.js").SubscriptionRequest): Promise<AsyncIterable<{
+        id: any;
+        operation: string;
+        value: object;
+    }>>;
+    publish: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    search: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    query: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    copy: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    move: {
+        (idOrQuery: string | import("../ResourceInterface.js").Id, dataOrContext?: any, context?: import("../ResourceInterface.js").Context): any;
+        reliesOnPrototype: boolean;
+    };
+    isCollection(resource: any): any;
+    parseQuery(search: any): any;
+    parsePath(path: any, context: any, query: any): any;
+};
+export declare function normalizeIPv6(ipv6: string): string;
+/** stableNodeId takes a hostname or IP address and returns a number containing
+ * the 32-bit SHAKE128 hash of the hostname or IP address. The astute among you
+ * will now be thinking, "Why return a 32-bit hash of a 32-bit IPv4 address?"
+ * And the answer is that this is primarily intended for identifying cluster
+ * nodes, and in production those should always use hostnames for TLS security.
+ * So it doesn't make much sense to optimize the IPv4 use case.
+ */
+export declare function stableNodeId(nodeAddrOrName: string): number;

package/resources/analytics/metadata.d.ts

@@ -0,0 +1,9 @@
+export declare const METRIC: {
+    readonly TABLE_SIZE: "table-size";
+    readonly DATABASE_SIZE: "database-size";
+    readonly STORAGE_VOLUME: "storage-volume";
+    readonly MAIN_THREAD_UTILIZATION: "main-thread-utilization";
+    readonly RESOURCE_USAGE: "resource-usage";
+    readonly UTILIZATION: "utilization";
+};
+export type BuiltInMetricName = (typeof METRIC)[keyof typeof METRIC];

package/resources/analytics/read.d.ts

@@ -0,0 +1,26 @@
+import type { Metric } from './write.ts';
+interface GetAnalyticsRequest {
+    metric: string;
+    start_time?: number;
+    end_time?: number;
+    get_attributes?: string[];
+}
+type GetAnalyticsResponse = Metric[];
+export declare function getOp(req: GetAnalyticsRequest): Promise<GetAnalyticsResponse>;
+export declare function get(metric: string, getAttributes?: string[], startTime?: number, endTime?: number): Promise<Metric[]>;
+type MetricType = 'builtin' | 'custom';
+interface ListMetricsRequest {
+    metric_types: MetricType[];
+}
+type ListMetricsResponse = string[];
+export declare function listMetricsOp(req: ListMetricsRequest): Promise<ListMetricsResponse>;
+export declare function listMetrics(metricTypes?: MetricType[]): Promise<string[]>;
+interface DescribeMetricRequest {
+    metric: string;
+}
+interface DescribeMetricResponse {
+    attributes?: string[];
+}
+export declare function describeMetricOp(req: DescribeMetricRequest): Promise<DescribeMetricResponse>;
+export declare function describeMetric(metric: string): Promise<DescribeMetricResponse>;
+export {};

package/resources/{analytics.d.ts → analytics/write.d.ts}

@@ -24,16 +24,22 @@ export declare function setAnalyticsEnabled(enabled: boolean): void;
 export declare function recordAction(value: Value, metric: string, path?: string, method?: string, type?: string): void;
 export declare function recordActionBinary(value: any, metric: any, path?: any, method?: any, type?: any): void;
 export declare function addAnalyticsListener(callback: any): void;
+export declare function recordHostname(): Promise<void>;
+export interface Metric {
+    [key: string]: any;
+}
 interface ResourceUsage extends Partial<NodeJS.ResourceUsage> {
     time?: number;
     period?: number;
     cpuUtilization?: number;
+    userCPUTime?: number;
+    systemCPUTime?: number;
 }
-/** calculateCPUUtilization takes a ResourceUsage with at least userCPUTime & systemCPUTime set
- *  with millisecond values (NB: Node's process.resourceUsage returns values in microseconds for
- *  these fields so divide them by 1000 to get milliseconds) and a time period in milliseconds
- *  and returns the percentage of that time the CPU was being utilized as a decimal value
- *  between 0 and 1. So for example, 50% utilization will be returned as 0.5.
+/** calculateCPUUtilization takes a ResourceUsage with at least userCPUTime &
+ *  systemCPUTime set with millisecond values and a time period in milliseconds
+ *  and returns the percentage of that time the CPU was being utilized as a
+ *  decimal value between 0 and 1. So for example, 50% utilization will be
+ *  returned as 0.5.
  */
 export declare function calculateCPUUtilization(resourceUsage: ResourceUsage, period: number): number;
 /** diffResourceUsage takes a ResourceUsage representing the last time we stored them and a new
@@ -54,13 +60,13 @@ function addToBucket(action, value) {
     let jump = BUCKET_COUNT >> 1; // amount to jump with each iteration
     let position = jump; // start at halfway point
     while ((jump = jump >> 1) > 0) {
-        const bucket_value = values[position];
-        if (bucket_value === 0) {
+        const bucketValue = values[position];
+        if (bucketValue === 0) {
             // unused slot, immediately put our value in
             counts[position] = 1;
             values[position] = value;
         }
-        if (value > bucket_value) {
+        if (value > bucketValue) {
             position += jump;
         } else {
             position -= jump;
@@ -88,36 +94,36 @@ function newBuckets() {
     };
 }
 
-let balancing_buckets;
+let balancingBuckets;
 
  /**
  * Rebalance the buckets, we can reset the counts at the same time, if this occurred after a delivery
  * @param param
- * @param reset_counts
+ * @param resetCounts
  *
-function rebalance({ counts, values, totalCount }, reset_counts: boolean) {
-    const count_per_bucket = totalCount / BUCKET_COUNT;
-    let target_position = 0;
-    let target_count = 0;
-    let last_target_value = 0;
-    const { values: target_values, counts: target_counts } = balancing_buckets || (balancing_buckets = newBuckets());
+function rebalance({ counts, values, totalCount }, resetCounts: boolean) {
+    const countPerBucket = totalCount / BUCKET_COUNT;
+    let targetPosition = 0;
+    let targetCount = 0;
+    let lastTargetValue = 0;
+    const { values: targetValues, counts: targetCounts } = balancingBuckets || (balancingBuckets = newBuckets());
     for (let i = 0; i < BUCKET_COUNT; i++) {
         // iterate through the existing buckets, filling up the target buckets in a balanced way
         let count = counts[i];
-        while ((count_per_bucket - target_count) < count) {
+        while ((countPerBucket - targetCount) < count) {
             const value = values[i];
-            last_target_value = ((count_per_bucket - target_count) / count) * (value - last_target_value) + last_target_value;
-            target_values[target_position] = last_target_value;
-            target_counts[target_position] = count_per_bucket;
-            count -= count_per_bucket;
-            target_position++;
-            target_count = 0;
+            lastTargetValue = ((countPerBucket - targetCount) / count) * (value - lastTargetValue) + lastTargetValue;
+            targetValues[targetPosition] = lastTargetValue;
+            targetCounts[targetPosition] = countPerBucket;
+            count -= countPerBucket;
+            targetPosition++;
+            targetCount = 0;
         }
-        target_count += count;
+        targetCount += count;
     }
     // now copy the balanced buckets back into the original buckets
-    values.set(target_values);
-    if (reset_counts) counts.fill(0);
-    else counts.set(target_counts);
+    values.set(targetValues);
+    if (resetCounts) counts.fill(0);
+    else counts.set(targetCounts);
 }
 */