mediasfu-shared 1.0.6 → 1.2.0

package/dist/consumers/compareScreenStates.d.ts

@@ -0,0 +1,55 @@
+import { ScreenState, TriggerType, TriggerParameters } from '../types/types';
+export interface CompareScreenStatesParameters extends TriggerParameters {
+    recordingDisplayType: 'video' | 'media' | 'all';
+    recordingVideoOptimized: boolean;
+    screenStates: ScreenState[];
+    prevScreenStates: ScreenState[];
+    activeNames: string[];
+    trigger: TriggerType;
+    getUpdatedAllParams: () => CompareScreenStatesParameters;
+    [key: string]: any;
+}
+export interface CompareScreenStatesOptions {
+    restart?: boolean;
+    parameters: CompareScreenStatesParameters;
+}
+export type CompareScreenStatesType = (options: CompareScreenStatesOptions) => Promise<void>;
+/**
+ * Compares the current screen states with the previous screen states and triggers actions based on changes.
+ *
+ * @param {CompareScreenStatesOptions} options - The options for comparing screen states.
+ * @param {boolean} [options.restart=false] - Whether to restart the comparison process.
+ * @param {CompareScreenStatesParameters} options.parameters - The parameters for the comparison.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string} options.parameters.recordingDisplayType - The type of display being recorded.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Whether the recording is optimized for video.
+ * @param {Array<ScreenState>} options.parameters.screenStates - The current screen states.
+ * @param {Array<ScreenState>} options.parameters.prevScreenStates - The previous screen states.
+ * @param {Array<string>} options.parameters.activeNames - The active names in the current context.
+ * @param {Function} options.parameters.trigger - Function to trigger actions based on changes.
+ *
+ * @returns {Promise<void>} A promise that resolves when the comparison and any triggered actions are complete.
+ *
+ * @throws Will log an error message if an error occurs during the comparison process.
+ *
+ * @example
+ * const options = {
+ *   restart: false,
+ *   parameters: {
+ *     getUpdatedAllParams: getUpdatedAllParamsFunction,
+ *     recordingDisplayType: 'video',
+ *     recordingVideoOptimized: true,
+ *     screenStates: [{ key1: 'value1' }, { key2: 'value2' }],
+ *     prevScreenStates: [{ key1: 'value1' }, { key2: 'value2' }],
+ *     activeNames: ['name1', 'name2'],
+ *     trigger: triggerFunction,
+ *   },
+ * };
+ *
+ * compareScreenStates(options)
+ *   .then(() => {
+ *     console.log('Screen states compared successfully');
+ *   });
+ */
+export declare function compareScreenStates({ restart, parameters, }: CompareScreenStatesOptions): Promise<void>;
+//# sourceMappingURL=compareScreenStates.d.ts.map

package/dist/consumers/compareScreenStates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareScreenStates.d.ts","sourceRoot":"","sources":["../../src/consumers/compareScreenStates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE7E,MAAM,WAAW,6BAA8B,SAAQ,iBAAiB;IACtE,oBAAoB,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,CAAC;IAChD,uBAAuB,EAAE,OAAO,CAAC;IACjC,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,WAAW,EAAE,MAAM,EAAE,CAAC;IAGtB,OAAO,EAAE,WAAW,CAAC;IACrB,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;IACzD,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,6BAA6B,CAAC;CAC3C;AAGD,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE,0BAA0B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,wBAAsB,mBAAmB,CAAC,EACxC,OAAe,EACf,UAAU,GACX,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD5C"}

package/dist/consumers/connectIps.d.ts

@@ -0,0 +1,66 @@
+import { Device } from 'mediasoup-client/types';
+import { ReorderStreamsParameters, ReorderStreamsType, NewPipeProducerParameters, NewPipeProducerType, ProducerClosedType, ProducerClosedParameters, JoinConsumeRoomType, JoinConsumeRoomParameters, ConsumeSocket } from '../types/types';
+export interface ConnectIpsParameters extends ReorderStreamsParameters, JoinConsumeRoomParameters, ProducerClosedParameters, NewPipeProducerParameters {
+    device: Device | null;
+    roomRecvIPs: string[];
+    updateRoomRecvIPs: (roomRecvIPs: string[]) => void;
+    updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;
+    reorderStreams: ReorderStreamsType;
+    getUpdatedAllParams: () => ConnectIpsParameters;
+    [key: string]: any;
+}
+export interface ConnectIpsOptions {
+    consume_sockets: ConsumeSocket[];
+    remIP: string[];
+    apiUserName: string;
+    apiKey?: string;
+    apiToken: string;
+    newProducerMethod?: NewPipeProducerType;
+    closedProducerMethod?: ProducerClosedType;
+    joinConsumeRoomMethod?: JoinConsumeRoomType;
+    parameters: ConnectIpsParameters;
+}
+export type ConnectIpsType = (options: ConnectIpsOptions) => Promise<[Record<string, any>[], string[]]>;
+/**
+ * Connects to remote IPs and manages socket connections.
+ *
+ * @param {ConnectIpsOptions} options - The options for connecting IPs.
+ * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.
+ * @param {string[]} options.remIP - The list of remote IPs to connect to.
+ * @param {string} options.apiUserName - The API username for authentication.
+ * @param {string} [options.apiKey] - The API key for authentication.
+ * @param {string} [options.apiToken] - The API token for authentication.
+ * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.
+ * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.
+ * @param {Function} [options.joinConsumeRoomMethod=joinConsumeRoom] - The method to handle joining a consuming room.
+ * @param {ConnectIpsParameters} options.parameters - Additional parameters.
+ * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.
+ * @param {Function} options.parameters.updateRoomRecvIPs - The function to update the room received IPs.
+ * @param {Function} options.parameters.updateConsume_sockets - The function to update the consume sockets.
+ *
+ * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.
+ *
+ * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+ *
+ * @example
+ * const options = {
+ *   consume_sockets: [],
+ *   remIP: ['ip1', 'ip2'],
+ *   apiUserName: 'username',
+ *   apiKey: 'apikey',
+ *   apiToken: 'token',
+ *   parameters: {
+ *     roomRecvIPs: [],
+ *     updateRoomRecvIPs: updateRoomRecvIPsFunction,
+ *     updateConsume_sockets: updateConsumeSocketsFunction,
+ *   },
+ * };
+ *
+ * connectIps(options)
+ *   .then(([consume_sockets, roomRecvIPs]) => {
+ *     console.log('Connected IPs:', consume_sockets);
+ *     console.log('Room received IPs:', roomRecvIPs);
+ *   });
+ */
+export declare const connectIps: ({ consume_sockets, remIP, apiUserName, apiKey, apiToken, newProducerMethod, closedProducerMethod, joinConsumeRoomMethod, parameters, }: ConnectIpsOptions) => Promise<[Record<string, any>[], string[]]>;
+//# sourceMappingURL=connectIps.d.ts.map

package/dist/consumers/connectIps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectIps.d.ts","sourceRoot":"","sources":["../../src/consumers/connectIps.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EACL,wBAAwB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,kBAAkB,EAChH,wBAAwB,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,aAAa,EACxF,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,oBAAqB,SAAQ,wBAAwB,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,yBAAyB;IACpJ,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,iBAAiB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACnD,qBAAqB,EAAE,CAAC,eAAe,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;IAGlE,cAAc,EAAE,kBAAkB,CAAC;IACnC,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;IAChD,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,aAAa,EAAE,CAAC;IACjC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,mBAAmB,CAAC;IACxC,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;IAC1C,qBAAqB,CAAC,EAAE,mBAAmB,CAAC;IAC5C,UAAU,EAAE,oBAAoB,CAAC;CAClC;AAGD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,eAAO,MAAM,UAAU,GAAU,wIAY9B,iBAAiB,KAAG,OAAO,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAoF/D,CAAC"}

package/dist/consumers/connectLocalIps.d.ts

@@ -0,0 +1,52 @@
+import { ReorderStreamsParameters, ReorderStreamsType, NewPipeProducerParameters, NewPipeProducerType, ProducerClosedType, ProducerClosedParameters, ReceiveAllPipedTransportsParameters, ReceiveAllPipedTransportsType } from '../types/types';
+import { Socket } from 'socket.io-client';
+export interface ConnectLocalIpsParameters extends ReorderStreamsParameters, ProducerClosedParameters, NewPipeProducerParameters, ReceiveAllPipedTransportsParameters {
+    socket: Socket;
+    reorderStreams: ReorderStreamsType;
+    receiveAllPipedTransports: ReceiveAllPipedTransportsType;
+    getUpdatedAllParams: () => ConnectLocalIpsParameters;
+    [key: string]: any;
+}
+export interface ConnectLocalIpsOptions {
+    socket: Socket;
+    newProducerMethod?: NewPipeProducerType;
+    closedProducerMethod?: ProducerClosedType;
+    parameters: ConnectLocalIpsParameters;
+}
+export type ConnectLocalIpsType = (options: ConnectLocalIpsOptions) => Promise<void>;
+/**
+ * Connects to remote IPs and manages socket connections.
+ *
+ * @param {ConnectLocalIpsOptions} options - The options for connecting IPs.
+ * @param {Socket} options.socket - The socket to connect to.
+ * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.
+ * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.
+ * @param {ConnectLocalIpsParameters} options.parameters - Additional parameters.
+ * @param {Function} options.parameters.reorderStreams - The function to reorder streams.
+ * @param {Function} options.parameters.getUpdatedAllParams - The function to get updated parameters.
+ * @param {Socket} options.parameters.socket - The socket to connect to.
+ *
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *  socket,
+ * newProducerMethod: newPipeProducer,
+ * closedProducerMethod: producerClosed,
+ * parameters: connectLocalIpsParameters,
+ * };
+ *
+ * connectLocalIps(options)
+ *  .then(() => {
+ *   console.log('Connected to local IPs');
+ * })
+ * .catch(error => {
+ *  console.error('Error connecting to local IPs:', error);
+ * });
+ * ```
+ */
+export declare const connectLocalIps: ({ socket, newProducerMethod, closedProducerMethod, parameters, }: ConnectLocalIpsOptions) => Promise<void>;
+//# sourceMappingURL=connectLocalIps.d.ts.map

package/dist/consumers/connectLocalIps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectLocalIps.d.ts","sourceRoot":"","sources":["../../src/consumers/connectLocalIps.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,wBAAwB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,kBAAkB,EAChH,wBAAwB,EACxB,mCAAmC,EACnC,6BAA6B,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,MAAM,WAAW,yBAA0B,SAAQ,wBAAwB,EAAE,wBAAwB,EAAE,yBAAyB,EAChI,mCAAmC;IACjC,MAAM,EAAE,MAAM,CAAC;IAGf,cAAc,EAAE,kBAAkB,CAAC;IACnC,yBAAyB,EAAE,6BAA6B,CAAC;IACzD,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;IACrD,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,mBAAmB,CAAC;IACxC,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;IAC1C,UAAU,EAAE,yBAAyB,CAAC;CACvC;AAGD,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,eAAO,MAAM,eAAe,GAAU,kEAOnC,sBAAsB,KAAG,OAAO,CAAC,IAAI,CA+BvC,CAAC"}

package/dist/consumers/connectRecvTransport.d.ts

@@ -0,0 +1,64 @@
+import { Socket } from 'socket.io-client';
+import { ConsumerResumeType, ConsumerResumeParameters, Transport as TransportType } from '../types/types';
+import { Device, Transport } from 'mediasoup-client/types';
+interface SpeakerTranslationState {
+    speakerId: string;
+    speakerName: string;
+    inputLanguage: string;
+    outputLanguage: string;
+    originalProducerId: string;
+    enabled: boolean;
+}
+export interface ConnectRecvTransportParameters extends ConsumerResumeParameters {
+    device: Device | null;
+    consumerTransports: TransportType[];
+    updateConsumerTransports: (transports: TransportType[]) => void;
+    speakerTranslationStates?: Map<string, SpeakerTranslationState>;
+    consumerResume: ConsumerResumeType;
+    getUpdatedAllParams: () => ConnectRecvTransportParameters;
+    [key: string]: any;
+}
+export interface ConnectRecvTransportOptions {
+    consumerTransport: Transport;
+    remoteProducerId: string;
+    serverConsumerTransportId: string;
+    nsock: Socket;
+    parameters: ConnectRecvTransportParameters;
+}
+export type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;
+/**
+ * Connects the receiving transport to consume media from a remote producer.
+ *
+ * @param {ConnectRecvTransportOptions} options - The options for connecting the receiving transport.
+ * @param {Transport} options.consumerTransport - The transport used for consuming media.
+ * @param {string} options.remoteProducerId - The ID of the remote producer.
+ * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.
+ * @param {Socket} options.nsock - The socket used for communication.
+ * @param {ConnectRecvTransportParameters} options.parameters - The parameters for the connection.
+ *
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @throws Will throw an error if the connection or consumption fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransport,
+ *   remoteProducerId: 'producer-id',
+ *   serverConsumerTransportId: 'transport-id',
+ *   nsock: socket,
+ *   parameters: connectRecvTransportOptions,
+ * };
+ *
+ * connectRecvTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected and consuming media');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
+export declare const connectRecvTransport: ({ consumerTransport, remoteProducerId, serverConsumerTransportId, nsock, parameters, }: ConnectRecvTransportOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=connectRecvTransport.d.ts.map

package/dist/consumers/connectRecvTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectRecvTransport.d.ts","sourceRoot":"","sources":["../../src/consumers/connectRecvTransport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,SAAS,IAAI,aAAa,EAAe,MAAM,gBAAgB,CAAC;AACvH,OAAO,KAAK,EAAY,MAAM,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAE1E,UAAU,uBAAuB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;CAClB;AA+ED,MAAM,WAAW,8BAA+B,SAAQ,wBAAwB;IAC9E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,kBAAkB,EAAE,aAAa,EAAE,CAAC;IACpC,wBAAwB,EAAE,CAAC,UAAU,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;IAChE,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;IAGhE,cAAc,EAAE,kBAAkB,CAAC;IACnC,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;IAC1D,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AACD,MAAM,WAAW,2BAA2B;IAC1C,iBAAiB,EAAE,SAAS,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,yBAAyB,EAAE,MAAM,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,8BAA8B,CAAC;CAC5C;AAGD,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,oBAAoB,GAAU,wFAMxC,2BAA2B,KAAG,OAAO,CAAC,IAAI,CAoG5C,CAAC"}

package/dist/consumers/connectSendTransport.d.ts

@@ -0,0 +1,75 @@
+import { ProducerOptions } from 'mediasoup-client/types';
+import { ConnectSendTransportAudioType, ConnectSendTransportVideoType, ConnectSendTransportScreenType, ConnectSendTransportAudioParameters, ConnectSendTransportVideoParameters, ConnectSendTransportScreenParameters } from '../types/types';
+export interface ConnectSendTransportParameters extends ConnectSendTransportAudioParameters, ConnectSendTransportVideoParameters, ConnectSendTransportScreenParameters {
+    audioParams: ProducerOptions;
+    videoParams: ProducerOptions;
+    localStreamScreen: MediaStream | null;
+    canvasStream: MediaStream | null;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    shared: boolean;
+    islevel: string;
+    connectSendTransportAudio: ConnectSendTransportAudioType;
+    connectSendTransportVideo: ConnectSendTransportVideoType;
+    connectSendTransportScreen: ConnectSendTransportScreenType;
+    getUpdatedAllParams: () => ConnectSendTransportParameters;
+    [key: string]: any;
+}
+export interface ConnectSendTransportOptions {
+    option: 'audio' | 'video' | 'screen' | 'all';
+    targetOption?: 'local' | 'remote' | 'all';
+    parameters: ConnectSendTransportParameters;
+}
+export type ConnectSendTransportType = (options: ConnectSendTransportOptions) => Promise<void>;
+/**
+ * Connects the send transport based on the specified option.
+ *
+ * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.
+ * @param {string} options.option - The type of transport to connect ("audio", "video", "screen", or "all").
+ * @param {boolean} options.targetOption - The target option to connect ("local", "remote", or "all").
+ * @param {ConnectSendTransportParameters} options.parameters - The parameters required for connecting the transport.
+ * @param {ProducerOptions} options.parameters.audioParams - The audio parameters.
+ * @param {ProducerOptions} options.parameters.videoParams - The video parameters.
+ * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {MediaStream} options.parameters.canvasStream - The canvas stream.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {string} options.parameters.islevel - The level of the screen sharing.
+ * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.
+ * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.
+ * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the transport is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * const options = {
+ *   option: 'audio',
+ *   targetOption: 'local',
+ *   parameters: {
+ *     audioParams: audioProducerOptions,
+ *     videoParams: videoProducerOptions,
+ *     localStreamScreen: localStream,
+ *     canvasStream: canvasStream,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     shared: false,
+ *     islevel: '1',
+ *     connectSendTransportAudio: connectAudioFunction,
+ *     connectSendTransportVideo: connectVideoFunction,
+ *     connectSendTransportScreen: connectScreenFunction,
+ *   },
+ * };
+ *
+ * connectSendTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ */
+export declare const connectSendTransport: ({ option, targetOption, parameters }: ConnectSendTransportOptions) => Promise<void>;
+//# sourceMappingURL=connectSendTransport.d.ts.map

package/dist/consumers/connectSendTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectSendTransport.d.ts","sourceRoot":"","sources":["../../src/consumers/connectSendTransport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,6BAA6B,EAAE,6BAA6B,EAAE,8BAA8B,EAAE,mCAAmC,EAAE,mCAAmC,EAAE,oCAAoC,EAAE,MAAM,gBAAgB,CAAC;AAC9O,MAAM,WAAW,8BAA+B,SAAQ,mCAAmC,EAAE,mCAAmC,EAAE,oCAAoC;IACpK,WAAW,EAAE,eAAe,CAAA;IAC5B,WAAW,EAAE,eAAe,CAAC;IAC7B,iBAAiB,EAAE,WAAW,GAAG,IAAI,CAAC;IACtC,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAGhB,yBAAyB,EAAE,6BAA6B,CAAC;IACzD,yBAAyB,EAAE,6BAA6B,CAAC;IACzD,0BAA0B,EAAE,8BAA8B,CAAC;IAE3D,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;IAC1D,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IAC7C,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IAC1C,UAAU,EAAE,8BAA8B,CAAC;CAC5C;AAGD,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,eAAO,MAAM,oBAAoB,GAAU,sCAA8C,2BAA2B,KAAG,OAAO,CAAC,IAAI,CAoElI,CAAC"}

package/dist/consumers/connectSendTransportAudio.d.ts

@@ -0,0 +1,62 @@
+import { Transport, Producer, ProducerOptions } from 'mediasoup-client/types';
+export interface ConnectSendTransportAudioParameters {
+    audioProducer: Producer | null;
+    producerTransport: Transport | null;
+    localAudioProducer?: Producer | null;
+    localProducerTransport?: Transport | null;
+    updateAudioProducer: (producer: Producer | null) => void;
+    updateProducerTransport: (transport: Transport | null) => void;
+    updateLocalAudioProducer?: (localProducer: Producer | null) => void;
+    updateLocalProducerTransport?: (localTransport: Transport | null) => void;
+    updateAudioLevel: (level: number) => void;
+    getUpdatedAllParams: () => ConnectSendTransportAudioParameters;
+    [key: string]: any;
+}
+export interface ConnectSendTransportAudioOptions {
+    audioParams: ProducerOptions;
+    parameters: ConnectSendTransportAudioParameters;
+    targetOption?: 'all' | 'local' | 'remote';
+}
+export type ConnectSendTransportAudioType = (options: ConnectSendTransportAudioOptions) => Promise<void>;
+export declare const updateMicLevel: (audioProducer: Producer, updateAudioLevel: (level: number) => void) => Promise<void>;
+/**
+ * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
+ *
+ * If the primary connection fails, it attempts to connect using the local transport via a separate function.
+ *
+ * @param {ConnectSendTransportAudioOptions} options - The options for connecting the send transport.
+ * @param {ProducerOptions} options.audioParams - The audio parameters.
+ * @param {ConnectSendTransportAudioParameters} options.parameters - The parameters required for connecting the transport.
+ * @param {Producer | null} options.parameters.audioProducer - The audio producer object.
+ * @param {Transport | null} options.parameters.producerTransport - The producer transport object.
+ * @param {Producer | null} [options.parameters.localAudioProducer] - The local audio producer object.
+ * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport object.
+ * @param {(producer: Producer | null) => void} options.parameters.updateAudioProducer - The function to update the audio producer object.
+ * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the producer transport object.
+ * @param {(localProducer: Producer | null) => void} [options.parameters.updateLocalAudioProducer] - The function to update the local audio producer object.
+ * @param {(localTransport: Transport | null) => void} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport object.
+ * @param {(level: number) => void} [options.parameters.updateAudioLevel] - The function to update the audio level.
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @example
+ * const options = {
+ *   audioParams: { codec: "opus", maxBitrate: 128000 },
+ *   parameters: {
+ *     audioProducer: null,
+ *     producerTransport: transport,
+ *     localAudioProducer: null,
+ *     localProducerTransport: localTransport,
+ *     updateAudioProducer: (producer) => console.log("Updated producer:", producer),
+ *     updateProducerTransport: (transport) => console.log("Updated transport:", transport),
+ *     updateLocalAudioProducer: (localProducer) => console.log("Updated local producer:", localProducer),
+ *     updateLocalProducerTransport: (localTransport) => console.log("Updated local transport:", localTransport),
+ *     updateAudioLevel: (level) => console.log("Updated audio level:", level),
+ *   },
+ * };
+ *
+ * connectSendTransportAudio(options)
+ *   .then(() => console.log("Audio transport connected successfully"))
+ *   .catch((error) => console.error("Error connecting audio transport:", error));
+ */
+export declare const connectSendTransportAudio: ConnectSendTransportAudioType;
+//# sourceMappingURL=connectSendTransportAudio.d.ts.map

package/dist/consumers/connectSendTransportAudio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectSendTransportAudio.d.ts","sourceRoot":"","sources":["../../src/consumers/connectSendTransportAudio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEnF,MAAM,WAAW,mCAAmC;IAClD,aAAa,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC/B,iBAAiB,EAAE,SAAS,GAAG,IAAI,CAAC;IACpC,kBAAkB,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACrC,sBAAsB,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1C,mBAAmB,EAAE,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC;IACzD,uBAAuB,EAAE,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAC;IAC/D,wBAAwB,CAAC,EAAE,CAAC,aAAa,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC;IACpE,4BAA4B,CAAC,EAAE,CAAC,cAAc,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1E,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAG1C,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;IAC/D,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CAEpB;AAED,MAAM,WAAW,gCAAgC;IAC/C,WAAW,EAAE,eAAe,CAAC;IAC7B,UAAU,EAAE,mCAAmC,CAAC;IAChD,YAAY,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;CAC3C;AAGD,MAAM,MAAM,6BAA6B,GAAG,CAAC,OAAO,EAAE,gCAAgC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AA0BzG,eAAO,MAAM,cAAc,GAAU,eAAe,QAAQ,EAAE,kBAAkB,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,kBAmBtG,CAAA;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,eAAO,MAAM,yBAAyB,EAAE,6BA8CvC,CAAC"}

package/dist/consumers/connectSendTransportScreen.d.ts

@@ -0,0 +1,72 @@
+import { Transport, Producer, Device, ProducerOptions } from 'mediasoup-client/types';
+export interface ConnectSendTransportScreenParameters {
+    screenProducer: Producer | null;
+    localScreenProducer?: Producer | null;
+    device: Device | null;
+    screenParams: ProducerOptions;
+    producerTransport: Transport | null;
+    localProducerTransport?: Transport | null;
+    params: ProducerOptions;
+    updateScreenProducer: (producer: Producer | null) => void;
+    updateLocalScreenProducer?: (localProducer: Producer | null) => void;
+    updateProducerTransport: (transport: Transport | null) => void;
+    updateLocalProducerTransport?: (localTransport: Transport | null) => void;
+    getUpdatedAllParams: () => ConnectSendTransportScreenParameters;
+    getCurrentParams?: () => any;
+    [key: string]: any;
+}
+export interface ConnectSendTransportScreenOptions {
+    stream: MediaStream;
+    parameters: ConnectSendTransportScreenParameters;
+    targetOption?: "all" | "local" | "remote";
+}
+export type ConnectSendTransportScreenType = (options: ConnectSendTransportScreenOptions) => Promise<void>;
+/**
+ * Sets up and connects a screen sharing transport for sending video streams.
+ *
+ * This function supports both a primary and a local screen producer, delegating local handling to a separate function.
+ *
+ * @param {ConnectSendTransportScreenOptions} options - The configuration options for setting up the screen transport.
+ * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for connecting the transport.
+ * @param {MediaStream} options.stream - The screen stream to be shared.
+ * @param {ConnectSendTransportScreenParameters} options.parameters - The parameters required for setting up the screen transport.
+ * @param {Producer | null} options.parameters.screenProducer - The screen producer object to be updated.
+ * @param {Device | null} options.parameters.device - The device object for media capabilities.
+ * @param {ProducerOptions} options.parameters.screenParams - The parameters for the screen producer.
+ * @param {Transport | null} options.parameters.producerTransport - The producer transport object.
+ * @param {ProducerOptions} options.parameters.params - The parameters for the producer.
+ * @param {Function} options.parameters.updateScreenProducer - The function to update the screen producer object.
+ * @param {Function} options.parameters.updateProducerTransport - The function to update the producer transport object.
+ * @param {Function} [options.parameters.updateLocalScreenProducer] - The function to update the local screen producer object.
+ * @param {Function} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport object.
+ * @param {Function} options.parameters.getUpdatedAllParams - The function to get updated parameters.
+ * @param {Object} [options.parameters.*] - Additional parameters for future use.
+ *
+ * @returns {Promise<void>} - A promise that resolves once the screen transport is successfully connected and set up.
+ *
+ * @throws Will throw an error if there is an issue with the connection or setup process.
+ *
+ * @example
+ * ```typescript
+ * await connectSendTransportScreen({
+ *   stream: screenStream,
+ *   targetOption: "all",
+ *   parameters: {
+ *     screenProducer: null,
+ *     localScreenProducer: null,
+ *     device: mediaDevice,
+ *     screenParams: { encodings: [{ maxBitrate: 1500000 }] },
+ *     producerTransport: sendTransport,
+ *     localProducerTransport: localSendTransport,
+ *     params: { track: screenStream.getVideoTracks()[0] },
+ *     updateScreenProducer: setScreenProducer,
+ *     updateLocalScreenProducer: setLocalScreenProducer,
+ *     updateProducerTransport: setProducerTransport,
+ *     updateLocalProducerTransport: setLocalProducerTransport,
+ *     getUpdatedAllParams: getParams,
+ *   },
+ * });
+ * ```
+ */
+export declare const connectSendTransportScreen: ConnectSendTransportScreenType;
+//# sourceMappingURL=connectSendTransportScreen.d.ts.map

package/dist/consumers/connectSendTransportScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectSendTransportScreen.d.ts","sourceRoot":"","sources":["../../src/consumers/connectSendTransportScreen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE3F,MAAM,WAAW,oCAAoC;IACnD,cAAc,EAAE,QAAQ,GAAG,IAAI,CAAC;IAChC,mBAAmB,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,eAAe,CAAC;IAC9B,iBAAiB,EAAE,SAAS,GAAG,IAAI,CAAC;IACpC,sBAAsB,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1C,MAAM,EAAE,eAAe,CAAC;IACxB,oBAAoB,EAAE,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1D,yBAAyB,CAAC,EAAE,CAAC,aAAa,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC;IACrE,uBAAuB,EAAE,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAC;IAC/D,4BAA4B,CAAC,EAAE,CAAC,cAAc,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAC;IAE1E,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;IAChE,gBAAgB,CAAC,EAAE,MAAM,GAAG,CAAC;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,iCAAiC;IAChD,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,oCAAoC,CAAC;IACjD,YAAY,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;CAC3C;AAGD,MAAM,MAAM,8BAA8B,GAAG,CAAC,OAAO,EAAE,iCAAiC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAuC3G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,eAAO,MAAM,0BAA0B,EAAE,8BAyDxC,CAAC"}

package/dist/consumers/connectSendTransportVideo.d.ts

@@ -0,0 +1,75 @@
+import { Device, Producer, ProducerOptions, Transport } from 'mediasoup-client/types';
+export interface ConnectSendTransportVideoParameters {
+    videoProducer: Producer | null;
+    localVideoProducer?: Producer | null;
+    device: Device | null;
+    producerTransport: Transport | null;
+    localProducerTransport?: Transport | null;
+    islevel: string;
+    updateMainWindow: boolean;
+    updateVideoProducer: (producer: Producer | null) => void;
+    updateLocalVideoProducer?: (localProducer: Producer | null) => void;
+    updateProducerTransport: (transport: Transport | null) => void;
+    updateLocalProducerTransport?: (localTransport: Transport | null) => void;
+    updateUpdateMainWindow: (state: boolean) => void;
+    [key: string]: any;
+}
+export interface ConnectSendTransportVideoOptions {
+    videoParams: ProducerOptions;
+    parameters: ConnectSendTransportVideoParameters;
+    targetOption?: "all" | "local" | "remote";
+}
+export type ConnectSendTransportVideoType = (options: ConnectSendTransportVideoOptions) => Promise<void>;
+/**
+ * Connects the send transport for video by producing video data and updates the relevant states.
+ *
+ * This function supports both a primary and a local video producer, delegating local handling to a separate function.
+ *
+ * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
+ * @param {ProducerOptions} options.videoParams - The parameters for the video producer.
+ * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for the video transport connection.
+ * @param {ConnectSendTransportVideoParameters} options.parameters - The parameters for the video transport connection.
+ * @param {Producer | null} options.parameters.videoProducer - The primary video producer.
+ * @param {Producer | null} [options.parameters.localVideoProducer] - The local video producer.
+ * @param {Device | null} options.parameters.device - The device information.
+ * @param {Transport | null} options.parameters.producerTransport - The primary producer transport.
+ * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport.
+ * @param {string} options.parameters.islevel - The connection level for the video transport.
+ * @param {boolean} options.parameters.updateMainWindow - The flag to update the main window state.
+ * @param {(producer: Producer | null) => void} options.parameters.updateVideoProducer - The function to update the video producer state.
+ * @param {(localProducer: Producer | null) => void} [options.parameters.updateLocalVideoProducer] - The function to update the local video producer state.
+ * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the producer transport state.
+ * @param {(localTransport: Transport | null) => void} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport state.
+ * @param {(state: boolean) => void} options.parameters.updateUpdateMainWindow - The function to update the main window state.
+ * @param {any} [options.parameters] - Additional parameters for future use.
+ * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * const options = {
+ *   videoParams: {
+ *     // video producer options (e.g., codec, bitrate)
+ *   },
+ *   targetOption: "all",
+ *   parameters: {
+ *     videoProducer: null,
+ *     localVideoProducer: null,
+ *     producerTransport: transport,
+ *     localProducerTransport: localTransport,
+ *     islevel: '2',
+ *     updateMainWindow: false,
+ *     updateVideoProducer: (producer) => console.log("Updated producer"),
+ *     updateLocalVideoProducer: (localProducer) => console.log("Updated local producer"),
+ *     updateProducerTransport: (transport) => console.log("Updated transport"),
+ *     updateLocalProducerTransport: (localTransport) => console.log("Updated local transport"),
+ *     updateUpdateMainWindow: (state) => console.log("Updated main window:", state),
+ *   },
+ * };
+ *
+ * connectSendTransportVideo(options)
+ *   .then(() => console.log("Video transport connected successfully"))
+ *   .catch((error) => console.error("Error connecting video transport:", error));
+ */
+export declare const connectSendTransportVideo: ConnectSendTransportVideoType;
+//# sourceMappingURL=connectSendTransportVideo.d.ts.map

package/dist/consumers/connectSendTransportVideo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectSendTransportVideo.d.ts","sourceRoot":"","sources":["../../src/consumers/connectSendTransportVideo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAE3F,MAAM,WAAW,mCAAmC;IAClD,aAAa,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC/B,kBAAkB,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACrC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,iBAAiB,EAAE,SAAS,GAAG,IAAI,CAAC;IACpC,sBAAsB,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mBAAmB,EAAE,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC;IACzD,wBAAwB,CAAC,EAAE,CAAC,aAAa,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC;IACpE,uBAAuB,EAAE,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAC;IAC/D,4BAA4B,CAAC,EAAE,CAAC,cAAc,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1E,sBAAsB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,gCAAgC;IAC/C,WAAW,EAAE,eAAe,CAAC;IAC7B,UAAU,EAAE,mCAAmC,CAAC;IAChD,YAAY,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;CAC3C;AAGD,MAAM,MAAM,6BAA6B,GAAG,CAAC,OAAO,EAAE,gCAAgC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AA4BzG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,eAAO,MAAM,yBAAyB,EAAE,6BA2CvC,CAAC"}

package/dist/consumers/consumerResume.d.ts

@@ -0,0 +1,16 @@
+import { Socket } from 'socket.io-client';
+export interface ConsumerResumeParameters {
+    [key: string]: any;
+}
+export interface ConsumerResumeOptions {
+    track: MediaStreamTrack;
+    kind: string;
+    remoteProducerId: string;
+    params: any;
+    parameters: ConsumerResumeParameters;
+    nsock: Socket;
+    consumer?: any;
+}
+export type ConsumerResumeType = (options: ConsumerResumeOptions) => Promise<void>;
+export declare const consumerResume: ConsumerResumeType;
+//# sourceMappingURL=consumerResume.d.ts.map

package/dist/consumers/consumerResume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumerResume.d.ts","sourceRoot":"","sources":["../../src/consumers/consumerResume.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,MAAM,WAAW,wBAAwB;IACvC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,GAAG,CAAC;IACZ,UAAU,EAAE,wBAAwB,CAAC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnF,eAAO,MAAM,cAAc,EAAE,kBAE5B,CAAC"}