## API Report File for "@fluidframework/common-utils"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { EventEmitter } from 'events';
import { IDisposable } from '@fluidframework/common-definitions';
import { IEvent } from '@fluidframework/common-definitions';
import { IEventProvider } from '@fluidframework/common-definitions';
import { IEventTransformer } from '@fluidframework/common-definitions';
import { ITelemetryBaseEvent } from '@fluidframework/common-definitions';
import { ITelemetryBaseLogger } from '@fluidframework/common-definitions';
import { ITelemetryErrorEvent } from '@fluidframework/common-definitions';
import { ITelemetryGenericEvent } from '@fluidframework/common-definitions';
import { ITelemetryLogger } from '@fluidframework/common-definitions';
import { ITelemetryPerformanceEvent } from '@fluidframework/common-definitions';
import { TransformedEvent } from '@fluidframework/common-definitions';

// @internal @deprecated
export function assert(condition: boolean, message: string | number): asserts condition;

// @internal @deprecated
export class BaseTelemetryNullLogger implements ITelemetryBaseLogger {
    send(event: ITelemetryBaseEvent): void;
}

// @internal @deprecated
export class Buffer extends Uint8Array {
    // (undocumented)
    static from(value: any, encodingOrOffset?: any, length?: any): IsoBuffer;
    // (undocumented)
    static isBuffer(obj: any): obj is Buffer;
    // (undocumented)
    toString(encoding?: string): string;
}

// @internal @deprecated
export const bufferToString: (blob: ArrayBufferLike, encoding: string) => string;

// @internal @deprecated
export class Deferred<T> {
    constructor();
    get isCompleted(): boolean;
    get promise(): Promise<T>;
    reject(error: any): void;
    resolve(value: T | PromiseLike<T>): void;
}

// @internal @deprecated
export const delay: (timeMs: number) => Promise<void>;

// @internal @deprecated
export function doIfNotDisposed<T>(disposable: IDisposable, f: (...args: any[]) => T): (...args: any[]) => T;

// @internal @deprecated
export type EventEmitterEventType = EventEmitter extends {
    on(event: infer E, listener: any): any;
} ? E : never;

// @internal @deprecated
export class EventForwarder<TEvent = IEvent> extends TypedEventEmitter<TEvent> implements IDisposable {
    constructor(source?: EventEmitter | IEventProvider<TEvent & IEvent>);
    // (undocumented)
    dispose(): void;
    // (undocumented)
    get disposed(): boolean;
    // (undocumented)
    protected forwardEvent(source: EventEmitter | IEventProvider<TEvent & IEvent>, ...events: string[]): void;
    // (undocumented)
    protected static isEmitterEvent(event: string): boolean;
    // (undocumented)
    protected unforwardEvent(source: EventEmitter | IEventProvider<TEvent & IEvent>, ...events: string[]): void;
}

// @internal @deprecated
export const fromBase64ToUtf8: (input: string) => string;

// @internal @deprecated
export const fromUtf8ToBase64: (input: string) => string;

// @internal @deprecated
export function gitHashFile(file: IsoBuffer): Promise<string>;

// @internal @deprecated
export function hashFile(file: IsoBuffer, algorithm?: "SHA-1" | "SHA-256", hashEncoding?: "hex" | "base64"): Promise<string>;

// @internal @deprecated
export class Heap<T> {
    constructor(comp: IComparer<T>);
    add(x: T): IHeapNode<T>;
    // (undocumented)
    comp: IComparer<T>;
    count(): number;
    get(): T;
    peek(): IHeapNode<T>;
    remove(node: IHeapNode<T>): void;
    update(node: IHeapNode<T>): void;
}

// @internal @deprecated
export interface IComparer<T> {
    compare(a: T, b: T): number;
    min: T;
}

// @internal @deprecated
export interface IHeapNode<T> {
    // (undocumented)
    position: number;
    // (undocumented)
    value: T;
}

// @internal @deprecated
export interface IPromiseTimer extends ITimer {
    start(): Promise<IPromiseTimerResult>;
}

// @internal @deprecated (undocumented)
export interface IPromiseTimerResult {
    // (undocumented)
    timerResult: "timeout" | "cancel";
}

// @internal @deprecated
export interface IRange {
    // (undocumented)
    length: number;
    // (undocumented)
    primary: number;
    // (undocumented)
    secondary: number | undefined;
}

// @internal @deprecated
export interface IRangeTrackerSnapshot {
    // (undocumented)
    lastPrimary: number;
    // (undocumented)
    lastSecondary: number | undefined;
    // (undocumented)
    ranges: IRange[];
}

// @internal @deprecated (undocumented)
export const IsoBuffer: typeof Buffer;

// @internal @deprecated (undocumented)
export type IsoBuffer = Buffer;

// @internal @deprecated
export type IsomorphicPerformance = Partial<Performance> & Pick<Performance, "clearMarks" | "mark" | "measure" | "now">;

// @internal @deprecated (undocumented)
export interface ITimer {
    clear(): void;
    readonly hasTimer: boolean;
    start(): void;
}

// @internal @deprecated
export interface ITraceEvent {
    readonly duration: number;
    readonly tick: number;
    readonly totalTimeElapsed: number;
}

// @internal @deprecated
export class Lazy<T> {
    constructor(valueGenerator: () => T);
    get evaluated(): boolean;
    get value(): T;
}

// @internal @deprecated
export class LazyPromise<T> implements Promise<T> {
    // (undocumented)
    get [Symbol.toStringTag](): string;
    constructor(execute: () => Promise<T>);
    // (undocumented)
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
    // (undocumented)
    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
    // (undocumented)
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
}

// @internal @deprecated
export const NumberComparer: IComparer<number>;

// @internal @deprecated (undocumented)
const performance_2: IsomorphicPerformance;
export { performance_2 as performance }

// @internal @deprecated
export class PromiseCache<TKey, TResult> {
    constructor({ expiry, removeOnError, }?: PromiseCacheOptions);
    add(key: TKey, asyncFn: () => Promise<TResult>): boolean;
    addOrGet(key: TKey, asyncFn: () => Promise<TResult>): Promise<TResult>;
    addValue(key: TKey, value: TResult): boolean;
    addValueOrGet(key: TKey, value: TResult): Promise<TResult>;
    get(key: TKey): Promise<TResult> | undefined;
    has(key: TKey): boolean;
    remove(key: TKey): boolean;
}

// @internal @deprecated
export type PromiseCacheExpiry = {
    policy: "indefinite";
} | {
    policy: "absolute" | "sliding";
    durationMs: number;
};

// @internal @deprecated
export interface PromiseCacheOptions {
    expiry?: PromiseCacheExpiry;
    removeOnError?: (e: any) => boolean;
}

// @internal @deprecated
export class PromiseTimer implements IPromiseTimer {
    constructor(defaultTimeout: number, defaultHandler: () => void);
    // (undocumented)
    clear(): void;
    get hasTimer(): boolean;
    start(ms?: number, handler?: () => void): Promise<IPromiseTimerResult>;
    // (undocumented)
    protected wrapHandler(handler: () => void): void;
}

// @internal @deprecated
export class RangeTracker {
    constructor(primary: IRangeTrackerSnapshot);
    constructor(primary: number, secondary: number);
    add(primary: number, secondary: number): void;
    // (undocumented)
    get base(): number;
    get(primary: number): number;
    get primaryHead(): number;
    get secondaryHead(): number | undefined;
    serialize(): IRangeTrackerSnapshot;
    updateBase(primary: number): void;
}

// @internal @deprecated
export class RateLimiter {
    constructor(windowMSec: number);
    filter(clientId: string, messages: string[]): string[];
}

// @internal @deprecated
export function safelyParseJSON(json: string): any | undefined;

// @internal @deprecated
export function setLongTimeout(timeoutFn: () => void, timeoutMs: number, setTimeoutIdFn?: (timeoutId: ReturnType<typeof setTimeout>) => void): ReturnType<typeof setTimeout>;

// @internal @deprecated
export function stringToBuffer(input: string, encoding: string): ArrayBufferLike;

// @internal @deprecated
export class TelemetryNullLogger implements ITelemetryLogger {
    // (undocumented)
    send(event: ITelemetryBaseEvent): void;
    // (undocumented)
    sendErrorEvent(event: ITelemetryErrorEvent, error?: any): void;
    // (undocumented)
    sendPerformanceEvent(event: ITelemetryPerformanceEvent, error?: any): void;
    // (undocumented)
    sendTelemetryEvent(event: ITelemetryGenericEvent, error?: any): void;
}

// @internal @deprecated
export class Timer implements ITimer {
    constructor(defaultTimeout: number, defaultHandler: () => void, getCurrentTick?: () => number);
    clear(): void;
    get hasTimer(): boolean;
    restart(ms?: number, handler?: () => void): void;
    start(ms?: number, handler?: () => void): void;
}

// @internal @deprecated
export const toUtf8: (input: string, encoding: string) => string;

// @internal @deprecated
export class Trace {
    protected constructor(startTick: number);
    // (undocumented)
    protected lastTick: number;
    // (undocumented)
    static start(): Trace;
    // (undocumented)
    readonly startTick: number;
    // (undocumented)
    trace(): ITraceEvent;
}

// @internal @deprecated
export class TypedEventEmitter<TEvent> extends EventEmitter implements IEventProvider<TEvent & IEvent> {
    constructor();
    // (undocumented)
    readonly addListener: TypedEventTransform<this, TEvent>;
    // (undocumented)
    readonly off: TypedEventTransform<this, TEvent>;
    // (undocumented)
    readonly on: TypedEventTransform<this, TEvent>;
    // (undocumented)
    readonly once: TypedEventTransform<this, TEvent>;
    // (undocumented)
    readonly prependListener: TypedEventTransform<this, TEvent>;
    // (undocumented)
    readonly prependOnceListener: TypedEventTransform<this, TEvent>;
    // (undocumented)
    readonly removeListener: TypedEventTransform<this, TEvent>;
}

// @internal @deprecated (undocumented)
export type TypedEventTransform<TThis, TEvent> = TransformedEvent<TThis, "newListener" | "removeListener", Parameters<(event: string, listener: (...args: any[]) => void) => void>> & IEventTransformer<TThis, TEvent & IEvent> & TransformedEvent<TThis, EventEmitterEventType, any[]>;

// @internal @deprecated
export function Uint8ArrayToArrayBuffer(array: Uint8Array): ArrayBuffer;

// @internal @deprecated
export function Uint8ArrayToString(arr: Uint8Array, encoding?: string): string;

// @internal @deprecated
export function unreachableCase(_: never, message?: string): never;

```