@vkontakte/videoplayer-shared 1.0.83-dev.b2d1f4f2.0 → 1.0.83-dev.b507ef65.0

package/types/Logger/types.d.ts

@@ -1,29 +1,30 @@
-import type { IObservable } from "../reactive/types";
+import type { IObservable } from '../reactive/types';
 export interface ILogger {
-	log: (entry: ILogInputEntry) => void;
-	createCustomLog: <TArgs extends unknown[]>(transform: (...args: TArgs) => ILogInputEntry) => (...args: TArgs) => void;
-	createComponentLog: (component: string) => IComponentLogger;
-	getAllLogs: () => ILogEntry[];
-	log$: IObservable<ILogEntry>;
+    log: (entry: ILogInputEntry) => void;
+    createCustomLog: <TArgs extends unknown[]>(transform: (...args: TArgs) => ILogInputEntry) => (...args: TArgs) => void;
+    createComponentLog: (component: string) => IComponentLogger;
+    getAllLogs: () => ILogEntry[];
+    log$: IObservable<ILogEntry>;
 }
 export interface ILogEntry {
-	/**
-	* Сообщение.
-	*/
-	message: string;
-	/**
-	* Компонент, в котором залогировано событие. (модуль, класс или функция)
-	*/
-	component: string;
-	/**
-	* Время, в которое случилось логируемое событие
-	*/
-	timestamp: number;
+    /**
+     * Сообщение.
+     */
+    message: string;
+    /**
+     * Компонент, в котором залогировано событие. (модуль, класс или функция)
+     */
+    component: string;
+    /**
+     * Время, в которое случилось логируемое событие
+     */
+    timestamp: number;
 }
 export type IComponentLogger = (entry: IComponentLogEntry) => void;
-export type ILogInputEntry = Omit<ILogEntry, "timestamp">;
-export interface IComponentLogEntry extends Omit<ILogInputEntry, "component">, IOptionalComponent {}
+export type ILogInputEntry = Omit<ILogEntry, 'timestamp'>;
+export interface IComponentLogEntry extends Omit<ILogInputEntry, 'component'>, IOptionalComponent {
+}
 interface IOptionalComponent {
-	component?: ILogInputEntry["component"];
+    component?: ILogInputEntry['component'];
 }
 export {};

package/types/Tracer/FakeTracer.d.ts

@@ -1,13 +1,13 @@
-import type { IRootTracer, ITracer, ITracerParams } from "./types";
-import type { Attributes } from "@opentelemetry/api";
+import { IRootTracer, ITracer, ITracerParams } from '../Tracer/types';
+import type { Attributes } from '@opentelemetry/api';
 export declare class FakeTracer implements IRootTracer {
-	private readonly fakeTraceId;
-	constructor(params?: Partial<ITracerParams>);
-	log(name: string, attributes?: Attributes): void;
-	error(name: string, attributes?: Attributes): void;
-	critical(name: string, attributes?: Attributes): void;
-	createComponentTracer(name: string): ITracer;
-	end(): void;
-	getFinishedSpans(): any | undefined;
-	getTraceId(): string;
+    private readonly fakeTraceId;
+    constructor(params?: Partial<ITracerParams>);
+    log(name: string, attributes?: Attributes): void;
+    error(name: string, attributes?: Attributes): void;
+    critical(name: string, attributes?: Attributes): void;
+    createComponentTracer(name: string): ITracer;
+    end(): void;
+    getFinishedSpans(): any | undefined;
+    getTraceId(): string;
 }

package/types/Tracer/RootTracer.d.ts

@@ -1,10 +1,10 @@
-import type { IRootTracer, ITracerParams } from "./types";
-import { Tracer } from "./Tracer";
-import type { Milliseconds } from "../utils";
+import { IRootTracer, ITracerParams } from '../Tracer/types';
+import { Tracer } from '../Tracer/Tracer';
+import { Milliseconds } from '../utils';
 export declare class RootTracer extends Tracer implements IRootTracer {
-	private spanExporter;
-	constructor();
-	protected init({ name, getParentContext }: ITracerParams, startTime: Milliseconds): void;
-	getFinishedSpans(): any | undefined;
-	getTraceId(): string;
+    private spanExporter;
+    constructor();
+    protected init({ name, getParentContext }: ITracerParams, startTime: Milliseconds): void;
+    getFinishedSpans(): any | undefined;
+    getTraceId(): string;
 }

package/types/Tracer/Tracer.d.ts

@@ -1,25 +1,24 @@
-import type { Tracer as OtlpTracer } from "@opentelemetry/sdk-trace-web";
-import type { Attributes, Context, Span } from "@opentelemetry/api";
-import type { ITracer, ITracerDynamicImports, ITracerParams } from "./types";
-import { TracerDynamicImportStatus } from "./types";
-import type { Milliseconds } from "../utils";
+import type { Tracer as OtlpTracer } from '@opentelemetry/sdk-trace-web';
+import type { Attributes, Context, Span } from '@opentelemetry/api';
+import { ITracer, ITracerDynamicImports, ITracerParams, TracerDynamicImportStatus } from './types';
+import { Milliseconds } from '../utils';
 export declare class Tracer implements ITracer {
-	private readonly dynamicImportTimeout;
-	protected span: Span;
-	protected context: Context;
-	protected childTracers: ITracer[];
-	protected initPromise: Promise<void>;
-	protected static rootTracer: OtlpTracer;
-	protected static dynamicImportStatus: TracerDynamicImportStatus;
-	protected static dynamicImports: ITracerDynamicImports;
-	protected static dynamicImportPromise: Promise<void>;
-	protected constructor({ name, getParentContext }: ITracerParams);
-	protected init({ name, getParentContext }: ITracerParams, startTime: Milliseconds): void;
-	private loadOpentelemetry;
-	protected isComponentTracerNotInitialized(): boolean;
-	log(name: string, attributes?: Attributes): void;
-	error(name: string, attributes?: Attributes): void;
-	critical(name: string, attributes?: Attributes): void;
-	createComponentTracer(name: string): ITracer;
-	end(): void;
+    private readonly dynamicImportTimeout;
+    protected span: Span;
+    protected context: Context;
+    protected childTracers: ITracer[];
+    protected initPromise: Promise<void>;
+    protected static rootTracer: OtlpTracer;
+    protected static dynamicImportStatus: TracerDynamicImportStatus;
+    protected static dynamicImports: ITracerDynamicImports;
+    protected static dynamicImportPromise: Promise<void>;
+    protected constructor({ name, getParentContext }: ITracerParams);
+    protected init({ name, getParentContext }: ITracerParams, startTime: Milliseconds): void;
+    private loadOpentelemetry;
+    protected isComponentTracerNotInitialized(): boolean;
+    log(name: string, attributes?: Attributes): void;
+    error(name: string, attributes?: Attributes): void;
+    critical(name: string, attributes?: Attributes): void;
+    createComponentTracer(name: string): ITracer;
+    end(): void;
 }

package/types/Tracer/TracerFactory.d.ts

@@ -1,4 +1,4 @@
-import type { IRootTracer } from "./types";
+import { IRootTracer } from '../Tracer/types';
 export declare class TracerFactory {
-	static createRootTracer(isRealTracer?: boolean): IRootTracer;
+    static createRootTracer(isRealTracer?: boolean): IRootTracer;
 }

package/types/Tracer/index.d.ts

@@ -1,3 +1,3 @@
-export { TracerFactory } from "./TracerFactory";
-export type { ITracer, IRootTracer } from "./types";
-export { getTraceSubscriptionMethod } from "./utils";
+export { TracerFactory } from './TracerFactory';
+export { ITracer, IRootTracer } from './types';
+export { getTraceSubscriptionMethod } from './utils';

package/types/Tracer/types.d.ts

@@ -1,39 +1,39 @@
-import type { Attributes, Context } from "@opentelemetry/api";
-import type { ReadableSpan } from "@opentelemetry/sdk-trace-web";
-import type * as TracerOpentelemetry from "@apptracer/opentelemetry";
-import type * as OpentelemetryApi from "@opentelemetry/api";
-import type * as OpentelemetrySdk from "@opentelemetry/sdk-trace-web";
+import type { Attributes, Context } from '@opentelemetry/api';
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-web';
+import type * as TracerOpentelemetry from '@apptracer/opentelemetry';
+import type * as OpentelemetryApi from '@opentelemetry/api';
+import type * as OpentelemetrySdk from '@opentelemetry/sdk-trace-web';
 export type { TracerOpentelemetry };
 export type { OpentelemetryApi };
 export type { OpentelemetrySdk };
 export declare enum TracerDynamicImportStatus {
-	NotStarted = "not_started",
-	InProgress = "in_progress",
-	Failed = "failed",
-	Completed = "completed"
+    NotStarted = "not_started",
+    InProgress = "in_progress",
+    Failed = "failed",
+    Completed = "completed"
 }
 export declare enum TraceEventType {
-	Log = "log",
-	Error = "error",
-	Critical = "critical"
+    Log = "log",
+    Error = "error",
+    Critical = "critical"
 }
 export interface ITracerParams {
-	name: string;
-	getParentContext?: () => Context;
+    name: string;
+    getParentContext?: () => Context;
 }
 export interface ITracerDynamicImports {
-	opentelemetryApi: typeof OpentelemetryApi;
-	opentelemetrySdk: typeof OpentelemetrySdk;
-	tracer: typeof TracerOpentelemetry;
+    opentelemetryApi: typeof OpentelemetryApi;
+    opentelemetrySdk: typeof OpentelemetrySdk;
+    tracer: typeof TracerOpentelemetry;
 }
 export interface ITracer {
-	log: (name: string, attributes?: Attributes) => void;
-	error: (name: string, attributes?: Attributes) => void;
-	critical: (name: string, attributes?: Attributes) => void;
-	createComponentTracer: (name: string) => ITracer;
-	end: () => void;
+    log: (name: string, attributes?: Attributes) => void;
+    error: (name: string, attributes?: Attributes) => void;
+    critical: (name: string, attributes?: Attributes) => void;
+    createComponentTracer: (name: string) => ITracer;
+    end: () => void;
 }
 export interface IRootTracer extends ITracer {
-	getFinishedSpans: () => ReadableSpan[] | undefined;
-	getTraceId: () => string;
+    getFinishedSpans: () => ReadableSpan[] | undefined;
+    getTraceId: () => string;
 }

package/types/Tracer/utils.d.ts

@@ -1,3 +1,3 @@
-import type { Attributes } from "@opentelemetry/api";
-export declare const getTraceSubscriptionMethod: (log: (name: string, attributes?: Attributes) => void) => ((name: string) => (value: unknown) => void);
+import { Attributes } from '@opentelemetry/api';
+export declare const getTraceSubscriptionMethod: (log: (name: string, attributes?: Attributes) => void) => (name: string) => (value: any) => void;
 export declare const replaceUnsupportedValuesByStrings: (obj?: Attributes | undefined) => Attributes;

package/types/devNull.d.ts

@@ -1,9 +1,9 @@
 type DevNullValueArray<T> = [T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?];
 export interface DevNullEntry {
-	key: string;
-	json?: string;
-	strings?: DevNullValueArray<string>;
-	numbers?: DevNullValueArray<number>;
+    key: string;
+    json?: string;
+    strings?: DevNullValueArray<string>;
+    numbers?: DevNullValueArray<number>;
 }
 type Callback = (entry: DevNullEntry) => void;
 type TempStorage = DevNullEntry[];

package/types/index.d.ts

@@ -1,11 +1,11 @@
-export { VERSION } from "./env";
-export * from "./Logger";
-export * from "./Tracer";
-export * from "./utils";
-export * from "./reactive";
-export * from "./types";
-export * from "./translation";
-export * from "./InternalsExposure";
-export * as devNull from "./devNull";
-export type { DevNullEntry } from "./devNull";
-export * from "./AppTracer";
+export { VERSION } from './env';
+export * from './Logger';
+export * from './Tracer';
+export * from './utils';
+export * from './reactive';
+export * from './types';
+export * from './translation';
+export * from './InternalsExposure';
+export * as devNull from './devNull';
+export { DevNullEntry } from './devNull';
+export * from './AppTracer';

package/types/reactive/Observable.d.ts

@@ -1,14 +1,14 @@
-import type { IEmitter, IListener, IObservable, IOperator, ISubscription, IUnsubscriber } from "./types";
+import type { IEmitter, IListener, IObservable, IOperator, ISubscription, IUnsubscriber } from './types';
 export default class Observable<T> implements IObservable<T> {
-	private suppressErrors;
-	constructor(subscribe?: (emitter: IEmitter<T>) => IUnsubscriber | ISubscription | void);
-	/**
-	* @deprecated Глушить ошибки не стоит.
-	* Раньше у нас они по-умолчанию ошибочно глушились что маскировало многие исключения, в том числе грубые ошибки
-	* Этот метод нужен чтобы временно поддержать старрое поведение пока маскиуремые ошибки не исправятся
-	*/
-	setSuppressErrors(suppress: boolean): void;
-	subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
-	pipe<K = unknown>(...operators: IOperator<unknown, unknown>[]): IObservable<K>;
-	protected _subscribe(_emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+    private suppressErrors;
+    constructor(subscribe?: (emitter: IEmitter<T>) => IUnsubscriber | ISubscription | void);
+    /**
+     * @deprecated Глушить ошибки не стоит.
+     * Раньше у нас они по-умолчанию ошибочно глушились что маскировало многие исключения, в том числе грубые ошибки
+     * Этот метод нужен чтобы временно поддержать старрое поведение пока маскиуремые ошибки не исправятся
+     */
+    setSuppressErrors(suppress: boolean): void;
+    subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
+    pipe<K = unknown>(...operators: IOperator<unknown, unknown>[]): IObservable<K>;
+    protected _subscribe(_emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
 }

package/types/reactive/ReplaySubject.d.ts

@@ -1,12 +1,11 @@
-import type { ISubject } from "./types";
-import { type IEmitter, type ISubscription, type IUnsubscriber } from "./types";
-import SubjectMY from "./Subject";
+import { type IEmitter, ISubject, type ISubscription, type IUnsubscriber } from './types';
+import SubjectMY from './Subject';
 export default class ReplaySubject<T> extends SubjectMY<T> implements ISubject<T> {
-	private readonly bufferSize;
-	private readonly buffer;
-	private cursorEnd;
-	private cursorStart;
-	constructor(bufferSize: number);
-	next(value: T): void;
-	protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+    private readonly bufferSize;
+    private readonly buffer;
+    private cursorEnd;
+    private cursorStart;
+    constructor(bufferSize: number);
+    next(value: T): void;
+    protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
 }

package/types/reactive/Subject.d.ts

@@ -1,10 +1,10 @@
-import type { IEmitter, ISubject, ISubscription, IUnsubscriber } from "./types";
-import Observable from "./Observable";
+import type { IEmitter, ISubject, ISubscription, IUnsubscriber } from './types';
+import Observable from './Observable';
 export default class Subject<T> extends Observable<T> implements ISubject<T> {
-	protected keyCounter: number;
-	protected subscribers: Map<number, IEmitter<T>>;
-	constructor();
-	next(value: T): void;
-	error(value: T): void;
-	protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+    protected keyCounter: number;
+    protected subscribers: Map<number, IEmitter<T>>;
+    constructor();
+    next(value: T): void;
+    error(value: T): void;
+    protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
 }

package/types/reactive/Subscription.d.ts

@@ -1,6 +1,6 @@
-import type { ISubscription, IUnsubscriber } from "./types";
+import type { ISubscription, IUnsubscriber } from './types';
 export default class Subscription implements ISubscription {
-	protected subscriptions: Array<(() => void) | ISubscription>;
-	unsubscribe(): void;
-	add(item: ISubscription | IUnsubscriber): ISubscription;
+    protected subscriptions: Array<(() => void) | ISubscription>;
+    unsubscribe(): void;
+    add(item: ISubscription | IUnsubscriber): ISubscription;
 }

package/types/reactive/SubscriptionRemovable.d.ts

@@ -1,5 +1,5 @@
-import Subscription from "./Subscription";
-import type { ISubscription, IUnsubscriber } from "./types";
+import Subscription from './Subscription';
+import { ISubscription, IUnsubscriber } from './types';
 export default class SubscriptionRemovable extends Subscription {
-	remove(item: ISubscription | IUnsubscriber): void;
+    remove(item: ISubscription | IUnsubscriber): void;
 }

package/types/reactive/ValueSubject.d.ts

@@ -1,10 +1,10 @@
-import type { IEmitter, ISubscription, IUnsubscriber, IValueSubject } from "./types";
-import Subject from "./Subject";
+import type { IEmitter, ISubscription, IUnsubscriber, IValueSubject } from './types';
+import Subject from './Subject';
 export default class ValueSubject<T> extends Subject<T> implements IValueSubject<T> {
-	private value;
-	constructor(initialValue: T);
-	next(value: T): void;
-	error(value: T): void;
-	getValue(): T;
-	protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+    private value;
+    constructor(initialValue: T);
+    next(value: T): void;
+    error(value: T): void;
+    getValue(): T;
+    protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
 }

package/types/reactive/combine.d.ts

@@ -1,7 +1,10 @@
-import type { IObservable, TypeOfObservable } from "./types";
+import type { IObservable, TypeOfObservable } from './types';
 /**
-*  Создаёт Observable, который состоит из объектов, ключами которых являются последние значения исходных Observable.
-*  Первое событие возникает тогда, когда каждый исходный Observable выдал хотя бы одно значение.
-*/
-type CombineObservables<T extends Record<string, IObservable<unknown>>> = { [key in keyof T] : TypeOfObservable<T[key]> };
+ *  Создаёт Observable, который состоит из объектов, ключами которых являются последние значения исходных Observable.
+ *  Первое событие возникает тогда, когда каждый исходный Observable выдал хотя бы одно значение.
+ */
+type CombineObservables<T extends Record<string, IObservable<unknown>>> = {
+    [key in keyof T]: TypeOfObservable<T[key]>;
+};
 export default function combine<T extends Record<string, IObservable<unknown>>>(observables: T): IObservable<CombineObservables<T>>;
+export {};

package/types/reactive/fromEvent.d.ts

@@ -1,7 +1,7 @@
-import type { IObservable } from "./types";
+import type { IObservable } from './types';
 interface IEventTarget {
-	addEventListener(type: string, handler: (...params: any[]) => void): void;
-	removeEventListener(type: string, handler: (...params: any[]) => void): void;
+    addEventListener(type: string, handler: (...params: any[]) => void): void;
+    removeEventListener(type: string, handler: (...params: any[]) => void): void;
 }
 declare const _default: <T>(target: IEventTarget, eventName: string) => IObservable<T>;
 export default _default;

package/types/reactive/index.d.ts

@@ -1,25 +1,25 @@
-export { default as Subscription } from "./Subscription";
-export { default as Observable } from "./Observable";
-export { default as Subject } from "./Subject";
-export { default as ReplaySubject } from "./ReplaySubject";
-export { default as ValueSubject } from "./ValueSubject";
-export { default as combine } from "./combine";
-export { default as merge } from "./merge";
-export { default as timeout } from "./timeout";
-export { default as interval } from "./interval";
-export { default as observableFrom } from "./observableFrom";
-export { default as fromEvent } from "./fromEvent";
-export { default as SubscriptionRemovable } from "./SubscriptionRemovable";
-export { default as buffer } from "./operators/buffer";
-export { default as debounce } from "./operators/debounce";
-export { default as throttle } from "./operators/throttle";
-export { default as filter } from "./operators/filter";
-export { default as filterChanged } from "./operators/filterChanged";
-export { default as map } from "./operators/map";
-export { default as mapTo } from "./operators/mapTo";
-export { default as once } from "./operators/once";
-export { default as pairwise } from "./operators/pairwise";
-export { default as tap } from "./operators/tap";
-export { default as skip } from "./operators/skip";
-export { default as shareReplay } from "./operators/shareReplay";
-export type { ISubscription, IUnsubscriber, IObservable, ISubject, IValueSubject, IValueObservable, IListener, IEmitter, IValue, IOperator } from "./types";
+export { default as Subscription } from './Subscription';
+export { default as Observable } from './Observable';
+export { default as Subject } from './Subject';
+export { default as ReplaySubject } from './ReplaySubject';
+export { default as ValueSubject } from './ValueSubject';
+export { default as combine } from './combine';
+export { default as merge } from './merge';
+export { default as timeout } from './timeout';
+export { default as interval } from './interval';
+export { default as observableFrom } from './observableFrom';
+export { default as fromEvent } from './fromEvent';
+export { default as SubscriptionRemovable } from './SubscriptionRemovable';
+export { default as buffer } from './operators/buffer';
+export { default as debounce } from './operators/debounce';
+export { default as throttle } from './operators/throttle';
+export { default as filter } from './operators/filter';
+export { default as filterChanged } from './operators/filterChanged';
+export { default as map } from './operators/map';
+export { default as mapTo } from './operators/mapTo';
+export { default as once } from './operators/once';
+export { default as pairwise } from './operators/pairwise';
+export { default as tap } from './operators/tap';
+export { default as skip } from './operators/skip';
+export { default as shareReplay } from './operators/shareReplay';
+export type { ISubscription, IUnsubscriber, IObservable, ISubject, IValueSubject, IValueObservable, IListener, IEmitter, IValue, IOperator, } from './types';

package/types/reactive/interval.d.ts

@@ -1,4 +1,4 @@
-import type { Milliseconds } from "../utils";
-import type { IObservable } from "./types";
+import { Milliseconds } from '../utils';
+import type { IObservable } from './types';
 declare const _default: (time: Milliseconds) => IObservable<void>;
 export default _default;

package/types/reactive/merge.d.ts

@@ -1,82 +1,12 @@
-import type { IObservable } from "./types";
-export default function merge<
-	T1,
-	T2
->(v1: IObservable<T1>, v2: IObservable<T2>): IObservable<T1 | T2>;
-export default function merge<
-	T1,
-	T2,
-	T3
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>): IObservable<T1 | T2 | T3>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>): IObservable<T1 | T2 | T3 | T4>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4,
-	T5
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>): IObservable<T1 | T2 | T3 | T4 | T5>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
-export default function merge<
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10
->(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>, v10: IObservable<T10>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
+import type { IObservable } from './types';
+export default function merge<T1, T2>(v1: IObservable<T1>, v2: IObservable<T2>): IObservable<T1 | T2>;
+export default function merge<T1, T2, T3>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>): IObservable<T1 | T2 | T3>;
+export default function merge<T1, T2, T3, T4>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>): IObservable<T1 | T2 | T3 | T4>;
+export default function merge<T1, T2, T3, T4, T5>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>): IObservable<T1 | T2 | T3 | T4 | T5>;
+export default function merge<T1, T2, T3, T4, T5, T6>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
+export default function merge<T1, T2, T3, T4, T5, T6>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7, T8>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>, v10: IObservable<T10>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
 export default function merge<R>(...observables: IObservable<unknown>[]): IObservable<R>;

package/types/reactive/observableFrom.d.ts

@@ -1,3 +1,3 @@
-import type { IObservable } from "./types";
+import type { IObservable } from './types';
 declare const _default: <T>(values: T[]) => IObservable<T>;
 export default _default;

package/types/reactive/operators/buffer.d.ts

@@ -1,2 +1,2 @@
-import type { IOperator } from "../types";
+import type { IOperator } from '../types';
 export default function buffer<T>(size: number): IOperator<T, T[]>;

package/types/reactive/operators/debounce.d.ts

@@ -1,7 +1,6 @@
-import type { Milliseconds } from "../../utils/semanticTypes";
-import type { IOperator } from "../types";
-interface DebounceConfig {
-	leading: boolean;
-	trailing: boolean;
-}
-export default function debounce<T>(time: Milliseconds, config?: DebounceConfig): IOperator<T>;
+import type { Milliseconds } from '../../utils/semanticTypes';
+import type { IOperator } from '../types';
+export default function debounce<T>(time: Milliseconds, config?: {
+    leading: boolean;
+    trailing: boolean;
+}): IOperator<T>;

package/types/reactive/operators/filter.d.ts

@@ -1,6 +1,3 @@
-import type { IOperator } from "../types";
-export default function filter<
-	T,
-	S extends T
->(predicate: (value: T) => value is S): IOperator<T, S>;
+import type { IOperator } from '../types';
+export default function filter<T, S extends T>(predicate: (value: T) => value is S): IOperator<T, S>;
 export default function filter<T>(predicate: (value: T) => boolean): IOperator<T>;