@vkontakte/videoplayer-shared 1.0.86-dev.fcdd1bac.0 → 1.0.87-beta.0

package/types/Tracer/RootTracer.d.ts

@@ -0,0 +1,10 @@
+import type { IRootTracer, ITracerParams } from "./types";
+import { Tracer } from "./Tracer";
+import type { 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;
+}

package/types/Tracer/Tracer.d.ts

@@ -0,0 +1,25 @@
+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";
+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;
+}

package/types/Tracer/TracerFactory.d.ts

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

package/types/Tracer/index.d.ts

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

package/types/Tracer/types.d.ts

@@ -0,0 +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";
+export type { TracerOpentelemetry };
+export type { OpentelemetryApi };
+export type { OpentelemetrySdk };
+export declare enum TracerDynamicImportStatus {
+	NotStarted = "not_started",
+	InProgress = "in_progress",
+	Failed = "failed",
+	Completed = "completed"
+}
+export declare enum TraceEventType {
+	Log = "log",
+	Error = "error",
+	Critical = "critical"
+}
+export interface ITracerParams {
+	name: string;
+	getParentContext?: () => Context;
+}
+export interface ITracerDynamicImports {
+	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;
+}
+export interface IRootTracer extends ITracer {
+	getFinishedSpans: () => ReadableSpan[] | undefined;
+	getTraceId: () => string;
+}

package/types/Tracer/utils.d.ts

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

package/types/__polyfills/array.d.ts

@@ -0,0 +1,10 @@
+export declare const arrayAt: (array: readonly unknown[], index: number) => unknown;
+export declare const arrayFindLast: (array: readonly unknown[], predicate: (value: unknown, index: number, array: readonly unknown[]) => boolean) => unknown;
+export declare const arrayFindLastIndex: (array: readonly unknown[], predicate: (value: unknown, index: number, array: readonly unknown[]) => boolean) => number;
+export declare const arrayFlat: (array: readonly unknown[], depth?: number) => unknown[];
+export declare const arrayFlatMap: (array: readonly unknown[], callback: (value: unknown, index: number, array: readonly unknown[]) => unknown) => unknown[];
+export declare const arrayIncludes: (array: readonly unknown[], searchElement: unknown, fromIndex?: number) => boolean;
+export declare const arrayToReversed: (array: readonly unknown[]) => unknown[];
+export declare const arrayToSorted: (array: readonly unknown[], compareFn?: (a: unknown, b: unknown) => number) => unknown[];
+export declare const arrayToSpliced: (array: readonly unknown[], start: number, deleteCount?: number, ...items: unknown[]) => unknown[];
+export declare const arrayWith: (array: readonly unknown[], index: number, value: unknown) => unknown[];

package/types/__polyfills/global.d.ts

@@ -0,0 +1 @@
+export declare const globalThisPolyfill: typeof globalThis;

package/types/__polyfills/index.es2015.d.ts

@@ -0,0 +1,10 @@
+export { arrayIncludes, arrayFlat, arrayFlatMap, arrayAt, arrayFindLast, arrayFindLastIndex, arrayToReversed, arrayToSorted, arrayToSpliced, arrayWith } from "./array";
+export { globalThisPolyfill } from "./global";
+export { objectValues, objectEntries, objectFromEntries, objectHasOwn } from "./object";
+export { promiseFinally, promiseAllSettled, promiseAny, promiseWithResolvers, promiseTry } from "./promise";
+export { fetchPolyfilled, RequestPolyfilled, AbortSignalPolyfilled, AbortControllerPolyfilled } from "./runtime/abortableFetch";
+export { atPolyfilled } from "./runtime/at";
+export { requestIdleCallbackPolyfilled, cancelIdleCallbackPolyfilled } from "./runtime/idleCallback";
+export { includesPolyfilled } from "./runtime/includes";
+export { canParse as urlCanParsePolyfilled } from "./runtime/url.canParse";
+export { stringPadStart, stringPadEnd, stringTrimLeft, stringTrimRight, stringTrimStart, stringTrimEnd, stringMatchAll, stringReplaceAll, stringAt } from "./string";

package/types/__polyfills/index.esnext.d.ts

@@ -0,0 +1,3 @@
+export { fetchPolyfilled, RequestPolyfilled, AbortSignalPolyfilled, AbortControllerPolyfilled } from "./runtime/abortableFetch";
+export { requestIdleCallbackPolyfilled, cancelIdleCallbackPolyfilled } from "./runtime/idleCallback";
+export { canParse as urlCanParsePolyfilled } from "./runtime/url.canParse";

package/types/__polyfills/index.evergreen.d.ts

@@ -0,0 +1 @@
+export {};

package/types/__polyfills/object.d.ts

@@ -0,0 +1,4 @@
+export declare const objectEntries: (obj: object) => [string, unknown][];
+export declare const objectFromEntries: (entries: Iterable<readonly [PropertyKey, unknown]>) => Record<string, unknown>;
+export declare const objectHasOwn: (obj: object, key: PropertyKey) => boolean;
+export declare const objectValues: (obj: object) => unknown[];

package/types/__polyfills/promise.d.ts

@@ -0,0 +1,32 @@
+/**
+* Минимальные полифиллы для Promise-методов.
+*/
+/**
+* Полифилл Promise.allSettled — ждёт завершения всех промисов,
+* возвращая массив результатов { status, value/reason }.
+*/
+export declare const promiseAllSettled: (promises: Iterable<unknown>) => Promise<PromiseSettledResult<unknown>[]>;
+/**
+* Полифилл Promise.any — резолвится первым успешным промисом,
+* реджектится с AggregateError если все промисы отклонены.
+*/
+export declare const promiseAny: (promises: Iterable<unknown>) => Promise<unknown>;
+/**
+* Полифилл Promise.prototype.finally — выполняет onFinally при любом исходе,
+* сохраняя оригинальное значение resolve/reject.
+*/
+export declare const promiseFinally: (promise: Promise<unknown>, onFinally: () => void) => Promise<unknown>;
+/**
+* Полифилл Promise.try — выполняет функцию синхронно,
+* оборачивая результат или брошенную ошибку в промис.
+*/
+export declare const promiseTry: (fn: () => unknown) => Promise<unknown>;
+/**
+* Полифилл Promise.withResolvers — создаёт промис вместе с его
+* resolve/reject функциями для внешнего управления.
+*/
+export declare const promiseWithResolvers: () => {
+	promise: Promise<unknown>;
+	resolve: (value: unknown) => void;
+	reject: (reason?: unknown) => void;
+};

package/types/__polyfills/runtime/abortableFetch.d.ts

@@ -0,0 +1,4 @@
+export declare const fetchPolyfilled: typeof fetch;
+export declare const RequestPolyfilled: typeof Request;
+export declare const AbortControllerPolyfilled: typeof AbortController;
+export declare const AbortSignalPolyfilled: typeof AbortSignal;

package/types/__polyfills/runtime/at.d.ts

@@ -0,0 +1 @@
+export declare const atPolyfilled: (obj: any, index: number) => unknown;

package/types/__polyfills/runtime/idleCallback.d.ts

@@ -0,0 +1,3 @@
+import { root } from "./window";
+export declare const requestIdleCallbackPolyfilled: typeof root.requestIdleCallback;
+export declare const cancelIdleCallbackPolyfilled: typeof root.cancelIdleCallback;

package/types/__polyfills/runtime/includes.d.ts

@@ -0,0 +1 @@
+export declare const includesPolyfilled: (obj: any, searchElement: unknown, fromIndex?: number) => boolean;

package/types/__polyfills/runtime/url.canParse.d.ts

@@ -0,0 +1,3 @@
+type URLCanParse = (URLGlobal: typeof URL, ...args: Parameters<typeof URL.canParse>) => ReturnType<typeof URL.canParse>;
+declare const canParse: URLCanParse;
+export { canParse };

package/types/__polyfills/runtime/window.d.ts

@@ -0,0 +1 @@
+export declare const root: Window & typeof globalThis;

package/types/__polyfills/string.d.ts

@@ -0,0 +1,9 @@
+export declare const stringAt: (str: string, index: number) => string | undefined;
+export declare function stringMatchAll(str: string, regexp: RegExp): IterableIterator<RegExpMatchArray>;
+export declare const stringPadEnd: (str: string, targetLength: number, padString?: string) => string;
+export declare const stringPadStart: (str: string, targetLength: number, padString?: string) => string;
+export declare const stringReplaceAll: (str: string, searchValue: string | RegExp, replaceValue: string | ((match: string, ...args: unknown[]) => string)) => string;
+export declare const stringTrimStart: (str: string) => string;
+export declare const stringTrimEnd: (str: string) => string;
+export declare const stringTrimLeft: (str: string) => string;
+export declare const stringTrimRight: (str: string) => string;

package/types/devNull.d.ts

@@ -0,0 +1,14 @@
+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>;
+}
+type Callback = (entry: DevNullEntry) => void;
+type TempStorage = DevNullEntry[];
+export declare const create: (ownerName: string, callback?: Callback) => Map<string, Callback | TempStorage>;
+export declare const destroy: (ownerName: string) => boolean;
+export declare const push: (ownerName: string, entry: DevNullEntry) => void;
+export declare const subscribe: (ownerName: string, callback: Callback) => void;
+export {};

package/types/env.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/types/index.d.ts

@@ -0,0 +1,13 @@
+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 * from './__polyfills/index.es2015';

package/types/reactive/Observable.d.ts

@@ -0,0 +1,14 @@
+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;
+}

package/types/reactive/ReplaySubject.d.ts

@@ -0,0 +1,12 @@
+import type { ISubject } from "./types";
+import { type IEmitter, 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;
+}

package/types/reactive/Subject.d.ts

@@ -0,0 +1,10 @@
+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;
+}

package/types/reactive/Subscription.d.ts

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

package/types/reactive/SubscriptionRemovable.d.ts

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

package/types/reactive/ValueSubject.d.ts

@@ -0,0 +1,10 @@
+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;
+}

package/types/reactive/combine.d.ts

@@ -0,0 +1,7 @@
+import type { IObservable, TypeOfObservable } from "./types";
+/**
+*  Создаёт 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>>;

package/types/reactive/fromEvent.d.ts

@@ -0,0 +1,7 @@
+import type { IObservable } from "./types";
+interface IEventTarget {
+	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

@@ -0,0 +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";

package/types/reactive/interval.d.ts

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

package/types/reactive/merge.d.ts

@@ -0,0 +1,82 @@
+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

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

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

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

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

@@ -0,0 +1,7 @@
+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>;

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

@@ -0,0 +1,6 @@
+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>;

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

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+/**
+* Пропускает только события, содержащие значения, отличные от предыдущего
+*/
+export default function filterChanged<T>(equal?: (prev: T, next: T) => boolean): IOperator<T>;

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

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+export default function map<
+	T,
+	S
+>(mapper: (value: T) => S): IOperator<T, S>;

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

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+export default function mapTo<
+	T,
+	S
+>(value: S): IOperator<T, S>;

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

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+/**
+*  Отписывается от исходного потока после получения первого события.
+*/
+export default function once<T>(): IOperator<T>;

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

@@ -0,0 +1,3 @@
+import type { IOperator } from "../types";
+type IPair<T> = [previous: T, current: T];
+export default function pairwise<T>(): IOperator<T, IPair<T>>;

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

@@ -0,0 +1,2 @@
+import type { IOperator } from "..";
+export default function shareReplay<T>(bufferSize?: number | undefined): IOperator<T>;

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

@@ -0,0 +1,6 @@
+import type { IOperator } from "..";
+/**
+* Пропускает первые count событий
+* @param count
+*/
+export default function skip<T>(count: number): IOperator<T>;

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

@@ -0,0 +1,2 @@
+import type { IOperator } from "../types";
+export default function tap<T>(effect: (value: T) => void): IOperator<T>;

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

@@ -0,0 +1,6 @@
+import type { IOperator } from "../types";
+interface ThrottleConfig {
+	leading: boolean;
+	trailing: boolean;
+}
+export default function throttle<T>(time: number, config?: ThrottleConfig): IOperator<T>;

package/types/reactive/timeout.d.ts

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

package/types/reactive/types.d.ts

@@ -0,0 +1,53 @@
+export type IUnsubscriber = () => void;
+export interface ISubscription {
+	unsubscribe: IUnsubscriber;
+	add(item: ISubscription | IUnsubscriber): ISubscription;
+}
+export interface IObservable<T> {
+	subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
+	/**
+	* @deprecated Глушить ошибки не стоит.
+	* Раньше у нас они по-умолчанию ошибочно глушились что маскировало многие исключения, в том числе грубые ошибки
+	* Этот метод нужен чтобы временно поддержать старрое поведение пока маскиуремые ошибки не исправятся
+	*/
+	setSuppressErrors(suppress: boolean): void;
+	pipe<T1>(op1: IOperator<T, T1>): IObservable<T1>;
+	pipe<
+		T1,
+		T2
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>): IObservable<T2>;
+	pipe<
+		T1,
+		T2,
+		T3
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>, op3: IOperator<T2, T3>): IObservable<T3>;
+	pipe<
+		T1,
+		T2,
+		T3,
+		T4
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>, op3: IOperator<T2, T3>, op4: IOperator<T3, T4>): IObservable<T4>;
+	pipe<
+		T1,
+		T2,
+		T3,
+		T4,
+		T5
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>, op3: IOperator<T2, T3>, op4: IOperator<T3, T4>, op5: IOperator<T4, T5>): IObservable<T5>;
+}
+export interface IValue<T> {
+	getValue(): T;
+}
+export interface IEmitter<T> {
+	next(value: T): void;
+	error?(value: Error | unknown): void;
+}
+export interface IValueObservable<T> extends IObservable<T>, IValue<T> {}
+export interface ISubject<T> extends IEmitter<T>, IObservable<T> {}
+export interface IValueSubject<T> extends IEmitter<T>, IValueObservable<T> {}
+export type IListener<T> = IEmitter<T> | ((value: T) => void) | ((value: T) => Promise<void>);
+export type IOperator<
+	TInput,
+	TOutput = TInput
+> = (input: IObservable<TInput>) => IObservable<TOutput>;
+export type TypeOfObservable<TObservable> = TObservable extends IObservable<infer TType> ? TType : never;

package/types/translation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./loadVKLangPack";
+export * from "./types";

package/types/translation/loadVKLangPack.d.ts

@@ -0,0 +1,16 @@
+import type { StringRecord } from "./types";
+export declare enum VKNumericLanguage {
+	Armenian = "58",
+	Azerbaijani = "57",
+	Belarusian = "114",
+	English = "3",
+	Kazakh = "97",
+	Portuguese = "73",
+	Russian = "0",
+	Spanish = "4",
+	Ukrainian = "1",
+	Uzbek = "65",
+	Vietnamese = "75"
+}
+export type VKLanguage = VKNumericLanguage | string;
+export declare const loadVKLangPack: <T extends StringRecord>(language: VKLanguage, packName: string, packPrefix: string) => Promise<T>;

package/types/translation/types.d.ts

@@ -0,0 +1,5 @@
+export declare enum InterfaceLanguage {
+	RU = "ru",
+	EN = "en"
+}
+export type StringRecord = Record<string, string>;