@amazon/vinyl-util 1.0.0

package/dist/types/ts4.1/event/EventHost.d.ts

@@ -0,0 +1,69 @@
+import type { Disposable } from '../core/disposable';
+import type { EventHandler, SignalOptions } from './Signal';
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { Covariant } from '../util/type';
+import type { LogTarget } from '../logging/LogTarget';
+export interface EventDispatcher<EventMap> extends LogTarget {
+    /**
+     * Dispatches an event.
+     *
+     * @param type The key of the event within `EventMap`
+     * @param event If the passed event is read-only, then it may be re-used/cached. Otherwise,
+     * it should be a new event object every dispatch. If no target property is set on the event,
+     * the target will be set to this host.
+     */
+    dispatch<K extends keyof EventMap>(type: K, event: EventMap[K]): void;
+}
+export interface ReadonlyEventHost<EventMap> {
+    /**
+     * Adds an event handler for the given typed event.
+     *
+     * @param type The key representing the event type to listen for.
+     * @param handler A callback to invoke when the event with the given type is dispatched.
+     * @param options Options for changing listening behavior.
+     * @return Returns a method, when invoked, removes the handler.
+     */
+    on<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>, options?: SignalOptions): Unsubscribe;
+    /**
+     * Returns true if the event host has any listeners.
+     */
+    hasAnyListeners(): boolean;
+    /**
+     * Returns true if the event host has any listeners for the given type.
+     */
+    hasListeners(type: keyof EventMap): boolean;
+    /**
+     * Exists for EventMap type inference.
+     *
+     * @private
+     */
+    __eventMapType: Covariant<EventMap>;
+}
+/**
+ * An object that may dispatch events and have handlers for those events.
+ * Similar to the DOM's `EventTarget`, this is a basic event system based on event naming.
+ *
+ * Some of the advantages of EventHost over EventTarget:
+ * - Not all supported platforms support EventTarget construction or extension.
+ * - EventTarget is designed for the DOM, with bubble and capture phases not necessary in Vinyl.
+ * - Event types are strict.
+ * - Events can be plain objects, no need to extend CustomEvent.
+ * - Easier unsubscription and disposal; reduces the risk of memory leaks.
+ *
+ * EventHost supports concurrent modification, that is, handlers may be added or removed during
+ * the execution of another handler.
+ */
+export interface EventHost<EventMap> extends ReadonlyEventHost<EventMap>, EventDispatcher<EventMap> {
+}
+export declare class EventHostImpl<EventMap> implements EventHost<EventMap>, Disposable {
+    get [Symbol.toStringTag](): string;
+    readonly logPrefix: string;
+    private readonly signals;
+    hasAnyListeners(): boolean;
+    hasListeners(type: keyof EventMap): boolean;
+    on<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>, options?: SignalOptions): Unsubscribe;
+    dispatch<K extends keyof EventMap>(type: K, event: EventMap[K]): void;
+    dispose(): void;
+    __eventMapType: Covariant<EventMap>;
+}
+//# sourceMappingURL=EventHost.d.ts.map

package/dist/types/ts4.1/event/Signal.d.ts

@@ -0,0 +1,57 @@
+import type { Disposable } from '../core/disposable';
+import type { Unsubscribe } from '../core/Unsubscribe';
+export type EventHandler<T> = (event: T) => void;
+export interface SignalOptions {
+    /**
+     * If true, removes the handler after the first invocation.
+     */
+    once?: boolean;
+}
+export interface Signal<T> {
+    /**
+     * Returns true if this signal has no handlers.
+     */
+    readonly empty: boolean;
+    /**
+     * Adds an event handler that will be invoked upon signal dispatch.
+     *
+     * @param handler The handler to invoke on signal dispatch.
+     * @param options Options for changing listening behavior.
+     * @return Unsubscribe - Returns a method where, when invoked, will remove the handler.
+     * If the handler has already been removed, Unsubscribe will do nothing.
+     */
+    listen(handler: EventHandler<T>, options?: SignalOptions): Unsubscribe;
+}
+/**
+ * An object that may dispatch one type of event and have handlers for that event.
+ */
+export declare class SignalImpl<T> implements Signal<T>, Disposable {
+    private handlers;
+    get empty(): boolean;
+    listen(handler: EventHandler<T>, options?: SignalOptions): Unsubscribe;
+    /**
+     * Invokes all handlers, providing the given event.
+     *
+     * Handlers may add/remove callbacks or do a nested dispatch.
+     *
+     * If a handler is added within a handler, the new handler will not be invoked until the
+     * next dispatch.
+     *
+     * @param event
+     */
+    dispatch(event: T): void;
+    /**
+     * Removes all handlers.
+     */
+    clear(): void;
+    /**
+     * Same as clear.
+     */
+    dispose(): void;
+}
+/**
+ * Constructs a new SignalImpl.
+ */
+export declare function signal<T>(): SignalImpl<T>;
+export declare const emptySignal: Signal<any>;
+//# sourceMappingURL=Signal.d.ts.map

package/dist/types/ts4.1/event/nextEventAsPromise.d.ts

@@ -0,0 +1,30 @@
+import type { ReadonlyEventHost } from './EventHost';
+import type { ReadonlyAbort } from '../util/async/Abort';
+import type { Maybe } from '../util/type';
+export interface NextEventAsPromiseOptions<EventMap, K extends keyof EventMap> {
+    /**
+     * (Optional) If provided, will only resolve if the event passes this predicate.
+     */
+    filter?: ((event: EventMap[K]) => boolean) | undefined | null;
+    /**
+     * (Optional) If provided, will reject the promise if the signal is aborted.
+     */
+    abort?: Maybe<ReadonlyAbort>;
+    /**
+     * If provided, the promise will reject after this duration, in seconds, if not resolved.
+     */
+    timeout?: number;
+    /**
+     * The timeout message. If not provided will use `DEFAULT_TIMEOUT_MESSAGE`.
+     */
+    timeoutMessage?: string;
+}
+/**
+ * Promisifies the next event.
+ *
+ * @param host The event host to observe.
+ * @param type The name of the event.
+ * @param options Optional configuration, to provide abort
+ */
+export declare function nextEventAsPromise<EventMap, K extends keyof EventMap>(host: ReadonlyEventHost<EventMap>, type: K, options?: Maybe<NextEventAsPromiseOptions<EventMap, K>>): Promise<EventMap[K]>;
+//# sourceMappingURL=nextEventAsPromise.d.ts.map

package/dist/types/ts4.1/event/onAny.d.ts

@@ -0,0 +1,13 @@
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { ReadonlyEventHost } from './EventHost';
+import type { SignalOptions } from './Signal';
+/**
+ * Adds a single handler to all given event types on an event host.
+ *
+ * @param host The event host.
+ * @param types An array of event types.
+ * @param handler A handler to be called if any of the given event types are dispatched.
+ * @param options If once is true, the first event called will remove the handler.
+ */
+export declare function onAny<EventMap, K extends keyof EventMap>(host: ReadonlyEventHost<EventMap>, types: readonly K[], handler: <U extends K>(event: EventMap[U], type: U) => void, options?: SignalOptions): Unsubscribe;
+//# sourceMappingURL=onAny.d.ts.map

package/dist/types/ts4.1/event/redispatchEvents.d.ts

@@ -0,0 +1,15 @@
+import type { EventDispatcher, ReadonlyEventHost } from './EventHost';
+import type { Unsubscribe } from '../core/Unsubscribe';
+/**
+ * Listens to an event host for a list of events, re-dispatching those events on this target
+ * dispatcher.
+ * Useful for event delegation.
+ *
+ * @param dispatcher The dispatcher on which to re-dispatch events.
+ * @param eventHost The readonly event host that emits the events to be re-dispatched.
+ * @param eventTypes The event types from eventHost to delegate to the dispatcher. These are the
+ * keys in the event map that should be delegated.
+ * @return Returns a method that when invoked, will unsubscribe from all delegated events.
+ */
+export declare function redispatchEvents<EventMap, K extends keyof EventMap>(dispatcher: EventDispatcher<Pick<EventMap, K>>, eventHost: ReadonlyEventHost<EventMap>, eventTypes: readonly K[]): Unsubscribe;
+//# sourceMappingURL=redispatchEvents.d.ts.map

package/dist/types/ts4.1/global/environment.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Returns true if this is a nodejs environment.
+ */
+export declare function isNode(): boolean;
+/**
+ * Node's global setTimeout differs slightly from the browser. Use this when storing timeout ids.
+ */
+export type TimeoutId = ReturnType<typeof setTimeout>;
+/**
+ * A subset of `Location` properties available in all environments.
+ */
+export interface PartialLocation {
+    readonly origin: string;
+    readonly search: string;
+    readonly href: string;
+}
+/**
+ * Returns the global `location` object, or a default with empty values
+ * when `location` is not defined (e.g. Node, Web Workers).
+ */
+export declare function getLocation(): PartialLocation;
+/**
+ * Node's global setInterval differs slightly from the browser. Use this when storing interval ids.
+ */
+export type IntervalId = ReturnType<typeof setInterval>;
+//# sourceMappingURL=environment.d.ts.map

package/dist/types/ts4.1/global/globalRegistry.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Manages global initializers.
+ */
+export declare class GlobalRegistry {
+    private registry;
+    get size(): number;
+    /**
+     * Registers an initializer that will be invoked during global state initialization.
+     * @param initializer
+     */
+    register<T extends GlobalRef<any>>(initializer: T): T;
+    /**
+     * Removes a global ref from the registry.
+     * May be called at any time.
+     * @param ref
+     * @return Returns true if the global ref was removed.
+     */
+    unregister(ref: GlobalRef<any>): boolean;
+    /**
+     * Resets all registered initializers and sets this registry back to its pre-initialized state.
+     * This is typically only done within unit tests, but may be called if all players are
+     * disposed and the consumer intends to teardown global state.
+     */
+    reset(): void;
+}
+/**
+ * Gets or creates the global registry instance.
+ */
+export declare function getGlobalRegistry(): GlobalRegistry;
+export interface GlobalRef<T> {
+    /**
+     * True if this has been initialized.
+     */
+    readonly initialized: boolean;
+    /**
+     * Returns the factory-produced value.
+     * Throws an {@link IllegalStateError} if the global registry has not been initialized.
+     */
+    readonly value: T;
+    /**
+     * Overrides this initializer.
+     * The previous initializer will be provided as an argument for extension.
+     *
+     * Throws an {@link IllegalStateError} if the global registry has been initialized.
+     * @return Returns this
+     */
+    set(newInitializer: (previousInitializer: () => T) => T): GlobalRef<T>;
+    /**
+     * Resets this initializer back to its pre-initialized state.
+     * If the initializer produced a disposable value, it will be disposed.
+     */
+    reset(): void;
+    /**
+     * Initializes the global ref.
+     * This is done automatically on first use of `value`, but may be initialized eagerly.
+     */
+    initialize(): void;
+}
+export declare function setGlobalRefDebug(enabled: boolean): void;
+export declare class GlobalRefImpl<T> implements GlobalRef<T> {
+    private readonly defaultInitializer;
+    private _value;
+    private _initialized;
+    private constructing;
+    private initializer;
+    private lastInitStack;
+    constructor(defaultInitializer: () => T);
+    get initialized(): boolean;
+    get value(): T;
+    reset(): void;
+    initialize(): void;
+    set(newInitializer: (previousInitializer: () => T) => T): GlobalRef<T>;
+    private assertNotInitialized;
+    private assertNotConstructing;
+}
+/**
+ * Creates a global reference that can be lazily initialized.
+ * This function is tree-shakable as it doesn't perform any side effects on import.
+ *
+ * @param init Factory function that creates the value
+ */
+export declare function globalRef<T>(init: () => T): GlobalRef<T>;
+//# sourceMappingURL=globalRegistry.d.ts.map

package/dist/types/ts4.1/global/globalTarget.d.ts

@@ -0,0 +1,8 @@
+import type { LogTarget } from '../logging/LogTarget';
+/**
+ * The global path target.
+ * Global systems such as logging or uncaught error handling may use this when a pathTarget
+ * is needed.
+ */
+export declare const globalTarget: LogTarget;
+//# sourceMappingURL=globalTarget.d.ts.map

package/dist/types/ts4.1/index.d.ts

@@ -0,0 +1,118 @@
+/** Auto-generated from build scripts */
+export * from './util/type';
+export * from './util/url/resolveUrl';
+export * from './util/string/uid';
+export * from './util/string/string';
+export * from './util/string/StringReader';
+export * from './util/set/set';
+export * from './util/serialization/stringifyForPrint';
+export * from './util/serialization/primitives';
+export * from './util/serialization/json';
+export * from './util/serialization/ParseError';
+export * from './util/range/timeRanges';
+export * from './util/range/UnionRanges';
+export * from './util/range/Ranges';
+export * from './util/range/IntersectionRanges';
+export * from './util/object/readonlyType';
+export * from './util/object/object';
+export * from './util/object/mutableType';
+export * from './util/object/mergeDeep';
+export * from './util/object/merge';
+export * from './util/object/lazy';
+export * from './util/object/equalDeep';
+export * from './util/object/clone';
+export * from './util/network/request';
+export * from './util/mpeg/parseSidxBox';
+export * from './util/math/math';
+export * from './util/map/map';
+export * from './util/iteration/iterable';
+export * from './util/fun/throttle';
+export * from './util/fun/memoize';
+export * from './util/fun/function';
+export * from './util/fun/flow';
+export * from './util/fun/debounce';
+export * from './util/error/stack';
+export * from './util/date/date';
+export * from './util/config/ValueProvider';
+export * from './util/comparison/compare';
+export * from './util/collection/typedArray';
+export * from './util/collection/array';
+export * from './util/collection/LruCache';
+export * from './util/collection/LinkedList';
+export * from './util/collection/CacheMap';
+export * from './util/buffer/buffer';
+export * from './util/buffer/BufferWriter';
+export * from './util/buffer/BufferReader';
+export * from './util/buffer/BufferError';
+export * from './util/browser/searchParams';
+export * from './util/async/timeout';
+export * from './util/async/sleep';
+export * from './util/async/promise';
+export * from './util/async/never';
+export * from './util/async/abortUtils';
+export * from './util/async/TimeoutSlot';
+export * from './util/async/TimeoutController';
+export * from './util/async/TaskQueue';
+export * from './util/async/Deferred';
+export * from './util/async/Abort';
+export * from './persistence/persistenceRef';
+export * from './persistence/StoragePersistence';
+export * from './persistence/PersistentItem';
+export * from './persistence/KeyValuePersistence';
+export * from './patch/patchTarget';
+export * from './patch/network/fetch';
+export * from './network/responseUtil';
+export * from './network/requesterUtil';
+export * from './network/requesterGlobal';
+export * from './network/network';
+export * from './network/createRequester';
+export * from './network/RequesterImplEventMap';
+export * from './network/RequesterImpl';
+export * from './network/Requester';
+export * from './network/RequestInterceptor';
+export * from './network/RequestError';
+export * from './network/metrics/networkMetricsModel';
+export * from './network/metrics/networkMetricsGlobal';
+export * from './network/metrics/NetworkMetricsControllerImpl';
+export * from './network/metrics/NetworkMetricsController';
+export * from './network/logging/networkLoggingHandler';
+export * from './network/browser/NetworkInformation';
+export * from './logging/logTimer';
+export * from './logging/getLogLevelFromSearch';
+export * from './logging/VinylLogging';
+export * from './logging/Logger';
+export * from './logging/LogTarget';
+export * from './logging/HistoryLogHandler';
+export * from './logging/ConsoleLogHandler';
+export * from './global/globalTarget';
+export * from './global/globalRegistry';
+export * from './global/environment';
+export * from './event/redispatchEvents';
+export * from './event/onAny';
+export * from './event/nextEventAsPromise';
+export * from './event/Signal';
+export * from './event/EventHost';
+export * from './event/DomEventHost';
+export * from './error/ValidationError';
+export * from './error/UnreachableCodeError';
+export * from './error/TimeoutError';
+export * from './error/StackOverflowError';
+export * from './error/ServiceResponseError';
+export * from './error/ReportableError';
+export * from './error/MediaUnsupportedError';
+export * from './error/IllegalStateError';
+export * from './error/IllegalArgumentError';
+export * from './error/ErrorOrigin';
+export * from './error/AbortError';
+export * from './core/disposable';
+export * from './core/cloneable';
+export * from './core/clearable';
+export * from './core/Unsubscribe';
+export * from './client/Version';
+export * from './client/userAgent/userAgentRuleHelpers';
+export * from './client/userAgent/tokenizeUserAgent';
+export * from './client/userAgent/parseUserAgent';
+export * from './client/userAgent/hasBrowser';
+export * from './client/userAgent/defaultUserAgentRules';
+export * from './client/userAgent/UserAgentInfo';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ts4.1/logging/ConsoleLogHandler.d.ts

@@ -0,0 +1,26 @@
+import type { Disposable } from '../core/disposable';
+import type { ReadonlyEventHost } from '../event/EventHost';
+import type { LogEventMap } from './Logger';
+import { LogLevel } from './Logger';
+export interface ConsoleLike {
+    log(message?: any, ...optionalParams: any[]): void;
+    debug(message?: any, ...optionalParams: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+}
+/**
+ * A log target that logs to a console.
+ */
+export interface ConsoleLogHandler {
+    logLevel: LogLevel;
+}
+/**
+ * A {@link ConsoleLogHandler} implementation.
+ */
+export declare class ConsoleLogHandlerImpl implements ConsoleLogHandler, Disposable {
+    logLevel: LogLevel;
+    private readonly logSub;
+    constructor(host: ReadonlyEventHost<LogEventMap>, logLevel?: LogLevel, consoleLike?: ConsoleLike);
+    dispose(): void;
+}
+//# sourceMappingURL=ConsoleLogHandler.d.ts.map

package/dist/types/ts4.1/logging/HistoryLogHandler.d.ts

@@ -0,0 +1,56 @@
+import type { Disposable } from '../core/disposable';
+import type { ReadonlyEventHost } from '../event/EventHost';
+import type { LogEventMap } from './Logger';
+import { LogLevel } from './Logger';
+import type { ReadonlyDate } from '../util/object/readonlyType';
+/**
+ * The default maximum history size for the history log handler.
+ */
+export declare const DEFAULT_MAX_HISTORY = 100;
+export interface HistoryLogItem {
+    readonly timestamp: ReadonlyDate;
+    readonly messages: readonly any[];
+    readonly level: LogLevel;
+    /**
+     * The LogTarget's logPrefix.
+     */
+    readonly logPrefix: string;
+}
+/**
+ * Logs to a rolling list.
+ */
+export interface HistoryLogHandler {
+    /**
+     * This level and higher will be logged to the history.
+     * Default is {@link LogLevel.DEBUG}
+     */
+    logLevel: LogLevel;
+    /**
+     * The maximum number of logs to keep.
+     */
+    maxHistorySize: number;
+    /*
+    * The log history, kept up to {@link maxHistorySize}
+    */
+    readonly history: readonly HistoryLogItem[];
+    /**
+     * Clears the log history.
+     */
+    clear(): void;
+}
+/**
+ * A basic HistoryLogHandler implementation.
+ */
+export declare class HistoryLogHandlerImpl implements HistoryLogHandler, Disposable {
+    logLevel: LogLevel;
+    private readonly _history;
+    private readonly logSub;
+    private _maxHistorySize;
+    constructor(host: ReadonlyEventHost<LogEventMap>, logLevel?: LogLevel);
+    get maxHistorySize(): number;
+    set maxHistorySize(value: number);
+    get history(): readonly HistoryLogItem[];
+    clear(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=HistoryLogHandler.d.ts.map

package/dist/types/ts4.1/logging/LogTarget.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Provides the logging prefix for all logs made by this target.
+ */
+export interface LogTarget {
+    /**
+     * A string prefix for all log statements made by this target.
+     */
+    readonly logPrefix: string;
+}
+/**
+ * Creates a unique log prefix.
+ *
+ * @param target Either a string or an object with a toStringTag.
+ * The log prefix will append a unique counter.
+ */
+export declare function createLogPrefix(target: string | {
+    readonly [Symbol.toStringTag]: string;
+}): string;
+//# sourceMappingURL=LogTarget.d.ts.map

package/dist/types/ts4.1/logging/Logger.d.ts

@@ -0,0 +1,66 @@
+import type { ReadonlyEventHost } from '../event/EventHost';
+import { EventHostImpl } from '../event/EventHost';
+import type { LogTarget } from '../logging/LogTarget';
+export declare enum LogLevel {
+    VERBOSE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4,
+    NONE = 5
+}
+export interface LogEvent {
+    readonly messages: any[];
+    readonly target: LogTarget;
+    readonly level: LogLevel;
+}
+export interface LogEventMap {
+    readonly log: LogEvent;
+}
+/**
+ * The interface for a basic logger implementation.
+ */
+export interface Logger extends ReadonlyEventHost<LogEventMap> {
+    logLevel: LogLevel;
+    log(target: LogTarget, level: LogLevel, ...messages: readonly any[]): void;
+}
+export declare class LoggerImpl extends EventHostImpl<LogEventMap> implements Logger {
+    logLevel: LogLevel;
+    get [Symbol.toStringTag](): string;
+    constructor(logLevel?: LogLevel);
+    log(target: LogTarget, level: LogLevel, ...messages: readonly any[]): void;
+}
+/**
+ * A global reference to the logger.
+ * @private
+ */
+export declare const loggerRef: import("../global/globalRegistry").GlobalRef<Logger>;
+/**
+ * Returns the current log level.
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * Sets the current log level.
+ *
+ * @param value
+ */
+export declare function setLogLevel(value: LogLevel): void;
+export declare function log(target: LogTarget, level: LogLevel, ...messages: readonly any[]): void;
+export declare function logVerbose(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logDebug(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logInfo(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logWarn(target: LogTarget, ...messages: readonly any[]): void;
+export declare function logError(target: LogTarget, ...messages: readonly any[]): void;
+/**
+ * From a case-insensitive string, returns the log level.
+ * Possible values match to the keys in {@link LogLevel}.
+ *
+ * @param str
+ */
+export declare function parseLogLevel(str: string): LogLevel | null;
+/**
+ * Returns the log level as a lowercase string.
+ * E.g. stringifyLogLevel(LogLevel.DEBUG) returns 'debug'
+ */
+export declare function stringifyLogLevel(logLevel: LogLevel): string;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/types/ts4.1/logging/VinylLogging.d.ts

@@ -0,0 +1,9 @@
+import type { ConsoleLogHandler } from './ConsoleLogHandler';
+import type { HistoryLogHandler } from './HistoryLogHandler';
+export declare const historyLogHandler: import("../global/globalRegistry").GlobalRef<HistoryLogHandler | undefined>;
+export declare const consoleLogHandler: import("../global/globalRegistry").GlobalRef<ConsoleLogHandler | undefined>;
+/**
+ * Initializes vinyl logging.
+ */
+export declare function initializeLogging(): void;
+//# sourceMappingURL=VinylLogging.d.ts.map

package/dist/types/ts4.1/logging/getLogLevelFromSearch.d.ts

@@ -0,0 +1,8 @@
+import { LogLevel } from '../logging/Logger';
+/**
+ * Returns the current vinyl logging level, as set by the querystring parameter: vinylLogLevel.
+ * @param search
+ * @param defaultLevel
+ */
+export declare function getLogLevelFromSearch(search?: string, defaultLevel?: LogLevel): LogLevel;
+//# sourceMappingURL=getLogLevelFromSearch.d.ts.map

package/dist/types/ts4.1/logging/logTimer.d.ts

@@ -0,0 +1,10 @@
+import type { LogTarget } from '../logging/LogTarget';
+/**
+ * Creates a timer that logs elapsed time when called.
+ *
+ * @param target - The log target
+ * @param message - Message to log with the elapsed time
+ * @returns Function that logs the elapsed time since creation
+ */
+export declare function logTimer(target: LogTarget, message: string): () => void;
+//# sourceMappingURL=logTimer.d.ts.map

package/dist/types/ts4.1/network/RequestError.d.ts

@@ -0,0 +1,26 @@
+import { ReportableError } from '../error/ReportableError';
+import type { RequestErrorEvent } from './RequesterImplEventMap';
+import type { Json } from '../util/serialization/json';
+/**
+ * An error reported from a service response.
+ */
+export declare class RequestError extends ReportableError {
+    /**
+     * When the request failure is a !ok response, this will be set.
+     */
+    readonly response: Response | null;
+    readonly info: RequestErrorEvent;
+    get [Symbol.toStringTag](): string;
+    private static getErrorMessage;
+    /**
+     * 500 errors are external service errors, all other errors are considered internal.
+     */
+    static getErrorOrigin(info: RequestErrorEvent): string;
+    constructor(
+    /**
+     * When the request failure is a !ok response, this will be set.
+     */
+    response: Response | null, info: RequestErrorEvent);
+    toJSON(): Json;
+}
+//# sourceMappingURL=RequestError.d.ts.map