@webex/plugin-meetings 3.6.0 → 3.7.0-ipv6-multi-turn-urls.1

package/test/unit/spec/webinar/index.ts

@@ -2,6 +2,7 @@ import {assert, expect} from '@webex/test-helper-chai';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import Webinar from '@webex/plugin-meetings/src/webinar';
 import MockWebex from '@webex/test-helper-mock-webex';
+import uuid from 'uuid';
 import sinon from 'sinon';
 
 describe('plugin-meetings', () => {
@@ -9,18 +10,28 @@ describe('plugin-meetings', () => {
 
         let webex;
         let webinar;
+        let uuidStub;
+        let getUserTokenStub; 
 
         beforeEach(() => {
             // @ts-ignore
+            getUserTokenStub = sinon.stub().resolves('test-token'); 
+            uuidStub = sinon.stub(uuid,'v4').returns('test-uuid');            
             webex = new MockWebex({});
             webex.internal.mercury.on = sinon.stub();
             webinar = new Webinar({}, {parent: webex});
             webinar.locusUrl = 'locusUrl';
+            webinar.webcastInstanceUrl = 'webcastInstanceUrl';
             webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
             webex.meetings = {};
+            webex.credentials.getUserToken = getUserTokenStub;
             webex.meetings.getMeetingByType = sinon.stub();
         });
 
+        afterEach(() => {
+          sinon.restore(); 
+        });
+
         describe('#locusUrlUpdate', () => {
             it('sets the locus url', () => {
                 webinar.locusUrlUpdate('newUrl');
@@ -29,32 +40,450 @@ describe('plugin-meetings', () => {
             });
         });
 
-        describe('#webcastUrlUpdate', () => {
-            it('sets the webcast url', () => {
-                webinar.webcastUrlUpdate('newUrl');
+        describe('#updateWebcastUrl', () => {
+            it('sets the webcast instance url', () => {
+                webinar.updateWebcastUrl({resources: {webcastInstance: {url:'newUrl'}}});
 
-                assert.equal(webinar.webcastUrl, 'newUrl');
+                assert.equal(webinar.webcastInstanceUrl, 'newUrl');
             });
         });
 
-        describe('#webinarAttendeesSearchingUrlUpdate', () => {
-            it('sets the webinarAttendeesSearching url', () => {
-                webinar.webinarAttendeesSearchingUrlUpdate('newUrl');
 
-                assert.equal(webinar.webinarAttendeesSearchingUrl, 'newUrl');
+        describe('#updateCanManageWebcast', () => {
+          it('sets the webcast instance url when valid', () => {
+            webinar.updateWebcastUrl({resources: {webcastInstance: {url:'newUrl'}}});
+            assert.equal(webinar.webcastInstanceUrl, 'newUrl', 'webcast instance URL should be updated');
+          });
+
+          it('handles missing resources gracefully', () => {
+              webinar.updateWebcastUrl({});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
+
+          it('handles missing webcastInstance gracefully', () => {
+              webinar.updateWebcastUrl({resources: {}});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
+
+          it('handles missing URL gracefully', () => {
+              webinar.updateWebcastUrl({resources: {webcastInstance: {}}});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
+        });
+
+      describe('#updateRoleChanged', () => {
+        it('updates roles when promoted from attendee to panelist', () => {
+          const payload = {
+            oldRoles: ['ATTENDEE'],
+            newRoles: ['PANELIST']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, true, 'self should be a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, true, 'should indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+
+        it('updates roles when demoted from panelist to attendee', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            newRoles: ['ATTENDEE']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, false, 'self should not be a panelist');
+          assert.equal(webinar.selfIsAttendee, true, 'self should be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, true, 'should indicate demotion');
+        });
+
+        it('updates roles when promoted to moderator', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            newRoles: ['MODERATOR']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, false, 'self should not be a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, true, 'self should have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+
+        it('updates roles when unchanged (remains as panelist)', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            newRoles: ['PANELIST']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, true, 'self should remain a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+      });
+
+      describe("#setPracticeSessionState", () => {
+        [true, false].forEach((enabled) => {
+          it(`sends a PATCH request to ${enabled ? "enable" : "disable"} the practice session`, async () => {
+            const result = await webinar.setPracticeSessionState(enabled);
+            assert.calledOnce(webex.request);
+            assert.calledWith(webex.request, {
+              method: "PATCH",
+              uri: `${webinar.locusUrl}/controls`,
+              body: {
+                practiceSession: { enabled }
+              }
             });
+            assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+          });
         });
 
-        describe('#updateCanManageWebcast', () => {
-          it('update canManageWebcast', () => {
-            webinar.updateCanManageWebcast(true);
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.setPracticeSessionState(true);
+            assert.fail('setPracticeSessionState should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#setPracticeSessionState failed', sinon.match.instanceOf(Error));
+          }
 
-            assert.equal(webinar.canManageWebcast, true);
+          errorLogger.restore();
+        });
+      });
+
+      describe('#updatePracticeSessionStatus', () => {
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: true});
 
-            webinar.updateCanManageWebcast(false);
+          assert.equal(webinar.practiceSessionEnabled, true);
+        });
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: false});
 
-            assert.equal(webinar.canManageWebcast, false);
+          assert.equal(webinar.practiceSessionEnabled, false);
+        });
+      });
+
+      describe("#startWebcast", () => {
+        const meeting = {
+          locusId: 'locusId',
+          correlationId: 'correlationId',
+        }
+        const layout = {
+          videoLayout: 'Prominent',
+          contentLayout: 'Prominent',
+          syncStageLayout: false,
+          syncStageInMeeting: false,
+        }
+        it(`sends a PUT request to start the webcast`, async () => {
+          const result = await webinar.startWebcast(meeting, layout);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "PUT",
+            uri: `${webinar.webcastInstanceUrl}/streaming`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+              'Content-Type': 'application/json'
+            },
+            body: {
+              action: 'start',
+              meetingInfo: {
+                locusId: meeting.locusId,
+                correlationId: meeting.correlationId,
+              },
+              layout,
+            }
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('should handle undefined meeting parameter', async () => {
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.startWebcast(undefined, layout);
+            assert.fail('startWebcast should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'Meeting parameter does not meet expectations', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, `Meeting:webinar#startWebcast failed --> meeting parameter : ${undefined}`);
+          } finally {
+            errorLogger.restore();
+          }
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.startWebcast(meeting, layout);
+            assert.fail('startWebcast should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#startWebcast failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
+
+      describe("#stopWebcast", () => {
+        it(`sends a PUT request to stop the webcast`, async () => {
+          const result = await webinar.stopWebcast();
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "PUT",
+            uri: `${webinar.webcastInstanceUrl}/streaming`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+              'Content-Type': 'application/json'
+            },
+            body: {
+              action: 'stop',
+            }
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+  
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+  
+          try {
+            await webinar.stopWebcast();
+            assert.fail('stopWebcast should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#stopWebcast failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }  
+        });
+      });
+
+
+      describe("#queryWebcastLayout", () => {
+        it(`sends a GET request to query the webcast layout`, async () => {
+          const result = await webinar.queryWebcastLayout();
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/layout`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+  
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+  
+          try {
+            await webinar.queryWebcastLayout();
+            assert.fail('queryWebcastLayout should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#queryWebcastLayout failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }  
+        });
+      });
+
+      describe("#updateWebcastLayout", () => {
+        const layout = {
+          videoLayout: 'Prominent',
+          contentLayout: 'Prominent',
+          syncStageLayout: false,
+          syncStageInMeeting: false,
+        }
+        it(`sends a PUT request to update the webcast layout`, async () => {
+          const result = await webinar.updateWebcastLayout(layout);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "PUT",
+            uri: `${webinar.webcastInstanceUrl}/layout`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+              'Content-Type': 'application/json'
+            },
+            body: {
+              ...layout
+            }
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+  
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+  
+          try {
+            await webinar.updateWebcastLayout(layout);
+            assert.fail('updateWebcastLayout should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#updateWebcastLayout failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }  
+        });
+      });
+      
+      describe("#searchWebcastAttendees", () => {
+        const queryString = 'queryString';
+        const specialCharsQuery = 'query@string!';
+        const emptyQuery = '';
+      
+        it("sends a GET request to search the webcast attendees", async () => {
+          const result = await webinar.searchWebcastAttendees(queryString);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(queryString)}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
           });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+      
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+      
+          try {
+            await webinar.searchWebcastAttendees(queryString);
+            assert.fail('searchWebcastAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#searchWebcastAttendees failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      
+        it("should handle empty query string", async () => {
+          const result = await webinar.searchWebcastAttendees(emptyQuery);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(emptyQuery)}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+      
+        it("should handle query string with special characters", async () => {
+          const result = await webinar.searchWebcastAttendees(specialCharsQuery);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(specialCharsQuery)}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+      });
+      
+
+      describe("#viewAllWebcastAttendees", () => {
+        it(`sends a GET request to view all the webcast attendees`, async () => {
+          const result = await webinar.viewAllWebcastAttendees();
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+  
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+  
+          try {
+            await webinar.viewAllWebcastAttendees();
+            assert.fail('viewAllWebcastAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#viewAllWebcastAttendees failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }  
+        });
+      });
+            
+      describe("#expelWebcastAttendee", () => {
+        const participantId = 'participantId'
+        it(`sends a DELETE request to expel the webcast attendee`, async () => {
+          const result = await webinar.expelWebcastAttendee(participantId);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "DELETE",
+            uri: `${webinar.webcastInstanceUrl}/attendees/${participantId}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+  
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+  
+          try {
+            await webinar.expelWebcastAttendee(participantId);
+            assert.fail('expelWebcastAttendee should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#expelWebcastAttendee failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
         });
+      });
     })
 })

package/dist/annotation/annotation.types.d.ts

@@ -1,42 +0,0 @@
-import { ANNOTATION_POLICY } from './constants';
-/**
- * Type for an StrokeData Object
- */
-type StrokeData = {
-    deviceId: string;
-    toUserId: string;
-    requesterId: string;
-    content: string;
-    shareInstanceId: string;
-    encryptionKeyUrl: string;
-    version: string;
-};
-type RequestData = {
-    toUserId: string;
-    toDeviceUrl: string;
-    shareInstanceId: string;
-};
-type CommandRequestBody = {
-    actionType: string;
-    resourceType: string;
-    shareInstanceId: string;
-    receivers?: any[];
-};
-/**
- * Type for an annotation Object include annotation version and privilege
- */
-type AnnotationInfo = {
-    version: string;
-    policy: ANNOTATION_POLICY;
-};
-interface IAnnotationChannel {
-    acceptRequest: (approval: any) => undefined | Promise<void>;
-    declineRequest: (approval: any) => undefined | Promise<void>;
-    closeAnnotation: (requestData: RequestData) => undefined | Promise<void>;
-    approveAnnotation: (requestData: RequestData) => undefined | Promise<void>;
-    cancelApproveAnnotation: (requestData: RequestData, approval: any) => undefined | Promise<void>;
-    sendStrokeData: (strokeData: StrokeData) => void;
-    approvalUrlUpdate: (approvalUrl: string) => void;
-    locusUrlUpdate: (locusUrl: string) => void;
-}
-export type { StrokeData, RequestData, CommandRequestBody, IAnnotationChannel, AnnotationInfo };

package/dist/annotation/constants.d.ts

@@ -1,31 +0,0 @@
-export declare const EVENT_TRIGGERS: {
-    ANNOTATION_STROKE_DATA: string;
-    ANNOTATION_COMMAND: string;
-};
-export declare const ANNOTATION_RESOURCE_TYPE = "AnnotationOnShare";
-export declare const ANNOTATION_RELAY_TYPES: {
-    ANNOTATION_CLIENT: string;
-};
-export declare const ANNOTATION_STATUS: {
-    NO_ANNOTATION: string;
-    RUNNING_ANNOTATION: string;
-};
-export declare enum ANNOTATION_POLICY {
-    ANYONE_CAN_ANNOTATE = "AnyoneCanAnnotate",
-    APPROVAL = "Approval",
-    ANNOTATION_NOT_ALLOWED = "AnnotationNotAllowed"
-}
-export declare const ANNOTATION_REQUEST_TYPE: {
-    ANNOTATION_MESSAGE: string;
-};
-export declare const enum ANNOTATION_ACTION_TYPE {
-    REQUESTED = "REQUESTED",
-    ACCEPTED = "ACCEPTED",
-    DECLINED = "DECLINED",
-    OFFERED = "OFFERED",
-    CANCELED = "CANCELED",
-    EXPIRED = "EXPIRED",
-    REVOKED = "REVOKED",
-    CLOSED = "CLOSED"
-}
-export declare const ANNOTATION = "annotation";

package/dist/annotation/index.d.ts

@@ -1,117 +0,0 @@
-import { WebexPlugin } from '@webex/webex-core';
-import { StrokeData, RequestData, IAnnotationChannel } from './annotation.types';
-/**
- * @description Annotation to handle LLM and Mercury message and locus API
- * @class
- */
-declare class AnnotationChannel extends WebexPlugin implements IAnnotationChannel {
-    namespace: string;
-    private seqNum;
-    hasSubscribedToEvents: boolean;
-    approvalUrl: string;
-    locusUrl: string;
-    deviceUrl: string;
-    /**
-     * Initializes annotation module
-     */
-    constructor(...args: any[]);
-    /**
-     * Process Stroke Data
-     * @param {object}  data
-     * @returns {void}
-     */
-    private processStrokeMessage;
-    /** bind all events from mercury
-     * @param {Object} e
-     * @returns {undefined}
-     */
-    private eventCommandProcessor;
-    /** bind all events from llm
-     * @param {Object} e
-     * @returns {undefined}
-     */
-    private eventDataProcessor;
-    /**
-     * Listen to websocket messages
-     * @returns {undefined}
-     */
-    private listenToEvents;
-    /**
-     * set locusUrl
-     * @param {string} locusUrl
-     * @returns {void}
-     */
-    locusUrlUpdate(locusUrl: string): void;
-    /**
-     * set approved url
-     * @param {string} approvalUrl
-     * @returns {void}
-     */
-    approvalUrlUpdate(approvalUrl: string): void;
-    /**
-     * accept request
-     * @param {object} approval
-     * @returns {Promise}
-     */
-    acceptRequest(approval: any): any;
-    /**
-     * presenter declined request annotation
-     * @param {approval} approval
-     * @returns {Promise}
-     */
-    declineRequest(approval: any): any;
-    /**
-     * request approved annotation
-     * @param {RequestData} requestData
-     * @returns {Promise}
-     */
-    approveAnnotation(requestData: RequestData): Promise<void>;
-    /**
-     * cancel approved annotation
-     * @param {object} requestData
-     * @param {object} approval
-     * @returns {Promise}
-     */
-    cancelApproveAnnotation(requestData: RequestData, approval: any): any;
-    /**
-     * close annotation
-     * @param {object} requestData
-     * @returns {Promise}
-     */
-    closeAnnotation(requestData: RequestData): Promise<void>;
-    /**
-     * send annotation command
-     * @param {ANNOTATION_ACTION_TYPE} actionType
-     * @param {RequestData} requestData
-     * @returns {Promise}
-     */
-    private sendAnnotationAction;
-    /**
-     * decrypt data
-     * @param {string} encryptionKeyUrl
-     * @param {string} content encrypted content
-     * @returns {string} decrypted content
-     */
-    private decryptContent;
-    /**
-     * encrypt data
-     * @param {string} encryptionKeyUrl
-     * @param {string} content original content
-     * @returns {string} encrypted content
-     */
-    private encryptContent;
-    /**
-     * Sends stroke data to presenter
-     * @param {StrokeData} strokeData
-     * @returns {void}
-     */
-    sendStrokeData: (strokeData: StrokeData) => void;
-    /**
-     * private encrypted the strokes data
-     * @param {string} encryptedContent
-     * @param {StrokeData} strokeData
-     * @returns {void}
-     */
-    private publishEncrypted;
-}
-export default AnnotationChannel;