@amazon/vinyl-util 1.0.0

package/dist/types/ts3.7/error/ServiceResponseError.d.ts

@@ -0,0 +1,14 @@
+import { ReportableError } from './ReportableError';
+import { Json } from '../util/serialization/json';
+export declare const SERVICE_RESPONSE_ERROR_MESSAGE = "Unexpected service response";
+export declare class ServiceResponseError extends ReportableError {
+    readonly reason: any;
+    constructor(reason: any);
+    get [Symbol.toStringTag](): string;
+    toJSON(): Json;
+}
+/**
+ * When used in a catch clause of a promise, wraps the reason in a {@link ServiceResponseError}.
+ */
+export declare function throwServiceResponse(reason: any): never;
+//# sourceMappingURL=ServiceResponseError.d.ts.map

package/dist/types/ts3.7/error/StackOverflowError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating a stack overflow has occurred.
+ */
+export declare class StackOverflowError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string);
+}
+//# sourceMappingURL=StackOverflowError.d.ts.map

package/dist/types/ts3.7/error/TimeoutError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from './ReportableError';
+export declare class TimeoutError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=TimeoutError.d.ts.map

package/dist/types/ts3.7/error/UnreachableCodeError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating that a line of code was hit that should not be possible.
+ */
+export declare class UnreachableCodeError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor();
+}
+//# sourceMappingURL=UnreachableCodeError.d.ts.map

package/dist/types/ts3.7/error/ValidationError.d.ts

@@ -0,0 +1,17 @@
+import { ReportableError } from '../error/ReportableError';
+import { Json } from '../util/serialization/json';
+/**
+ * An error indicating that input had an invalid shape.
+ */
+export declare class ValidationError extends ReportableError {
+    readonly path: readonly string[];
+    get [Symbol.toStringTag](): string;
+    /**
+     * @param message The validation error message.
+     * @param origin The error origin, typically API (default) or SERVICE_EXTERNAL
+     * @param path The property path to the invalid field.
+     */
+    constructor(message: string, origin?: string, path?: readonly string[]);
+    toJSON(): Json;
+}
+//# sourceMappingURL=ValidationError.d.ts.map

package/dist/types/ts3.7/event/DomEventHost.d.ts

@@ -0,0 +1,45 @@
+import { Disposable } from '../core/disposable';
+import { ReadonlyEventHost } from './EventHost';
+import { EventHandler, SignalOptions } from './Signal';
+import { Unsubscribe } from '../core/Unsubscribe';
+import { ExtractValues } from '../util/type';
+/**
+ * Picks the keys from T that satisfy: `[keyof T extends string]: Event`
+ */
+export type DomEventMap<T> = ExtractValues<Pick<T, keyof T & string>, Event>;
+export interface DomReadonlyEventHost<EventMap> extends ReadonlyEventHost<DomEventMap<EventMap>> {
+    /**
+     * Adds an event handler for the given typed event.
+     *
+     * @param type A case-sensitive string representing the event type to listen for.
+     * @param handler A callback to invoke when the event with the given type is dispatched.
+     * @param options An options object specifies characteristics about the event listener.
+     * @return Returns a method, when invoked, removes the handler.
+     */
+    on<K extends keyof DomEventMap<EventMap>>(type: K, handler: EventHandler<DomEventMap<EventMap>[K]>, options?: DomEventListenerOptions): Unsubscribe;
+}
+/**
+ * Event listener options for DOM events.
+ *
+ * Note: signal not supported, use abort utilities.
+ */
+export interface DomEventListenerOptions extends SignalOptions, Omit<AddEventListenerOptions, 'signal'> {
+}
+/**
+ * Wraps a js `EventTarget` with a {@link ReadonlyEventHost} interface.
+ */
+export declare class DomEventHost<EventMap> implements DomReadonlyEventHost<EventMap>, Disposable {
+    protected readonly eventTarget: EventTarget;
+    private activeSubs;
+    private listenerCounts;
+    constructor(eventTarget: EventTarget);
+    hasAnyListeners(): boolean;
+    hasListeners(type: keyof DomEventMap<EventMap>): boolean;
+    on<K extends keyof DomEventMap<EventMap>>(type: K, handler: EventHandler<DomEventMap<EventMap>[K]>, options?: DomEventListenerOptions): Unsubscribe;
+    /**
+     * Disposal of a DomEventHost removes all listeners.
+     */
+    dispose(): void;
+    __eventMapType: import("../util/type").Covariant<EventMap>;
+}
+//# sourceMappingURL=DomEventHost.d.ts.map

package/dist/types/ts3.7/event/EventHost.d.ts

@@ -0,0 +1,69 @@
+import { Disposable } from '../core/disposable';
+import { EventHandler, SignalOptions } from './Signal';
+import { Unsubscribe } from '../core/Unsubscribe';
+import { Covariant } from '../util/type';
+import { 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/ts3.7/event/Signal.d.ts

@@ -0,0 +1,57 @@
+import { Disposable } from '../core/disposable';
+import { 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/ts3.7/event/nextEventAsPromise.d.ts

@@ -0,0 +1,30 @@
+import { ReadonlyEventHost } from './EventHost';
+import { ReadonlyAbort } from '../util/async/Abort';
+import { 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/ts3.7/event/onAny.d.ts

@@ -0,0 +1,13 @@
+import { Unsubscribe } from '../core/Unsubscribe';
+import { ReadonlyEventHost } from './EventHost';
+import { 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/ts3.7/event/redispatchEvents.d.ts

@@ -0,0 +1,15 @@
+import { EventDispatcher, ReadonlyEventHost } from './EventHost';
+import { 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/ts3.7/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/ts3.7/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/ts3.7/global/globalTarget.d.ts

@@ -0,0 +1,8 @@
+import { 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/ts3.7/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/ts3.7/logging/ConsoleLogHandler.d.ts

@@ -0,0 +1,26 @@
+import { Disposable } from '../core/disposable';
+import { ReadonlyEventHost } from '../event/EventHost';
+import { 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/ts3.7/logging/HistoryLogHandler.d.ts

@@ -0,0 +1,56 @@
+import { Disposable } from '../core/disposable';
+import { ReadonlyEventHost } from '../event/EventHost';
+import { LogEventMap } from './Logger';
+import { LogLevel } from './Logger';
+import { 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/ts3.7/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