agora-electron-sdk 4.5.2 → 4.5.3-dev.2

package/ts/Private/impl/IAgoraRtcEngineImpl.ts

@@ -94,6 +94,7 @@ import {
   IRtcEngine,
   IRtcEngineEventHandler,
   IVideoDeviceManager,
+  IVideoEffectObject,
   ImageTrackOptions,
   LeaveChannelOptions,
   Metadata,
@@ -106,6 +107,7 @@ import {
   Size,
   StreamFallbackOptions,
   VideoDeviceInfo,
+  VideoEffectAction,
 } from '../IAgoraRtcEngine';
 import { ILocalSpatialAudioEngine } from '../IAgoraSpatialAudio';
 import { IAudioDeviceManager } from '../IAudioDeviceManager';
@@ -308,6 +310,12 @@ export function processIRtcEngineEventHandler(
       }
       break;
 
+    case 'onLocalVideoEvent':
+      if (handler.onLocalVideoEvent !== undefined) {
+        handler.onLocalVideoEvent(jsonParams.source, jsonParams.event);
+      }
+      break;
+
     case 'onLocalVideoStateChanged':
       if (handler.onLocalVideoStateChanged !== undefined) {
         handler.onLocalVideoStateChanged(
@@ -957,6 +965,12 @@ export function processIRtcEngineEventHandler(
         handler.onSetRtmFlagResult(jsonParams.connection, jsonParams.code);
       }
       break;
+
+    case 'onMultipathStats':
+      if (handler.onMultipathStats !== undefined) {
+        handler.onMultipathStats(jsonParams.connection, jsonParams.stats);
+      }
+      break;
   }
 }
 
@@ -1091,6 +1105,275 @@ export class IVideoDeviceManagerImpl implements IVideoDeviceManager {
   }
 }
 
+// @ts-ignore
+export class IVideoEffectObjectImpl implements IVideoEffectObject {
+  addOrUpdateVideoEffect(nodeId: number, templateName: string): number {
+    const apiType = this.getApiTypeFromAddOrUpdateVideoEffect(
+      nodeId,
+      templateName
+    );
+    const jsonParams = {
+      nodeId: nodeId,
+      templateName: templateName,
+      toJSON: () => {
+        return {
+          nodeId: nodeId,
+          templateName: templateName,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromAddOrUpdateVideoEffect(
+    nodeId: number,
+    templateName: string
+  ): string {
+    return 'VideoEffectObject_addOrUpdateVideoEffect_303a98c';
+  }
+
+  removeVideoEffect(nodeId: number): number {
+    const apiType = this.getApiTypeFromRemoveVideoEffect(nodeId);
+    const jsonParams = {
+      nodeId: nodeId,
+      toJSON: () => {
+        return {
+          nodeId: nodeId,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromRemoveVideoEffect(nodeId: number): string {
+    return 'VideoEffectObject_removeVideoEffect_b48de50';
+  }
+
+  performVideoEffectAction(
+    nodeId: number,
+    actionId: VideoEffectAction
+  ): number {
+    const apiType = this.getApiTypeFromPerformVideoEffectAction(
+      nodeId,
+      actionId
+    );
+    const jsonParams = {
+      nodeId: nodeId,
+      actionId: actionId,
+      toJSON: () => {
+        return {
+          nodeId: nodeId,
+          actionId: actionId,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromPerformVideoEffectAction(
+    nodeId: number,
+    actionId: VideoEffectAction
+  ): string {
+    return 'VideoEffectObject_performVideoEffectAction_eddb1a6';
+  }
+
+  setVideoEffectStringParam(
+    option: string,
+    key: string,
+    param: string
+  ): number {
+    const apiType = this.getApiTypeFromSetVideoEffectStringParam(
+      option,
+      key,
+      param
+    );
+    const jsonParams = {
+      option: option,
+      key: key,
+      param: param,
+      toJSON: () => {
+        return {
+          option: option,
+          key: key,
+          param: param,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromSetVideoEffectStringParam(
+    option: string,
+    key: string,
+    param: string
+  ): string {
+    return 'VideoEffectObject_setVideoEffectStringParam_0e4f59e';
+  }
+
+  setVideoEffectFloatParam(option: string, key: string, param: number): number {
+    const apiType = this.getApiTypeFromSetVideoEffectFloatParam(
+      option,
+      key,
+      param
+    );
+    const jsonParams = {
+      option: option,
+      key: key,
+      param: param,
+      toJSON: () => {
+        return {
+          option: option,
+          key: key,
+          param: param,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromSetVideoEffectFloatParam(
+    option: string,
+    key: string,
+    param: number
+  ): string {
+    return 'VideoEffectObject_setVideoEffectFloatParam_e8dfcf8';
+  }
+
+  setVideoEffectIntParam(option: string, key: string, param: number): number {
+    const apiType = this.getApiTypeFromSetVideoEffectIntParam(
+      option,
+      key,
+      param
+    );
+    const jsonParams = {
+      option: option,
+      key: key,
+      param: param,
+      toJSON: () => {
+        return {
+          option: option,
+          key: key,
+          param: param,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromSetVideoEffectIntParam(
+    option: string,
+    key: string,
+    param: number
+  ): string {
+    return 'VideoEffectObject_setVideoEffectIntParam_3b77680';
+  }
+
+  setVideoEffectBoolParam(option: string, key: string, param: boolean): number {
+    const apiType = this.getApiTypeFromSetVideoEffectBoolParam(
+      option,
+      key,
+      param
+    );
+    const jsonParams = {
+      option: option,
+      key: key,
+      param: param,
+      toJSON: () => {
+        return {
+          option: option,
+          key: key,
+          param: param,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromSetVideoEffectBoolParam(
+    option: string,
+    key: string,
+    param: boolean
+  ): string {
+    return 'VideoEffectObject_setVideoEffectBoolParam_918930f';
+  }
+
+  getVideoEffectFloatParam(option: string, key: string): number {
+    const apiType = this.getApiTypeFromGetVideoEffectFloatParam(option, key);
+    const jsonParams = {
+      option: option,
+      key: key,
+      toJSON: () => {
+        return {
+          option: option,
+          key: key,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromGetVideoEffectFloatParam(
+    option: string,
+    key: string
+  ): string {
+    return 'VideoEffectObject_getVideoEffectFloatParam_ccad422';
+  }
+
+  getVideoEffectIntParam(option: string, key: string): number {
+    const apiType = this.getApiTypeFromGetVideoEffectIntParam(option, key);
+    const jsonParams = {
+      option: option,
+      key: key,
+      toJSON: () => {
+        return {
+          option: option,
+          key: key,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromGetVideoEffectIntParam(
+    option: string,
+    key: string
+  ): string {
+    return 'VideoEffectObject_getVideoEffectIntParam_ccad422';
+  }
+
+  getVideoEffectBoolParam(option: string, key: string): boolean {
+    const apiType = this.getApiTypeFromGetVideoEffectBoolParam(option, key);
+    const jsonParams = {
+      option: option,
+      key: key,
+      toJSON: () => {
+        return {
+          option: option,
+          key: key,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromGetVideoEffectBoolParam(
+    option: string,
+    key: string
+  ): string {
+    return 'VideoEffectObject_getVideoEffectBoolParam_ccad422';
+  }
+}
+
 export function processIMetadataObserver(
   handler: IMetadataObserver,
   event: string,
@@ -1771,6 +2054,54 @@ export class IRtcEngineImpl implements IRtcEngine {
     return 'RtcEngine_setFilterEffectOptions_53b4be3';
   }
 
+  createVideoEffectObject(
+    bundlePath: string,
+    type: MediaSourceType = MediaSourceType.PrimaryCameraSource
+  ): IVideoEffectObject {
+    const apiType = this.getApiTypeFromCreateVideoEffectObject(
+      bundlePath,
+      type
+    );
+    const jsonParams = {
+      bundlePath: bundlePath,
+      type: type,
+      toJSON: () => {
+        return {
+          bundlePath: bundlePath,
+          type: type,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromCreateVideoEffectObject(
+    bundlePath: string,
+    type: MediaSourceType = MediaSourceType.PrimaryCameraSource
+  ): string {
+    return 'RtcEngine_createVideoEffectObject_65bd50d';
+  }
+
+  destroyVideoEffectObject(videoEffectObject: IVideoEffectObject): number {
+    const apiType =
+      this.getApiTypeFromDestroyVideoEffectObject(videoEffectObject);
+    const jsonParams = {
+      videoEffectObject: videoEffectObject,
+      toJSON: () => {
+        return {};
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromDestroyVideoEffectObject(
+    videoEffectObject: IVideoEffectObject
+  ): string {
+    return 'RtcEngine_destroyVideoEffectObject_66d092b';
+  }
+
   setLowlightEnhanceOptions(
     enabled: boolean,
     options: LowlightEnhanceOptions,

package/ts/Private/internal/IrisApiEngine.ts

@@ -17,6 +17,7 @@ import {
   IVideoEncodedFrameObserver,
   IVideoFrameObserver,
   VideoFrame,
+  VideoSourceType,
 } from '../AgoraMediaBase';
 import { IH265TranscoderObserver } from '../IAgoraH265Transcoder';
 import {
@@ -65,6 +66,7 @@ import {
   MusicContentCenterInternal,
 } from './MusicContentCenterInternal';
 import { RtcEngineExInternal } from './RtcEngineExInternal';
+import { VideoEffectObjectInternal } from './VideoEffectObjectInternal';
 
 // @ts-ignore
 export const DeviceEventEmitter: EventEmitter = new EventEmitter();
@@ -343,6 +345,34 @@ export const EVENT_PROCESSORS: EventProcessors = {
         case 'onStreamMessageEx':
           data.data = buffers[0];
           break;
+        case 'onLocalVideoStats':
+          if (data) {
+            let rendererManager = AgoraEnv.AgoraRendererManager;
+            if (rendererManager) {
+              let sourceType = (data as any).sourceType;
+              let connection = (data as any).connection;
+              let rendererCaches =
+                rendererManager.getRendererCachesBySourceType(sourceType);
+              rendererCaches.forEach((cache) => {
+                cache.setCallbackContext(connection, sourceType);
+              });
+            }
+          }
+          break;
+        case 'onRemoteVideoStats':
+          if (data) {
+            let rendererManager = AgoraEnv.AgoraRendererManager;
+            if (rendererManager) {
+              let connection = (data as any).connection;
+              const sourceType = VideoSourceType.VideoSourceRemote;
+              let rendererCaches =
+                rendererManager.getRendererCachesBySourceType(sourceType);
+              rendererCaches.forEach((cache) => {
+                cache.setCallbackContext(connection, sourceType);
+              });
+            }
+          }
+          break;
       }
     },
     handlers: (event: string, data: any) => RtcEngineExInternal._event_handlers,
@@ -457,12 +487,15 @@ export function callIrisApi(funcName: string, params: any): any {
           // frame.buffer
           buffers.push(params.frame.buffer);
           // frame.eglContext
+          // @ts-ignore
           buffers.push(Buffer.from(''));
           // frame.metadata_buffer
+          // @ts-ignore
           buffers.push(Buffer.from(''));
           // frame.alphaBuffer
           buffers.push(params.frame.alphaBuffer);
           // frame.d3d11_texture_2d
+          // @ts-ignore
           buffers.push(Buffer.from(''));
           break;
         case 'MediaEngine_pushEncodedVideoImage_e71452b':
@@ -480,6 +513,13 @@ export function callIrisApi(funcName: string, params: any): any {
       params.toJSON = function () {
         return { ...json, playerId: params.mediaPlayerId };
       };
+    } else if (funcName.startsWith('VideoEffectObject_')) {
+      params.videoEffectObjectId = // @ts-ignore
+        (this as VideoEffectObjectInternal).getVideoEffectObjectId();
+      const json = params.toJSON?.call();
+      params.toJSON = function () {
+        return { ...json, objectId: params.videoEffectObjectId };
+      };
     } else if (funcName.startsWith('MediaRecorder_')) {
       // @ts-ignore
       params.nativeHandle = (this as MediaRecorderInternal).nativeHandle;
@@ -516,6 +556,13 @@ export function callIrisApi(funcName: string, params: any): any {
             return { playerId: params.mediaPlayerId };
           };
           break;
+        case 'RtcEngine_destroyVideoEffectObject_66d092b':
+          params.videoEffectObjectId =
+            params.videoEffectObject.getVideoEffectObjectId();
+          params.toJSON = function () {
+            return { objectId: params.videoEffectObjectId };
+          };
+          break;
         case 'RtcEngine_destroyMediaRecorder_95cdef5':
           // @ts-ignore
           params.nativeHandle = (

package/ts/Private/internal/RtcEngineExInternal.ts

@@ -1,8 +1,7 @@
 import { createCheckers } from 'ts-interface-checker';
 
 import { AgoraElectronBridge } from '../../Private/internal/IrisApiEngine';
-import { AgoraEnv, logError, parseIntPtr2Number } from '../../Utils';
-import { VideoEncoderConfiguration } from '../AgoraBase';
+import { AgoraEnv, logDebug, logError, parseIntPtr2Number } from '../../Utils';
 let RendererManager: any;
 let CapabilityManager: any;
 //@ts-ignore
@@ -28,6 +27,7 @@ import {
 } from '../AgoraBase';
 import {
   IAudioSpectrumObserver,
+  MediaSourceType,
   RenderModeType,
   VideoSourceType,
 } from '../AgoraMediaBase';
@@ -43,6 +43,7 @@ import {
   IMetadataObserver,
   IRtcEngineEventHandler,
   IVideoDeviceManager,
+  IVideoEffectObject,
   LeaveChannelOptions,
   MetadataType,
   RtcEngineContext,
@@ -73,6 +74,7 @@ import { MediaEngineInternal } from './MediaEngineInternal';
 import { MediaPlayerInternal } from './MediaPlayerInternal';
 import { MediaRecorderInternal } from './MediaRecorderInternal';
 import { MusicContentCenterInternal } from './MusicContentCenterInternal';
+import { VideoEffectObjectInternal } from './VideoEffectObjectInternal';
 
 const checkers = createCheckers(
   AgoraBaseTI,
@@ -80,6 +82,14 @@ const checkers = createCheckers(
   IAgoraRtcEngineTI
 );
 
+interface PerformanceCounter {
+  counters: {
+    counterId: number;
+    value: number;
+  }[];
+  uid: number;
+}
+
 export class RtcEngineExInternal extends IRtcEngineExImpl {
   static _event_handlers: IRtcEngineEventHandler[] = [];
   static _direct_cdn_streaming_event_handler: IDirectCdnStreamingEventHandler[] =
@@ -98,6 +108,13 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     new LocalSpatialAudioEngineInternal();
   private _h265_transcoder: IH265Transcoder = new H265TranscoderInternal();
 
+  private performanceInterval: number = 6000;
+  private performanceIntervalFunc: any;
+  private VideoRemoteRenderMeanFpsCounterId: number = 537;
+  private VideoRemoteRenderDrawCostCounterId: number = 576;
+  private VideoLocalRenderMeanFpsCounterId: number = 526;
+  private VideoLocalRenderDrawCostCounterId: number = 577;
+
   override initialize(context: RtcEngineContext): number {
     const ret = super.initialize(context);
     callIrisApi.call(this, 'RtcEngine_setAppType', {
@@ -112,6 +129,68 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
       if (AgoraEnv.CapabilityManager === undefined && CapabilityManager) {
         AgoraEnv.CapabilityManager = new CapabilityManager();
       }
+      if (AgoraEnv.enableArgusCounters) {
+        try {
+          this.performanceIntervalFunc = setInterval(() => {
+            let rendererManager = AgoraEnv.AgoraRendererManager;
+            let counters: {
+              data: PerformanceCounter[];
+              connection: RtcConnection;
+            }[] = [];
+            if (rendererManager) {
+              rendererManager.getRendererCaches().forEach((cache) => {
+                const isRemote =
+                  cache.callbackContext.sourceType ===
+                  VideoSourceType.VideoSourceRemote;
+                if (
+                  cache.callbackContext.connection?.channelId &&
+                  (cache.callbackContext.connection?.localUid || isRemote)
+                ) {
+                  let counter = counters.find(
+                    (counter) =>
+                      counter.connection.channelId ===
+                        cache.callbackContext.connection.channelId &&
+                      counter.connection.localUid ===
+                        cache.callbackContext.connection.localUid
+                  );
+                  let data: PerformanceCounter = {
+                    counters: [
+                      {
+                        counterId: isRemote
+                          ? this.VideoRemoteRenderMeanFpsCounterId
+                          : this.VideoLocalRenderMeanFpsCounterId,
+                        value: Math.floor(cache.actualFps),
+                      },
+                      {
+                        counterId: isRemote
+                          ? this.VideoRemoteRenderDrawCostCounterId
+                          : this.VideoLocalRenderDrawCostCounterId,
+                        value: Math.floor(cache.avgFrameInterval),
+                      },
+                    ],
+                    uid: isRemote ? cache.cacheContext.uid! : 0,
+                  };
+                  if (!counter) {
+                    counters.push({
+                      data: [data],
+                      connection: cache.callbackContext.connection,
+                    });
+                  } else {
+                    counter.data.push(data);
+                  }
+                }
+              });
+            }
+            counters.forEach((counter) => {
+              this.setParameters(
+                JSON.stringify({ 'rtc.report.argus_counters': counter })
+              );
+            });
+          }, this.performanceInterval);
+        } catch (error) {
+          logDebug('argus counters report error', error);
+        }
+      }
     }
     return ret;
   }
@@ -139,6 +218,10 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     this.removeAllListeners();
     AgoraEnv.CapabilityManager?.release();
     AgoraEnv.CapabilityManager = undefined;
+    if (this.performanceIntervalFunc) {
+      clearInterval(this.performanceIntervalFunc);
+      this.performanceIntervalFunc = undefined;
+    }
     super.release(sync);
   }
 
@@ -338,13 +421,6 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.unregisterMediaMetadataObserver(observer, type);
   }
 
-  override setVideoEncoderConfiguration(
-    config: VideoEncoderConfiguration
-  ): number {
-    AgoraEnv.encodeAlpha = config?.advanceOptions?.encodeAlpha ?? false;
-    return super.setVideoEncoderConfiguration(config);
-  }
-
   protected override getApiTypeFromJoinChannel(
     token: string,
     channelId: string,
@@ -521,6 +597,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
         if (!value.thumbImage?.buffer || !value.thumbImage?.length) {
           value.thumbImage!.buffer = undefined;
         } else {
+          // @ts-ignore
           value.thumbImage!.buffer = AgoraElectronBridge.GetBuffer(
             value.thumbImage!.buffer as unknown as number,
             value.thumbImage.length!
@@ -529,6 +606,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
         if (!value.iconImage?.buffer || !value.iconImage?.length) {
           value.iconImage!.buffer = undefined;
         } else {
+          // @ts-ignore
           value.iconImage.buffer = AgoraElectronBridge.GetBuffer(
             value.iconImage!.buffer as unknown as number,
             value.iconImage.length!
@@ -644,4 +722,23 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
       uid,
     });
   }
+
+  override createVideoEffectObject(
+    bundlePath: string,
+    type?: MediaSourceType
+  ): IVideoEffectObject {
+    // @ts-ignore
+    const videoEffectObjectId = super.createVideoEffectObject(
+      bundlePath,
+      type
+    ) as number;
+    return new VideoEffectObjectInternal(videoEffectObjectId);
+  }
+
+  override destroyVideoEffectObject(
+    videoEffectObject: IVideoEffectObject
+  ): number {
+    const ret = super.destroyVideoEffectObject(videoEffectObject);
+    return ret;
+  }
 }

package/ts/Private/internal/VideoEffectObjectInternal.ts

@@ -0,0 +1,14 @@
+import { IVideoEffectObjectImpl } from '../impl/IAgoraRtcEngineImpl';
+
+export class VideoEffectObjectInternal extends IVideoEffectObjectImpl {
+  private readonly _videoEffectObjectId: number;
+
+  constructor(videoEffectObjectId: number) {
+    super();
+    this._videoEffectObjectId = videoEffectObjectId;
+  }
+
+  getVideoEffectObjectId(): number {
+    return this._videoEffectObjectId;
+  }
+}

package/ts/Private/ti/IAgoraRtcEngine-ti.ts

@@ -28,6 +28,7 @@ export const IRtcEngineEventHandler = t.iface([], {
   "onFirstLocalVideoFramePublished": t.opt(t.func("void", t.param("connection", "RtcConnection"), t.param("elapsed", "number"))),
   "onFirstRemoteVideoDecoded": t.opt(t.func("void", t.param("connection", "RtcConnection"), t.param("remoteUid", "number"), t.param("width", "number"), t.param("height", "number"), t.param("elapsed", "number"))),
   "onVideoSizeChanged": t.opt(t.func("void", t.param("connection", "RtcConnection"), t.param("sourceType", "VideoSourceType"), t.param("uid", "number"), t.param("width", "number"), t.param("height", "number"), t.param("rotation", "number"))),
+  "onLocalVideoEvent": t.opt(t.func("void", t.param("source", "VideoSourceType"), t.param("event", "LocalVideoEventType"))),
   "onLocalVideoStateChanged": t.opt(t.func("void", t.param("source", "VideoSourceType"), t.param("state", "LocalVideoStreamState"), t.param("reason", "LocalVideoStreamReason"))),
   "onRemoteVideoStateChanged": t.opt(t.func("void", t.param("connection", "RtcConnection"), t.param("remoteUid", "number"), t.param("state", "RemoteVideoState"), t.param("reason", "RemoteVideoStateReason"), t.param("elapsed", "number"))),
   "onFirstRemoteVideoFrame": t.opt(t.func("void", t.param("connection", "RtcConnection"), t.param("remoteUid", "number"), t.param("width", "number"), t.param("height", "number"), t.param("elapsed", "number"))),
@@ -100,6 +101,7 @@ export const IRtcEngineEventHandler = t.iface([], {
   "onExtensionStoppedWithContext": t.opt(t.func("void", t.param("context", "ExtensionContext"))),
   "onExtensionErrorWithContext": t.opt(t.func("void", t.param("context", "ExtensionContext"), t.param("error", "number"), t.param("message", "string"))),
   "onSetRtmFlagResult": t.opt(t.func("void", t.param("connection", "RtcConnection"), t.param("code", "number"))),
+  "onMultipathStats": t.opt(t.func("void", t.param("connection", "RtcConnection"), t.param("stats", "MultipathStats"))),
 });
 
 export const IMetadataObserver = t.iface([], {