hy-rtc-core-v3 3.2.0 → 3.3.0

package/dist/types/proto/proto-ts/google/protobuf/empty.d.ts

@@ -0,0 +1,32 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ */
+export interface Empty {
+}
+export declare const Empty: {
+    encode(_: Empty, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Empty;
+    fromJSON(_: any): Empty;
+    toJSON(_: Empty): unknown;
+    create<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(base?: I): Empty;
+    fromPartial<I_1 extends {} & {} & { [K_1 in Exclude<keyof I_1, never>]: never; }>(_: I_1): Empty;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/dist/types/proto/proto-ts/google/protobuf/wrappers.d.ts

@@ -0,0 +1,238 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * Wrapper message for `double`.
+ *
+ * The JSON representation for `DoubleValue` is JSON number.
+ */
+export interface DoubleValue {
+    /** The double value. */
+    value: number;
+}
+/**
+ * Wrapper message for `float`.
+ *
+ * The JSON representation for `FloatValue` is JSON number.
+ */
+export interface FloatValue {
+    /** The float value. */
+    value: number;
+}
+/**
+ * Wrapper message for `int64`.
+ *
+ * The JSON representation for `Int64Value` is JSON string.
+ */
+export interface Int64Value {
+    /** The int64 value. */
+    value: number;
+}
+/**
+ * Wrapper message for `uint64`.
+ *
+ * The JSON representation for `UInt64Value` is JSON string.
+ */
+export interface UInt64Value {
+    /** The uint64 value. */
+    value: number;
+}
+/**
+ * Wrapper message for `int32`.
+ *
+ * The JSON representation for `Int32Value` is JSON number.
+ */
+export interface Int32Value {
+    /** The int32 value. */
+    value: number;
+}
+/**
+ * Wrapper message for `uint32`.
+ *
+ * The JSON representation for `UInt32Value` is JSON number.
+ */
+export interface UInt32Value {
+    /** The uint32 value. */
+    value: number;
+}
+/**
+ * Wrapper message for `bool`.
+ *
+ * The JSON representation for `BoolValue` is JSON `true` and `false`.
+ */
+export interface BoolValue {
+    /** The bool value. */
+    value: boolean;
+}
+/**
+ * Wrapper message for `string`.
+ *
+ * The JSON representation for `StringValue` is JSON string.
+ */
+export interface StringValue {
+    /** The string value. */
+    value: string;
+}
+/**
+ * Wrapper message for `bytes`.
+ *
+ * The JSON representation for `BytesValue` is JSON string.
+ */
+export interface BytesValue {
+    /** The bytes value. */
+    value: Uint8Array;
+}
+export declare const DoubleValue: {
+    encode(message: DoubleValue, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DoubleValue;
+    fromJSON(object: any): DoubleValue;
+    toJSON(message: DoubleValue): unknown;
+    create<I extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): DoubleValue;
+    fromPartial<I_1 extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): DoubleValue;
+};
+export declare const FloatValue: {
+    encode(message: FloatValue, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FloatValue;
+    fromJSON(object: any): FloatValue;
+    toJSON(message: FloatValue): unknown;
+    create<I extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): FloatValue;
+    fromPartial<I_1 extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): FloatValue;
+};
+export declare const Int64Value: {
+    encode(message: Int64Value, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Int64Value;
+    fromJSON(object: any): Int64Value;
+    toJSON(message: Int64Value): unknown;
+    create<I extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): Int64Value;
+    fromPartial<I_1 extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): Int64Value;
+};
+export declare const UInt64Value: {
+    encode(message: UInt64Value, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): UInt64Value;
+    fromJSON(object: any): UInt64Value;
+    toJSON(message: UInt64Value): unknown;
+    create<I extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): UInt64Value;
+    fromPartial<I_1 extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): UInt64Value;
+};
+export declare const Int32Value: {
+    encode(message: Int32Value, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Int32Value;
+    fromJSON(object: any): Int32Value;
+    toJSON(message: Int32Value): unknown;
+    create<I extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): Int32Value;
+    fromPartial<I_1 extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): Int32Value;
+};
+export declare const UInt32Value: {
+    encode(message: UInt32Value, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): UInt32Value;
+    fromJSON(object: any): UInt32Value;
+    toJSON(message: UInt32Value): unknown;
+    create<I extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): UInt32Value;
+    fromPartial<I_1 extends {
+        value?: number | undefined;
+    } & {
+        value?: number | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): UInt32Value;
+};
+export declare const BoolValue: {
+    encode(message: BoolValue, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BoolValue;
+    fromJSON(object: any): BoolValue;
+    toJSON(message: BoolValue): unknown;
+    create<I extends {
+        value?: boolean | undefined;
+    } & {
+        value?: boolean | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): BoolValue;
+    fromPartial<I_1 extends {
+        value?: boolean | undefined;
+    } & {
+        value?: boolean | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): BoolValue;
+};
+export declare const StringValue: {
+    encode(message: StringValue, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StringValue;
+    fromJSON(object: any): StringValue;
+    toJSON(message: StringValue): unknown;
+    create<I extends {
+        value?: string | undefined;
+    } & {
+        value?: string | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): StringValue;
+    fromPartial<I_1 extends {
+        value?: string | undefined;
+    } & {
+        value?: string | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): StringValue;
+};
+export declare const BytesValue: {
+    encode(message: BytesValue, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BytesValue;
+    fromJSON(object: any): BytesValue;
+    toJSON(message: BytesValue): unknown;
+    create<I extends {
+        value?: Uint8Array | undefined;
+    } & {
+        value?: Uint8Array | undefined;
+    } & { [K in Exclude<keyof I, "value">]: never; }>(base?: I): BytesValue;
+    fromPartial<I_1 extends {
+        value?: Uint8Array | undefined;
+    } & {
+        value?: Uint8Array | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "value">]: never; }>(object: I_1): BytesValue;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/dist/types/proto/proto-ts/utils.d.ts

@@ -0,0 +1,30 @@
+import { types } from 'mediasoup-client';
+import { DtlsFingerprint, DtlsParameters, DtlsRole, IceCandidate, IceCandidateType, IceParameters, MediaKind, MimeType, Protocol, RtpCapabilitiesFinalized, RtpCodecParameters, RtpParameters, RtpHeaderExtensionParameters, RtpEncodingParameters, RtcpParameters } from "./data_structures/rtp_parameters";
+import { TransportOptions } from "./data_structures/messages";
+export declare function mimeTypeToPbs(mimeType: string): MimeType;
+export declare function mimeTypeFromPbs(mimeType: MimeType): string | undefined;
+export declare function mediaKindFromPbs(mediaKind: MediaKind): types.MediaKind | undefined;
+export declare function mediaKindToPbs(mediaKind: types.MediaKind): MediaKind;
+export declare function rtpCapabilitiesFromPbs(rtpCapabilities: RtpCapabilitiesFinalized | undefined): types.RtpCapabilities;
+export declare function rtpCapabilitiesToPbs(rtpCapabilities: types.RtpCapabilities): RtpCapabilitiesFinalized;
+export declare function iceParametersFromPbs(iceParameters: IceParameters): types.IceParameters;
+export declare function iceCandidatesFromPbs(iceCandidates: IceCandidate[]): types.IceCandidate[];
+export declare function iceCandidateTypeFromPbs(iceCandidateType: IceCandidateType): string;
+export declare function protocolFromPbs(protocol: Protocol): string;
+export declare function dtlsParametersFromPbs(dtlsParameters: DtlsParameters): types.DtlsParameters;
+export declare function dtlsParametersToPbs(dtlsParameters: types.DtlsParameters): DtlsParameters;
+export declare function dtlsRoleFromPbs(dtlsRole: DtlsRole): types.DtlsRole;
+export declare function dtlsRoleToPbs(dtlsRole: types.DtlsRole): DtlsRole;
+export declare function fingerprintFromPbs(fingerprint: DtlsFingerprint): types.DtlsFingerprint;
+export declare function fingerprintToPbs(fingerprint: types.DtlsFingerprint): DtlsFingerprint;
+export declare function transportOptionsFromPbs(transportOptions: TransportOptions): types.TransportOptions;
+export declare function rtpParametersFromPbs(rtpParameters: RtpParameters): types.RtpParameters;
+export declare function rtpParametersToPbs(rtpParameters: types.RtpParameters): RtpParameters;
+export declare function rtpCodecParameterFromPbs(rtpCodecParameter: RtpCodecParameters): types.RtpCodecParameters;
+export declare function rtpCodecParameterToPbs(rtpCodecParameter: types.RtpCodecParameters): RtpCodecParameters;
+export declare function headerExtensionFromPbs(headerExtension: RtpHeaderExtensionParameters): types.RtpHeaderExtensionParameters;
+export declare function headerExtensionToPbs(headerExtension: types.RtpHeaderExtensionParameters): RtpHeaderExtensionParameters;
+export declare function rtpEncodingParametersFromPbs(rtpEncodingParameters: RtpEncodingParameters): types.RtpEncodingParameters;
+export declare function rtpEncodingParametersToPbs(rtpEncodingParameters: types.RtpEncodingParameters): RtpEncodingParameters;
+export declare function rtcpParametersFromPbs(rtcp?: RtcpParameters): types.RtcpParameters | undefined;
+export declare function rtcpParametersToPbs(rtcp?: types.RtcpParameters): RtcpParameters | undefined;

package/dist/types/publish/media.d.ts

@@ -0,0 +1,11 @@
+import { connectConsumerTransportArgs, connectProducerTransportArgs, keepAliveArgs, leaveArgs, produceArgs, producerPauseArgs, producerResumeArgs, publishJoinArgs, startConsumingArgs } from "../interface/HyRtcCore";
+import { EventEmitter } from "../EventEmitter";
+export declare function join(eventEmit: EventEmitter<any>, clientId: string | undefined, args: publishJoinArgs): void;
+export declare function startConsuming(eventEmit: EventEmitter<any>, clientId: string | undefined, args: startConsumingArgs): void;
+export declare function keepalive(eventEmit: EventEmitter<any>, clientId: string | undefined, args: keepAliveArgs): void;
+export declare function connectConsumerTransport(eventEmit: EventEmitter<any>, clientId: string | undefined, args: connectConsumerTransportArgs): void;
+export declare function connectProducerTransport(eventEmit: EventEmitter<any>, clientId: string | undefined, args: connectProducerTransportArgs): void;
+export declare function produce(eventEmit: EventEmitter<any>, clientId: string | undefined, args: produceArgs): void;
+export declare function producerResume(eventEmit: EventEmitter<any>, clientId: string | undefined, args: producerResumeArgs): void;
+export declare function producerPause(eventEmit: EventEmitter<any>, clientId: string | undefined, args: producerPauseArgs): void;
+export declare function leave(eventEmit: EventEmitter<any>, clientId: string | undefined, args: leaveArgs): void;

package/dist/types/publish/mediaapp.d.ts

@@ -0,0 +1,13 @@
+import { mediaCallEventArgs, keepAliveArgs, publishMediaCallArgs, publishBroadcastArgs, publishChannelArgs, publishMonitorArgs, publishMonitorListenArgs } from "../interface/HyRtcCore";
+import { EventEmitter } from "../EventEmitter";
+export declare function publishChannel(eventEmit: EventEmitter<any>, clientId: string | undefined, args: publishChannelArgs): void;
+export declare function publishMonitor(eventEmit: EventEmitter<any>, clientId: string | undefined, args: publishMonitorArgs): void;
+export declare function publishBroadcast(eventEmit: EventEmitter<any>, clientId: string | undefined, args: publishBroadcastArgs): void;
+export declare function publishMediaCall(eventEmit: EventEmitter<any>, clientId: string | undefined, args: publishMediaCallArgs): void;
+export declare function publishMonitorListen(eventEmit: EventEmitter<any>, clientId: string | undefined, args: publishMonitorListenArgs): void;
+export declare function mediaAppKeepalive(eventEmit: EventEmitter<any>, clientId: string | undefined, args: keepAliveArgs): void;
+export declare function mediaCallEventWaiting(eventEmit: EventEmitter<any>, callClientId: string | undefined, args: mediaCallEventArgs): void;
+export declare function mediaCallEventRinging(eventEmit: EventEmitter<any>, beCallClientId: string | undefined, args: mediaCallEventArgs): void;
+export declare function mediaCallEventNoAnswer(eventEmit: EventEmitter<any>, beCallClientId: string | undefined, args: mediaCallEventArgs): void;
+export declare function mediaCallEventAnswer(eventEmit: EventEmitter<any>, beCallClientId: string | undefined, args: mediaCallEventArgs): void;
+export declare function mediaCallEventHangup(eventEmit: EventEmitter<any>, beCallClientId: string | undefined, args: mediaCallEventArgs): void;

package/dist/types/response/business.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from "../EventEmitter";
+import mqtt from "mqtt";
+import { MediaAppErrorOnMessageParams } from "../interface/HyRtcCore";
+declare const handlerBusinessOnMessage: (eventEmit: EventEmitter<any>, params: {
+    curTopicMethod: string;
+    topic: string;
+    message: Uint8Array;
+    packet: mqtt.IPublishPacket;
+}) => void;
+declare const handlerMediaAppErrorOnMessage: (eventEmit: EventEmitter<any>, mediaAppErrorOnMessageParams: MediaAppErrorOnMessageParams) => Promise<void>;
+export { handlerBusinessOnMessage, handlerMediaAppErrorOnMessage };

package/dist/types/response/index.d.ts

@@ -0,0 +1,4 @@
+import mqtt from "mqtt";
+import { EventEmitter } from "../EventEmitter";
+declare const handlerOnMessage: (eventEmit: EventEmitter<any>, correlationDataMap: Map<any, any>, topic: string, message: Uint8Array, packet: mqtt.IPublishPacket) => Promise<false | undefined>;
+export { handlerOnMessage };

package/dist/types/response/media.d.ts

@@ -0,0 +1,6 @@
+import { EventEmitter } from "../EventEmitter";
+import { MediaErrorOnMessageParams, MediaOnMessageParams } from "../interface/HyRtcCore";
+declare const handlerMediaOnMessage: <T>(message: T) => void;
+declare const handlerMediaErrorOnMessage: (eventEmit: EventEmitter<any>, mediaErrorOnMessageParams: MediaErrorOnMessageParams) => Promise<false | undefined>;
+declare const handlerMediaServerOnMessage: (eventEmit: EventEmitter<any>, params: MediaOnMessageParams) => Promise<void>;
+export { handlerMediaOnMessage, handlerMediaServerOnMessage, handlerMediaErrorOnMessage };

package/dist/types/response/mediaapp.d.ts

@@ -0,0 +1,11 @@
+import { StringValue } from "../proto/proto-ts/google/protobuf/wrappers";
+import { EventEmitter } from "../EventEmitter";
+import mqtt from "mqtt";
+declare const handlerMediaAppOnMessage: (message: StringValue) => void;
+declare const handlerMediaAppServerOnMessage: (eventEmit: EventEmitter<any>, params: {
+    curTopicMethod: string;
+    topic: string;
+    message: Uint8Array;
+    packet: mqtt.IPublishPacket;
+}) => void;
+export { handlerMediaAppOnMessage, handlerMediaAppServerOnMessage };

package/dist/types/room/genPlayElement.d.ts

@@ -0,0 +1,12 @@
+import { GenPlayElementOptions } from "../interface/HyRtcCore";
+import { Room } from "../Room";
+export declare function genChannelPlayElement(params: GenPlayElementOptions): HTMLVideoElement | null;
+export declare function genMonitorPlayElement(params: GenPlayElementOptions): HTMLVideoElement | null;
+export declare function genMonitorPlaceholder(params: {
+    playElementBox: string;
+    room: Room;
+}): void;
+export declare function genBroadcastPlayElement(params: GenPlayElementOptions): HTMLAudioElement | null;
+export declare function genMonitorListenPlayElement(params: GenPlayElementOptions): HTMLAudioElement | null;
+export declare function genMediaBeCallDeviceIdElement(params: GenPlayElementOptions): HTMLAudioElement | null;
+export declare function genMediaCallDeviceIdElement(params: GenPlayElementOptions): HTMLAudioElement | null;

package/dist/types/room/roomMethods.d.ts

@@ -0,0 +1,25 @@
+import { Room } from "../Room";
+import { ConsumerInfo } from '../Client';
+import { ProduceInfoMap } from "../interface/HyRtcCore";
+export declare class RoomMethods {
+    room: Room;
+    constructor(room: Room);
+    getRoom(): void;
+    getProduceInfo(): ProduceInfoMap['produceMap'];
+    producerAudioResume(): void;
+    producerAudioPause(): void;
+    producerVideoResume(): void;
+    producerVideoPause(): void;
+    producerAllResume(): void;
+    producerAllPause(): void;
+    getAllVideoConsumer(): ConsumerInfo[];
+    getAllAudioConsumer(): ConsumerInfo[];
+    mutedAllElement(): void;
+    unMutedAllElement(): void;
+    replaceProducerByProduceId(producerId: string, mediaDeviceInfo: MediaDeviceInfo): Promise<false | undefined>;
+    replaceProducerByTrack(producerId: string, track: MediaStreamTrack): false | undefined;
+    startProduceDisplayMedia(): Promise<void>;
+    switchToDefaultStream(): void;
+    stopProduceDisplayMedia(): void;
+    leaveRoom(): void;
+}

package/dist/types/utils/MediaDevices.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from "../EventEmitter";
+export declare function enumerateDevices(kind?: string): Promise<MediaDeviceInfo[]>;
+export declare function getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
+export declare function getDeviceTrack(mediaStream: MediaStream): MediaStreamTrack[];
+export declare function setGlobalVideoDevice(eventEmit: EventEmitter<any>, device: MediaDeviceInfo): void;
+export declare function getGlobalVideoDevice(eventEmit: EventEmitter<any>): Promise<MediaDeviceInfo>;
+export declare function setGlobalAudioDevice(eventEmit: EventEmitter<any>, device: MediaDeviceInfo): void;
+export declare function getGlobalAudioDevice(eventEmit: EventEmitter<any>): Promise<MediaDeviceInfo>;
+export declare function getUserAudioMediaByDeviceId(audioDeviceId: string): Promise<MediaStream>;
+export declare function getUserVideoMediaByDeviceId(videoDeviceId: string): Promise<MediaStream>;
+export declare function getDisplayMediaStream(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+export declare function setGlobalDisplayMediaStream(eventEmit: EventEmitter<any>, mediaStream: MediaStream): void;
+export declare function getGlobalDisplayMediaStream(eventEmit: EventEmitter<any>): Promise<MediaStream>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hy-rtc-core-v3",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "hy-rtc-core V3",
   "type": "module",
   "main": "dist/index.esm.js",