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

package/types/reactive/ReplaySubject.d.ts

@@ -1,11 +1,12 @@
-import { type IEmitter, ISubject, type ISubscription, type IUnsubscriber } from './types';
-import SubjectMY from './Subject';
+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;
+	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 { ISubscription, IUnsubscriber } from './types';
+import Subscription from "./Subscription";
+import type { 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,10 +1,7 @@
-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 { Milliseconds } from '../utils';
-import type { IObservable } from './types';
+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

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

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

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

@@ -1,5 +1,5 @@
-import type { IOperator } from '../types';
+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

@@ -1,2 +1,5 @@
-import type { IOperator } from '../types';
-export default function map<T, S>(mapper: (value: T) => S): IOperator<T, S>;
+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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,6 @@
-import type { IOperator } from '../types';
-export default function throttle<T>(time: number, config?: {
-    leading: boolean;
-    trailing: boolean;
-}): IOperator<T>;
+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

@@ -1,4 +1,4 @@
-import { Milliseconds } from '../utils';
-import type { IObservable } from './types';
+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

@@ -1,29 +1,47 @@
 export type IUnsubscriber = () => void;
 export interface ISubscription {
-    unsubscribe: IUnsubscriber;
-    add(item: ISubscription | IUnsubscriber): ISubscription;
+	unsubscribe: IUnsubscriber;
+	add(item: ISubscription | IUnsubscriber): ISubscription;
 }
 export interface IObservable<T> {
-    subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
-    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>;
+	subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
+	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;
+	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>, IObservable<T>, IValue<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>, IObservable<T>, IValue<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 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

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

package/types/translation/loadVKLangPack.d.ts

@@ -1,16 +1,16 @@
-import type { StringRecord } from './types';
+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"
+	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

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