@rhc-office/sdk 6.6.264 → 6.6.268

package/src/tools/AnnotationToolImpl.ts

@@ -0,0 +1,263 @@
+import type { AnnotationTool, IDigitalAnnotationInfo } from '../api/annotation-tool';
+import type { AnnotationEventCallback } from '../api/callbacks';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const ANNOTATION_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  addAnnotationEventCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.annotationEvents.push(callback as AnnotationEventCallback);
+      }
+    },
+  },
+  addAnnotationPersistCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.annotationPersist.push(callback as (event: unknown) => void);
+      }
+    },
+  },
+  addAnnotationRetrieveCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.annotationRetrieve.push(callback as (event: unknown) => void);
+      }
+    },
+  },
+  addDigitalAnnotationRetrieveCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.digitalAnnotationRetrieve.push(
+          callback as (annotations: IDigitalAnnotationInfo[]) => void,
+        );
+      }
+    },
+  },
+  isInAnnotationMode: {
+    kind: 'stateGetter',
+    state: (state) => state.annotationEnabled,
+  },
+  getAnnotations: { kind: 'stateGetter', state: () => [] },
+  getAnnotationsCount: { kind: 'stateGetter', state: () => 0 },
+  queryAnnotationsBy: { kind: 'stateGetter', state: () => [] },
+  setToolSource: { kind: 'command' },
+  openAnnotationView: { kind: 'command' },
+  closeAnnotationView: { kind: 'command' },
+  openTextAnnotationView: { kind: 'command' },
+  setTextAnnotationFontColor: { kind: 'command' },
+  setTextAnnotationFontSize: { kind: 'command' },
+  closeTextAnnotationView: { kind: 'command' },
+  createTextAnnotation: { kind: 'command' },
+  setPersistToDocument: { kind: 'command' },
+  saveAnnotations: { kind: 'callbackQuery' },
+  saveTextAnnotations: { kind: 'command' },
+  clearAnnotations: { kind: 'command' },
+  clearTextAnnotations: { kind: 'command' },
+  undoAnnotation: { kind: 'command' },
+  redoAnnotation: { kind: 'command' },
+  selectAnnotationTool: { kind: 'command' },
+  showAnnotationColorPicker: { kind: 'command' },
+  setAnnotationPenType: { kind: 'command' },
+  appendAnnotations: { kind: 'callbackQuery' },
+  batchAppendAnnotations: { kind: 'callbackQuery' },
+  setAnnotationPenColor: { kind: 'command' },
+  setAnnotationPenWidth: { kind: 'command' },
+  setAnnotationPenThickness: { kind: 'command' },
+  enableAnnotationsInfoView: { kind: 'command' },
+  enableAnnotationsDeletion: { kind: 'command' },
+  enableAnnotationsDeletionOnlyByAuthor: { kind: 'command' },
+  listDigitalStamps: { kind: 'command' },
+  listAnnotations: { kind: 'command' },
+  deleteAnnotationsBy: { kind: 'command' },
+  deleteAnnotationsById: { kind: 'command' },
+  addDigitalAnnotation: { kind: 'command' },
+  addInkAnnotationCallback: { kind: 'callbackRegister' },
+};
+
+export class AnnotationToolImpl implements AnnotationTool {
+  private readonly adapter: AnnotationTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<AnnotationTool>(
+      'annotation',
+      ANNOTATION_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  setToolSource: AnnotationTool['setToolSource'] = (source) => {
+    return this.adapter.setToolSource(source);
+  };
+
+  openAnnotationView: AnnotationTool['openAnnotationView'] = (options) => {
+    return this.adapter.openAnnotationView(options);
+  };
+
+  closeAnnotationView: AnnotationTool['closeAnnotationView'] = (saveModifications) => {
+    return this.adapter.closeAnnotationView(saveModifications);
+  };
+
+  openTextAnnotationView: AnnotationTool['openTextAnnotationView'] = () => {
+    return this.adapter.openTextAnnotationView();
+  };
+
+  setTextAnnotationFontColor: AnnotationTool['setTextAnnotationFontColor'] = (color) => {
+    return this.adapter.setTextAnnotationFontColor(color);
+  };
+
+  setTextAnnotationFontSize: AnnotationTool['setTextAnnotationFontSize'] = (size) => {
+    return this.adapter.setTextAnnotationFontSize(size);
+  };
+
+  closeTextAnnotationView: AnnotationTool['closeTextAnnotationView'] = (saveModifications) => {
+    return this.adapter.closeTextAnnotationView(saveModifications);
+  };
+
+  createTextAnnotation: AnnotationTool['createTextAnnotation'] = (options) => {
+    return this.adapter.createTextAnnotation(options);
+  };
+
+  setPersistToDocument: AnnotationTool['setPersistToDocument'] = (persist) => {
+    return this.adapter.setPersistToDocument(persist);
+  };
+
+  saveAnnotations: AnnotationTool['saveAnnotations'] = (saveCallback) => {
+    return this.adapter.saveAnnotations(saveCallback);
+  };
+
+  saveTextAnnotations: AnnotationTool['saveTextAnnotations'] = () => {
+    return this.adapter.saveTextAnnotations();
+  };
+
+  clearAnnotations: AnnotationTool['clearAnnotations'] = () => {
+    return this.adapter.clearAnnotations();
+  };
+
+  clearTextAnnotations: AnnotationTool['clearTextAnnotations'] = () => {
+    return this.adapter.clearTextAnnotations();
+  };
+
+  undoAnnotation: AnnotationTool['undoAnnotation'] = () => {
+    return this.adapter.undoAnnotation();
+  };
+
+  redoAnnotation: AnnotationTool['redoAnnotation'] = () => {
+    return this.adapter.redoAnnotation();
+  };
+
+  selectAnnotationTool: AnnotationTool['selectAnnotationTool'] = (tool) => {
+    return this.adapter.selectAnnotationTool(tool);
+  };
+
+  showAnnotationColorPicker: AnnotationTool['showAnnotationColorPicker'] = () => {
+    return this.adapter.showAnnotationColorPicker();
+  };
+
+  setAnnotationPenType: AnnotationTool['setAnnotationPenType'] = (penType) => {
+    return this.adapter.setAnnotationPenType(penType);
+  };
+
+  appendAnnotations: AnnotationTool['appendAnnotations'] = (inkData, callback) => {
+    return this.adapter.appendAnnotations(inkData, callback);
+  };
+
+  batchAppendAnnotations: AnnotationTool['batchAppendAnnotations'] = (inkData, callback) => {
+    return this.adapter.batchAppendAnnotations(inkData, callback);
+  };
+
+  setAnnotationPenColor: AnnotationTool['setAnnotationPenColor'] = (hexColor) => {
+    return this.adapter.setAnnotationPenColor(hexColor);
+  };
+
+  setAnnotationPenWidth: AnnotationTool['setAnnotationPenWidth'] = (penWidth) => {
+    return this.adapter.setAnnotationPenWidth(penWidth);
+  };
+
+  setAnnotationPenThickness: AnnotationTool['setAnnotationPenThickness'] = (thickness) => {
+    return this.adapter.setAnnotationPenThickness(thickness);
+  };
+
+  enableAnnotationsInfoView: AnnotationTool['enableAnnotationsInfoView'] = (enabled) => {
+    return this.adapter.enableAnnotationsInfoView(enabled);
+  };
+
+  enableAnnotationsDeletion: AnnotationTool['enableAnnotationsDeletion'] = (enabled) => {
+    return this.adapter.enableAnnotationsDeletion(enabled);
+  };
+
+  enableAnnotationsDeletionOnlyByAuthor: AnnotationTool['enableAnnotationsDeletionOnlyByAuthor'] = (
+    onlyByAuthor,
+  ) => {
+    return this.adapter.enableAnnotationsDeletionOnlyByAuthor(onlyByAuthor);
+  };
+
+  listDigitalStamps: AnnotationTool['listDigitalStamps'] = () => {
+    return this.adapter.listDigitalStamps();
+  };
+
+  isInAnnotationMode: AnnotationTool['isInAnnotationMode'] = () => {
+    return this.adapter.isInAnnotationMode();
+  };
+
+  listAnnotations: AnnotationTool['listAnnotations'] = (options) => {
+    return this.adapter.listAnnotations(options);
+  };
+
+  getAnnotations: AnnotationTool['getAnnotations'] = () => {
+    return this.adapter.getAnnotations();
+  };
+
+  getAnnotationsCount: AnnotationTool['getAnnotationsCount'] = () => {
+    return this.adapter.getAnnotationsCount();
+  };
+
+  queryAnnotationsBy: AnnotationTool['queryAnnotationsBy'] = (query) => {
+    return this.adapter.queryAnnotationsBy(query);
+  };
+
+  deleteAnnotationsBy: AnnotationTool['deleteAnnotationsBy'] = (query, prompt) => {
+    return this.adapter.deleteAnnotationsBy(query, prompt);
+  };
+
+  deleteAnnotationsById: AnnotationTool['deleteAnnotationsById'] = (annotationIds, prompt) => {
+    return this.adapter.deleteAnnotationsById(annotationIds, prompt);
+  };
+
+  addDigitalAnnotation: AnnotationTool['addDigitalAnnotation'] = (options) => {
+    return this.adapter.addDigitalAnnotation(options);
+  };
+
+  addInkAnnotationCallback: AnnotationTool['addInkAnnotationCallback'] = (callback) => {
+    return this.adapter.addInkAnnotationCallback(callback);
+  };
+
+  addAnnotationEventCallback: AnnotationTool['addAnnotationEventCallback'] = (callback) => {
+    return this.adapter.addAnnotationEventCallback(callback);
+  };
+
+  addAnnotationPersistCallback: AnnotationTool['addAnnotationPersistCallback'] = (callback) => {
+    return this.adapter.addAnnotationPersistCallback(callback);
+  };
+
+  addAnnotationRetrieveCallback: AnnotationTool['addAnnotationRetrieveCallback'] = (callback) => {
+    return this.adapter.addAnnotationRetrieveCallback(callback);
+  };
+
+  addDigitalAnnotationRetrieveCallback: AnnotationTool['addDigitalAnnotationRetrieveCallback'] = (
+    callback,
+  ) => {
+    return this.adapter.addDigitalAnnotationRetrieveCallback(callback);
+  };
+}

package/src/tools/CryptoToolImpl.ts

@@ -0,0 +1,27 @@
+import type { CryptoTool } from '../api/crypto-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const CRYPTO_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  configSecurityProvider: { kind: 'command' },
+  getSecurityProviders: { kind: 'query' },
+};
+
+export class CryptoToolImpl implements CryptoTool {
+  private readonly adapter: CryptoTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<CryptoTool>('crypto', CRYPTO_TOOL_DESCRIPTOR, context);
+  }
+
+  configSecurityProvider: CryptoTool['configSecurityProvider'] = (providers) => {
+    return this.adapter.configSecurityProvider(providers);
+  };
+
+  getSecurityProviders: CryptoTool['getSecurityProviders'] = () => {
+    return this.adapter.getSecurityProviders();
+  };
+}

package/src/tools/DigitalSignToolImpl.ts

@@ -0,0 +1,155 @@
+import type { DigitalSignatureRetrieveCallback, DigitalSignCallback } from '../api/callbacks';
+import type { DigitalSignTool } from '../api/sign-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const DIGITAL_SIGN_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  addDigitalSignatureRetrieveCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.digitalSignatureRetrieve.push(callback as DigitalSignatureRetrieveCallback);
+      }
+    },
+  },
+  addDigitalSignatureParseCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.digitalSignatureParse.push(callback as DigitalSignatureRetrieveCallback);
+      }
+    },
+  },
+  addDigitalSignCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.digitalSign.push(callback as DigitalSignCallback);
+      }
+    },
+  },
+  setCryptoProvider: { kind: 'command' },
+  setSealSource: { kind: 'command' },
+  setDefaultStampPassword: { kind: 'command' },
+  setDefaultSealPassword: { kind: 'command' },
+  setDefaultKeystorePassword: { kind: 'command' },
+  setDefaultUSBKeyPassword: { kind: 'command' },
+  setupExternalSealServer: { kind: 'command' },
+  setDigitalSignOptions: { kind: 'command' },
+  setExternalDigitalSignOptions: { kind: 'command' },
+  setPDFDigitalSignCaptionOptions: { kind: 'command' },
+  addDigitalSignature: { kind: 'callbackQuery' },
+  addDigitalSignatureBySelectedSearchHighlight: { kind: 'command' },
+  listDigitalSignatures: { kind: 'callbackQuery' },
+  getDigitalSignatures: { kind: 'stateGetter', state: () => [] },
+  getDigitalSignaturesCount: { kind: 'stateGetter', state: () => 0 },
+  enableDigitalSignatureInfoView: { kind: 'command' },
+  enableDigitalSignatureRevocation: { kind: 'command' },
+};
+
+export class DigitalSignToolImpl implements DigitalSignTool {
+  private readonly adapter: DigitalSignTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<DigitalSignTool>(
+      'digitalSign',
+      DIGITAL_SIGN_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  addDigitalSignatureRetrieveCallback: DigitalSignTool['addDigitalSignatureRetrieveCallback'] = (
+    callback,
+  ) => {
+    return this.adapter.addDigitalSignatureRetrieveCallback(callback);
+  };
+
+  addDigitalSignatureParseCallback: DigitalSignTool['addDigitalSignatureParseCallback'] = (
+    callback,
+  ) => {
+    return this.adapter.addDigitalSignatureParseCallback(callback);
+  };
+
+  setCryptoProvider: DigitalSignTool['setCryptoProvider'] = (usage, provider, configuration) => {
+    return this.adapter.setCryptoProvider(usage, provider, configuration);
+  };
+
+  setSealSource: DigitalSignTool['setSealSource'] = (source) => {
+    return this.adapter.setSealSource(source);
+  };
+
+  setDefaultStampPassword: DigitalSignTool['setDefaultStampPassword'] = (stampPassword) => {
+    return this.adapter.setDefaultStampPassword(stampPassword);
+  };
+
+  setDefaultSealPassword: DigitalSignTool['setDefaultSealPassword'] = (sealPassword) => {
+    return this.adapter.setDefaultSealPassword(sealPassword);
+  };
+
+  setDefaultKeystorePassword: DigitalSignTool['setDefaultKeystorePassword'] = (pkPassword) => {
+    return this.adapter.setDefaultKeystorePassword(pkPassword);
+  };
+
+  setDefaultUSBKeyPassword: DigitalSignTool['setDefaultUSBKeyPassword'] = (pkPassword) => {
+    return this.adapter.setDefaultUSBKeyPassword(pkPassword);
+  };
+
+  addDigitalSignCallback: DigitalSignTool['addDigitalSignCallback'] = (callback) => {
+    return this.adapter.addDigitalSignCallback(callback);
+  };
+
+  setupExternalSealServer: DigitalSignTool['setupExternalSealServer'] = (options) => {
+    return this.adapter.setupExternalSealServer(options);
+  };
+
+  setDigitalSignOptions: DigitalSignTool['setDigitalSignOptions'] = (options) => {
+    return this.adapter.setDigitalSignOptions(options);
+  };
+
+  setExternalDigitalSignOptions: DigitalSignTool['setExternalDigitalSignOptions'] = (options) => {
+    return this.adapter.setExternalDigitalSignOptions(options);
+  };
+
+  setPDFDigitalSignCaptionOptions: DigitalSignTool['setPDFDigitalSignCaptionOptions'] = (
+    options,
+  ) => {
+    return this.adapter.setPDFDigitalSignCaptionOptions(options);
+  };
+
+  addDigitalSignature: DigitalSignTool['addDigitalSignature'] = (options, callback) => {
+    return this.adapter.addDigitalSignature(options, callback);
+  };
+
+  addDigitalSignatureBySelectedSearchHighlight: DigitalSignTool['addDigitalSignatureBySelectedSearchHighlight'] =
+    (options) => {
+      return this.adapter.addDigitalSignatureBySelectedSearchHighlight(options);
+    };
+
+  listDigitalSignatures: DigitalSignTool['listDigitalSignatures'] = (callback) => {
+    return this.adapter.listDigitalSignatures(callback);
+  };
+
+  getDigitalSignatures: DigitalSignTool['getDigitalSignatures'] = () => {
+    return this.adapter.getDigitalSignatures();
+  };
+
+  getDigitalSignaturesCount: DigitalSignTool['getDigitalSignaturesCount'] = () => {
+    return this.adapter.getDigitalSignaturesCount();
+  };
+
+  enableDigitalSignatureInfoView: DigitalSignTool['enableDigitalSignatureInfoView'] = (enabled) => {
+    return this.adapter.enableDigitalSignatureInfoView(enabled);
+  };
+
+  enableDigitalSignatureRevocation: DigitalSignTool['enableDigitalSignatureRevocation'] = (
+    enabled,
+  ) => {
+    return this.adapter.enableDigitalSignatureRevocation(enabled);
+  };
+}

package/src/tools/DocumentToolImpl.ts

@@ -1,11 +1,16 @@
 import type { DocumentClosedCallback, DocumentSavedCallback } from '../api/callbacks';
-import type { DocumentTool } from '../api/document-tool';
+import type { DocumentTool, IFileSaveOptions, IFileSaveResult } from '../api/document-tool';
+import { RHC_OFFICE_READER_ID_ATTRIBUTE } from '../viewer/AdapterProtocol';
 import {
   createBridgeToolAdapter,
   type BridgeToolAdapterContext,
   type BridgeToolDescriptor,
 } from '../viewer/BridgeToolAdapter';
 
+type ReaderElementWithSaveAs = HTMLElement & {
+  saveAs?: (options?: IFileSaveOptions) => Promise<IFileSaveResult>;
+};
+
 const DOCUMENT_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
   addDocumentOpenedCallback: {
     kind: 'callbackRegister',
@@ -68,7 +73,7 @@ const DOCUMENT_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
 export class DocumentToolImpl implements DocumentTool {
   private readonly adapter: DocumentTool;
 
-  constructor(context: BridgeToolAdapterContext) {
+  constructor(private readonly context: BridgeToolAdapterContext) {
     this.adapter = createBridgeToolAdapter<DocumentTool>(
       'document',
       DOCUMENT_TOOL_DESCRIPTOR,
@@ -129,6 +134,23 @@ export class DocumentToolImpl implements DocumentTool {
   };
 
   saveAs: DocumentTool['saveAs'] = (options) => {
+    const readerId = this.context.bridge.getReaderId();
+    if (!readerId) {
+      return Promise.resolve({
+        success: false,
+        action: 'save-as',
+        filename: options?.filename,
+        error: 'Reader is not mounted or does not expose saveAs.',
+      });
+    }
+
+    const readerElement = document.querySelector(
+      `[${RHC_OFFICE_READER_ID_ATTRIBUTE}="${readerId}"]`,
+    ) as ReaderElementWithSaveAs | null;
+    if (typeof readerElement?.saveAs === 'function') {
+      return readerElement.saveAs(options);
+    }
+
     return this.adapter.saveAs(options);
   };
 

package/src/tools/SignServerToolImpl.ts

@@ -0,0 +1,92 @@
+import type { SignServerAuthCallback, SignServerTool } from '../api/sign-server';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const SIGN_SERVER_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  setSignServer: { kind: 'command' },
+  addSignServerAuthCallback: {
+    kind: 'callbackRegister',
+    callback: (callbacks, args) => {
+      const callback = args[0];
+      if (typeof callback === 'function') {
+        callbacks.signServerAuth.push(callback as SignServerAuthCallback);
+      }
+    },
+  },
+  setSignServerDefaultLogin: { kind: 'command' },
+  setDefaultSignServerLogin: { kind: 'command' },
+  setSignServerDefaultPassword: { kind: 'command' },
+  setDefaultSignServerPassword: { kind: 'command' },
+  loginNTKOSignServer: { kind: 'command' },
+  loginSignServer: { kind: 'callbackQuery' },
+  signOutSignServer: { kind: 'command' },
+  isAuthenticatedOnSignServer: { kind: 'stateGetter', state: () => false },
+  setSignServerLoginFromUSBKey: { kind: 'command' },
+  setUserAuthSource: { kind: 'command' },
+};
+
+export class SignServerToolImpl implements SignServerTool {
+  private readonly adapter: SignServerTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<SignServerTool>(
+      'signServer',
+      SIGN_SERVER_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  setSignServer: SignServerTool['setSignServer'] = (signServer) => {
+    return this.adapter.setSignServer(signServer);
+  };
+
+  addSignServerAuthCallback: SignServerTool['addSignServerAuthCallback'] = (callback) => {
+    return this.adapter.addSignServerAuthCallback(callback);
+  };
+
+  setSignServerDefaultLogin: SignServerTool['setSignServerDefaultLogin'] = (login) => {
+    return this.adapter.setSignServerDefaultLogin(login);
+  };
+
+  setDefaultSignServerLogin: SignServerTool['setDefaultSignServerLogin'] = (login) => {
+    return this.adapter.setDefaultSignServerLogin(login);
+  };
+
+  setSignServerDefaultPassword: SignServerTool['setSignServerDefaultPassword'] = (password) => {
+    return this.adapter.setSignServerDefaultPassword(password);
+  };
+
+  setDefaultSignServerPassword: SignServerTool['setDefaultSignServerPassword'] = (password) => {
+    return this.adapter.setDefaultSignServerPassword(password);
+  };
+
+  loginNTKOSignServer: SignServerTool['loginNTKOSignServer'] = (serverAddress, login, password) => {
+    return this.adapter.loginNTKOSignServer(serverAddress, login, password);
+  };
+
+  loginSignServer: SignServerTool['loginSignServer'] = (server, login, password, onSuccess) => {
+    return this.adapter.loginSignServer(server, login, password, onSuccess);
+  };
+
+  signOutSignServer: SignServerTool['signOutSignServer'] = () => {
+    return this.adapter.signOutSignServer();
+  };
+
+  isAuthenticatedOnSignServer: SignServerTool['isAuthenticatedOnSignServer'] = () => {
+    return this.adapter.isAuthenticatedOnSignServer();
+  };
+
+  setSignServerLoginFromUSBKey: SignServerTool['setSignServerLoginFromUSBKey'] = (
+    enabled,
+    options,
+  ) => {
+    return this.adapter.setSignServerLoginFromUSBKey(enabled, options);
+  };
+
+  setUserAuthSource: SignServerTool['setUserAuthSource'] = (source) => {
+    return this.adapter.setUserAuthSource(source);
+  };
+}

package/src/tools/SymbologyToolImpl.ts

@@ -0,0 +1,34 @@
+import type { SymbologyTool } from '../api/symbology-tool';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const SYMBOLOGY_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  createPDF417Barcode: { kind: 'command' },
+};
+
+export class SymbologyToolImpl implements SymbologyTool {
+  private readonly adapter: SymbologyTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<SymbologyTool>(
+      'symbology',
+      SYMBOLOGY_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  createPDF417Barcode: SymbologyTool['createPDF417Barcode'] = (
+    content,
+    pageIndex,
+    x,
+    y,
+    width,
+    height,
+    margin,
+  ) => {
+    return this.adapter.createPDF417Barcode(content, pageIndex, x, y, width, height, margin);
+  };
+}

package/src/tools/TemplateSignToolImpl.ts

@@ -0,0 +1,51 @@
+import type { TemplateSignTool } from '../api/template-sign';
+import {
+  createBridgeToolAdapter,
+  type BridgeToolAdapterContext,
+  type BridgeToolDescriptor,
+} from '../viewer/BridgeToolAdapter';
+
+const TEMPLATE_SIGN_TOOL_DESCRIPTOR: BridgeToolDescriptor = {
+  setup: { kind: 'command' },
+  create: { kind: 'command' },
+  getMarkups: { kind: 'callbackQuery' },
+  removeMarkup: { kind: 'command' },
+  removeAllMarkups: { kind: 'command' },
+  sign: { kind: 'callbackQuery' },
+};
+
+export class TemplateSignToolImpl implements TemplateSignTool {
+  private readonly adapter: TemplateSignTool;
+
+  constructor(context: BridgeToolAdapterContext) {
+    this.adapter = createBridgeToolAdapter<TemplateSignTool>(
+      'templateSign',
+      TEMPLATE_SIGN_TOOL_DESCRIPTOR,
+      context,
+    );
+  }
+
+  setup: TemplateSignTool['setup'] = (option) => {
+    return this.adapter.setup(option);
+  };
+
+  create: TemplateSignTool['create'] = (signType) => {
+    return this.adapter.create(signType);
+  };
+
+  getMarkups: TemplateSignTool['getMarkups'] = (callback) => {
+    return this.adapter.getMarkups(callback);
+  };
+
+  removeMarkup: TemplateSignTool['removeMarkup'] = (markupId, prompt) => {
+    return this.adapter.removeMarkup(markupId, prompt);
+  };
+
+  removeAllMarkups: TemplateSignTool['removeAllMarkups'] = (prompt) => {
+    return this.adapter.removeAllMarkups(prompt);
+  };
+
+  sign: TemplateSignTool['sign'] = (callback) => {
+    return this.adapter.sign(callback);
+  };
+}

package/src/tools/index.ts

@@ -1,3 +1,6 @@
+export * from './AnnotationToolImpl';
+export * from './CryptoToolImpl';
+export * from './DigitalSignToolImpl';
 export * from './DocumentToolImpl';
 export * from './FindToolImpl';
 export * from './NetworkingToolImpl';
@@ -5,4 +8,7 @@ export * from './PageToolImpl';
 export * from './PdfFormFillerImpl';
 export * from './Phase1ToolPlaceholder';
 export * from './SDKValueObjects';
+export * from './SignServerToolImpl';
+export * from './SymbologyToolImpl';
+export * from './TemplateSignToolImpl';
 export * from './UIToolImpl';