imzo-agnost 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1818 @@
+'use strict';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/e-imzo/capiws.ts
+var CAPIWS = typeof EIMZOEXT !== "undefined" ? EIMZOEXT : {
+  URL: (window.location.protocol.toLowerCase() === "https:" ? "wss://127.0.0.1:64443" : "ws://127.0.0.1:64646") + "/service/cryptapi",
+  callFunction: function(funcDef, callback, error) {
+    if (!window.WebSocket) {
+      if (error) error();
+      return;
+    }
+    let socket;
+    try {
+      socket = new WebSocket(this.URL);
+    } catch (e) {
+      if (error) error(e);
+      return;
+    }
+    socket.onclose = function(e) {
+      if (error) {
+        if (e.code !== 1e3) {
+          error(e.code);
+        }
+      }
+    };
+    socket.onmessage = function(event) {
+      const data = JSON.parse(event.data);
+      socket.close();
+      callback(event, data);
+    };
+    socket.onopen = function() {
+      socket.send(JSON.stringify(funcDef));
+    };
+  },
+  version: function(callback, error) {
+    if (!window.WebSocket) {
+      if (error) error();
+      return;
+    }
+    let socket;
+    try {
+      socket = new WebSocket(this.URL);
+    } catch (e) {
+      if (error) error(e);
+      return;
+    }
+    socket.onclose = function(e) {
+      if (error) {
+        if (e.code !== 1e3) {
+          error(e.code);
+        }
+      }
+    };
+    socket.onmessage = function(event) {
+      const data = JSON.parse(event.data);
+      socket.close();
+      callback(event, data);
+    };
+    socket.onopen = function() {
+      const o = { name: "version" };
+      socket.send(JSON.stringify(o));
+    };
+  },
+  apidoc: function(callback, error) {
+    if (!window.WebSocket) {
+      if (error) error();
+      return;
+    }
+    let socket;
+    try {
+      socket = new WebSocket(this.URL);
+    } catch (e) {
+      if (error) error(e);
+      return;
+    }
+    socket.onclose = function(e) {
+      if (error) {
+        if (e.code !== 1e3) {
+          error(e.code);
+        }
+      }
+    };
+    socket.onmessage = function(event) {
+      const data = JSON.parse(event.data);
+      socket.close();
+      callback(event, data);
+    };
+    socket.onopen = function() {
+      const o = { name: "apidoc" };
+      socket.send(JSON.stringify(o));
+    };
+  },
+  apikey: function(domainAndKey, callback, error) {
+    if (!window.WebSocket) {
+      if (error) error();
+      return;
+    }
+    let socket;
+    try {
+      socket = new WebSocket(this.URL);
+    } catch (e) {
+      if (error) error(e);
+      return;
+    }
+    socket.onclose = function(e) {
+      if (error) {
+        if (e.code !== 1e3) {
+          error(e.code);
+        }
+      }
+    };
+    socket.onmessage = function(event) {
+      const data = JSON.parse(event.data);
+      socket.close();
+      callback(event, data);
+    };
+    socket.onopen = function() {
+      const o = { name: "apikey", arguments: domainAndKey };
+      socket.send(JSON.stringify(o));
+    };
+  }
+};
+var capiws_default = CAPIWS;
+
+// src/e-imzo-client.ts
+Date.prototype.yyyymmdd = function() {
+  const yyyy = this.getFullYear().toString();
+  const mm = (this.getMonth() + 1).toString();
+  const dd = this.getDate().toString();
+  return yyyy + (mm[1] ? mm : "0" + mm[0]) + (dd[1] ? dd : "0" + dd[0]);
+};
+Date.prototype.ddmmyyyy = function() {
+  const yyyy = this.getFullYear().toString();
+  const mm = (this.getMonth() + 1).toString();
+  const dd = this.getDate().toString();
+  return (dd[1] ? dd : "0" + dd[0]) + "." + (mm[1] ? mm : "0" + mm[0]) + "." + yyyy;
+};
+var dates = {
+  convert(d) {
+    if (d instanceof Date) {
+      return d;
+    } else if (Array.isArray(d) && d.length >= 3) {
+      return new Date(d[0] || 0, d[1] || 0, d[2] || 0);
+    } else if (typeof d === "number") {
+      return new Date(d);
+    } else if (typeof d === "string") {
+      return new Date(d);
+    } else if (typeof d === "object" && d !== null) {
+      const dateObj = d;
+      return new Date(dateObj.year || 0, dateObj.month || 0, dateObj.date || 0);
+    }
+    return NaN;
+  },
+  compare(a, b) {
+    const aVal = this.convert(a).valueOf();
+    const bVal = this.convert(b).valueOf();
+    return isFinite(aVal) && isFinite(bVal) ? (aVal > bVal ? 1 : 0) - (aVal < bVal ? 1 : 0) : NaN;
+  },
+  inRange(d, start, end) {
+    const dVal = this.convert(d).valueOf();
+    const startVal = this.convert(start).valueOf();
+    const endVal = this.convert(end).valueOf();
+    return isFinite(dVal) && isFinite(startVal) && isFinite(endVal) ? startVal <= dVal && dVal <= endVal : NaN;
+  }
+};
+String.prototype.splitKeep = function(splitter, ahead) {
+  const result = [];
+  if (splitter !== "") {
+    let getSubst2 = function(value) {
+      const substChar = value[0] === "0" ? "1" : "0";
+      let subst = "";
+      for (let i = 0; i < value.length; i++) {
+        subst += substChar;
+      }
+      return subst;
+    };
+    const matches = [];
+    if (splitter instanceof RegExp) {
+      this.replace(splitter, (m, ...args) => {
+        const offset = args[args.length - 2];
+        matches.push({ value: m, index: offset });
+        return getSubst2(m);
+      });
+    } else {
+      this.replaceAll(splitter, (m, offset) => {
+        matches.push({ value: m, index: offset });
+        return getSubst2(m);
+      });
+    }
+    let lastIndex = 0;
+    for (let i = 0; i < matches.length; i++) {
+      const m = matches[i];
+      if (m) {
+        const nextIndex = ahead === true ? m.index : m.index + m.value.length;
+        if (nextIndex !== lastIndex) {
+          const part = this.substring(lastIndex, nextIndex);
+          result.push(part);
+          lastIndex = nextIndex;
+        }
+      }
+    }
+    if (lastIndex < this.length) {
+      const part = this.substring(lastIndex, this.length);
+      result.push(part);
+    }
+  } else {
+    result.push(this.toString());
+  }
+  return result;
+};
+var EIMZOClient = {
+  NEW_API: false,
+  NEW_API2: false,
+  API_KEYS: [
+    "localhost",
+    "96D0C1491615C82B9A54D9989779DF825B690748224C2B04F500F370D51827CE2644D8D4A82C18184D73AB8530BB8ED537269603F61DB0D03D2104ABF789970B",
+    "127.0.0.1",
+    "A7BCFA5D490B351BE0754130DF03A068F855DB4333D43921125B9CF2670EF6A40370C646B90401955E1F7BC9CDBF59CE0B2C5467D820BE189C845D0B79CFC96F"
+  ],
+  checkVersion(success, fail) {
+    capiws_default.version(
+      (event, data) => {
+        if (data.success === true) {
+          if (data.major && data.minor) {
+            const installedVersion = parseInt(data.major) * 100 + parseInt(data.minor);
+            EIMZOClient.NEW_API = installedVersion >= 336;
+            EIMZOClient.NEW_API2 = installedVersion >= 412;
+            success(data.major, data.minor);
+          } else {
+            fail(null, "E-IMZO Version is undefined");
+          }
+        } else {
+          fail(null, data.reason || "Unknown error");
+        }
+      },
+      (e) => {
+        fail(e, null);
+      }
+    );
+  },
+  installApiKeys(success, fail) {
+    capiws_default.apikey(
+      EIMZOClient.API_KEYS,
+      (event, data) => {
+        if (data.success) {
+          success();
+        } else {
+          fail(null, data.reason || "Unknown error");
+        }
+      },
+      (e) => {
+        fail(e, null);
+      }
+    );
+  },
+  listAllUserKeys(itemIdGen, itemUiGen, success, fail) {
+    const items = [];
+    const errors = [];
+    if (!EIMZOClient.NEW_API) {
+      fail(null, "Please install new version of E-IMZO");
+    } else {
+      if (EIMZOClient.NEW_API2) {
+        EIMZOClient._findPfxs2(itemIdGen, itemUiGen, items, errors, (firstItmId2) => {
+          if (items.length === 0 && errors.length > 0) {
+            const firstError = errors[0];
+            if (firstError) {
+              fail(firstError.e, firstError.r || null);
+            }
+          } else {
+            let firstId = null;
+            if (items.length === 1 && firstItmId2) {
+              firstId = firstItmId2;
+            }
+            success(items, firstId);
+          }
+        });
+      } else {
+        EIMZOClient._findPfxs2(itemIdGen, itemUiGen, items, errors, (firstItmId2) => {
+          EIMZOClient._findTokens2(itemIdGen, itemUiGen, items, errors, (firstItmId3) => {
+            if (items.length === 0 && errors.length > 0) {
+              const firstError = errors[0];
+              if (firstError) {
+                fail(firstError.e, firstError.r || null);
+              }
+            } else {
+              let firstId = null;
+              if (items.length === 1) {
+                if (firstItmId2) {
+                  firstId = firstItmId2;
+                } else if (firstItmId3) {
+                  firstId = firstItmId3;
+                }
+              }
+              success(items, firstId);
+            }
+          });
+        });
+      }
+    }
+  },
+  idCardIsPLuggedIn(success, fail) {
+    if (!EIMZOClient.NEW_API2) {
+      console.log("E-IMZO version should be 4.12 or newer");
+      success(false);
+    } else {
+      capiws_default.callFunction(
+        { plugin: "idcard", name: "list_readers" },
+        (event, data) => {
+          if (data.success) {
+            success((data.readers?.length || 0) > 0);
+          } else {
+            fail(null, data.reason || "Unknown error");
+          }
+        },
+        (e) => {
+          fail(e, null);
+        }
+      );
+    }
+  },
+  loadKey(itemObject, success, fail, verifyPassword) {
+    if (itemObject) {
+      const vo = itemObject;
+      if (vo.type === "pfx") {
+        capiws_default.callFunction(
+          {
+            plugin: "pfx",
+            name: "load_key",
+            arguments: [vo.disk, vo.path, vo.name, vo.alias]
+          },
+          (event, data) => {
+            if (data.success && data.keyId) {
+              const id = data.keyId;
+              if (verifyPassword) {
+                capiws_default.callFunction(
+                  { name: "verify_password", plugin: "pfx", arguments: [id] },
+                  (event2, data2) => {
+                    if (data2.success) {
+                      success(id);
+                    } else {
+                      fail(null, data2.reason || "Password verification failed");
+                    }
+                  },
+                  (e) => {
+                    fail(e, null);
+                  }
+                );
+              } else {
+                success(id);
+              }
+            } else {
+              fail(null, data.reason || "Failed to load key");
+            }
+          },
+          (e) => {
+            fail(e, null);
+          }
+        );
+      } else if (vo.type === "ftjc") {
+        capiws_default.callFunction(
+          { plugin: "ftjc", name: "load_key", arguments: [vo.cardUID] },
+          (event, data) => {
+            if (data.success && data.keyId) {
+              const id = data.keyId;
+              if (verifyPassword) {
+                capiws_default.callFunction(
+                  { plugin: "ftjc", name: "verify_pin", arguments: [id, "1"] },
+                  (event2, data2) => {
+                    if (data2.success) {
+                      success(id);
+                    } else {
+                      fail(null, data2.reason || "PIN verification failed");
+                    }
+                  },
+                  (e) => {
+                    fail(e, null);
+                  }
+                );
+              } else {
+                success(id);
+              }
+            } else {
+              fail(null, data.reason || "Failed to load key");
+            }
+          },
+          (e) => {
+            fail(e, null);
+          }
+        );
+      }
+    }
+  },
+  changeKeyPassword(itemObject, success, fail) {
+    if (itemObject) {
+      const vo = itemObject;
+      if (vo.type === "pfx") {
+        capiws_default.callFunction(
+          {
+            plugin: "pfx",
+            name: "load_key",
+            arguments: [vo.disk, vo.path, vo.name, vo.alias]
+          },
+          (event, data) => {
+            if (data.success && data.keyId) {
+              const id = data.keyId;
+              capiws_default.callFunction(
+                { name: "change_password", plugin: "pfx", arguments: [id] },
+                (event2, data2) => {
+                  if (data2.success) {
+                    success();
+                  } else {
+                    fail(null, data2.reason || "Failed to change password");
+                  }
+                },
+                (e) => {
+                  fail(e, null);
+                }
+              );
+            } else {
+              fail(null, data.reason || "Failed to load key");
+            }
+          },
+          (e) => {
+            fail(e, null);
+          }
+        );
+      } else if (vo.type === "ftjc") {
+        capiws_default.callFunction(
+          { plugin: "ftjc", name: "load_key", arguments: [vo.cardUID] },
+          (event, data) => {
+            if (data.success && data.keyId) {
+              const id = data.keyId;
+              capiws_default.callFunction(
+                { name: "change_pin", plugin: "ftjc", arguments: [id, "1"] },
+                (event2, data2) => {
+                  if (data2.success) {
+                    success();
+                  } else {
+                    fail(null, data2.reason || "Failed to change PIN");
+                  }
+                },
+                (e) => {
+                  fail(e, null);
+                }
+              );
+            } else {
+              fail(null, data.reason || "Failed to load key");
+            }
+          },
+          (e) => {
+            fail(e, null);
+          }
+        );
+      }
+    }
+  },
+  createPkcs7(id, data, timestamper, success, fail, detached, isDataBase64Encoded) {
+    let data64;
+    if (isDataBase64Encoded === true) {
+      data64 = data;
+    } else {
+      data64 = globalThis.Base64?.encode(data) || btoa(data);
+    }
+    const detachedStr = detached === true ? "yes" : "no";
+    capiws_default.callFunction(
+      {
+        plugin: "pkcs7",
+        name: "create_pkcs7",
+        arguments: [data64, id, detachedStr]
+      },
+      (event, data2) => {
+        if (data2.success && data2.pkcs7_64) {
+          const pkcs7 = data2.pkcs7_64;
+          success(pkcs7);
+        } else {
+          fail(null, data2.reason || "Failed to create PKCS7");
+        }
+      },
+      (e) => {
+        fail(e, null);
+      }
+    );
+  },
+  _getX500Val(s, f) {
+    const res = s.splitKeep(/,[A-Z]+=/g, true);
+    for (const i in res) {
+      const resItem = res[i];
+      if (resItem) {
+        const n = resItem.search((parseInt(i) > 0 ? "," : "") + f + "=");
+        if (n !== -1) {
+          return resItem.slice(n + f.length + 1 + (parseInt(i) > 0 ? 1 : 0));
+        }
+      }
+    }
+    return "";
+  },
+  _findPfxs2(itemIdGen, itemUiGen, items, errors, callback) {
+    let itmkey0;
+    capiws_default.callFunction(
+      { plugin: "pfx", name: "list_all_certificates" },
+      (event, data) => {
+        if (data.success && data.certificates) {
+          for (const rec in data.certificates) {
+            const el = data.certificates[rec];
+            if (!el) continue;
+            let x500name_ex = el.alias.toUpperCase();
+            x500name_ex = x500name_ex.replace("1.2.860.3.16.1.1=", "INN=");
+            x500name_ex = x500name_ex.replace("1.2.860.3.16.1.2=", "PINFL=");
+            const vo = {
+              disk: el.disk,
+              path: el.path,
+              name: el.name,
+              alias: el.alias,
+              serialNumber: EIMZOClient._getX500Val(x500name_ex, "SERIALNUMBER"),
+              validFrom: new Date(
+                EIMZOClient._getX500Val(x500name_ex, "VALIDFROM").replace(/\./g, "-").replace(" ", "T")
+              ),
+              validTo: new Date(
+                EIMZOClient._getX500Val(x500name_ex, "VALIDTO").replace(/\./g, "-").replace(" ", "T")
+              ),
+              CN: EIMZOClient._getX500Val(x500name_ex, "CN"),
+              TIN: EIMZOClient._getX500Val(x500name_ex, "INN") || EIMZOClient._getX500Val(x500name_ex, "UID"),
+              UID: EIMZOClient._getX500Val(x500name_ex, "UID"),
+              PINFL: EIMZOClient._getX500Val(x500name_ex, "PINFL"),
+              O: EIMZOClient._getX500Val(x500name_ex, "O"),
+              T: EIMZOClient._getX500Val(x500name_ex, "T"),
+              type: "pfx"
+            };
+            if (!vo.TIN && !vo.PINFL) continue;
+            const itmkey = itemIdGen(vo, rec);
+            if (!itmkey0) {
+              itmkey0 = itmkey;
+            }
+            const itm = itemUiGen(itmkey, vo);
+            items.push(itm);
+          }
+        } else {
+          errors.push({ r: data.reason || "Failed to list certificates" });
+        }
+        callback(itmkey0);
+      },
+      (e) => {
+        errors.push({ e });
+        callback(itmkey0);
+      }
+    );
+  },
+  _findTokens2(itemIdGen, itemUiGen, items, errors, callback) {
+    let itmkey0;
+    capiws_default.callFunction(
+      { plugin: "ftjc", name: "list_all_keys", arguments: [""] },
+      (event, data) => {
+        if (data.success && data.tokens) {
+          for (const rec in data.tokens) {
+            const el = data.tokens[rec];
+            if (!el) continue;
+            let x500name_ex = el.info.toUpperCase();
+            x500name_ex = x500name_ex.replace("1.2.860.3.16.1.1=", "INN=");
+            x500name_ex = x500name_ex.replace("1.2.860.3.16.1.2=", "PINFL=");
+            const vo = {
+              cardUID: el.cardUID,
+              statusInfo: el.statusInfo,
+              ownerName: el.ownerName,
+              info: el.info,
+              serialNumber: EIMZOClient._getX500Val(x500name_ex, "SERIALNUMBER"),
+              validFrom: new Date(EIMZOClient._getX500Val(x500name_ex, "VALIDFROM")),
+              validTo: new Date(EIMZOClient._getX500Val(x500name_ex, "VALIDTO")),
+              CN: EIMZOClient._getX500Val(x500name_ex, "CN"),
+              TIN: EIMZOClient._getX500Val(x500name_ex, "INN") || EIMZOClient._getX500Val(x500name_ex, "UID"),
+              UID: EIMZOClient._getX500Val(x500name_ex, "UID"),
+              PINFL: EIMZOClient._getX500Val(x500name_ex, "PINFL"),
+              O: EIMZOClient._getX500Val(x500name_ex, "O"),
+              T: EIMZOClient._getX500Val(x500name_ex, "T"),
+              type: "ftjc"
+            };
+            if (!vo.TIN && !vo.PINFL) continue;
+            const itmkey = itemIdGen(vo, rec);
+            if (!itmkey0) {
+              itmkey0 = itmkey;
+            }
+            const itm = itemUiGen(itmkey, vo);
+            items.push(itm);
+          }
+        } else {
+          errors.push({ r: data.reason || "Failed to list tokens" });
+        }
+        callback(itmkey0);
+      },
+      (e) => {
+        errors.push({ e });
+        callback(itmkey0);
+      }
+    );
+  }
+};
+var e_imzo_client_default = EIMZOClient;
+
+// src/core/plugin-base.ts
+var EIMZOPlugin = class {
+  version = "1.0.0";
+  description = "";
+  /**
+   * Execute a plugin method call through CAPIWS
+   */
+  callMethod(methodName, args = [], onSuccess, onError) {
+    const call = {
+      plugin: this.name,
+      name: methodName,
+      ...args.length > 0 && { arguments: args }
+    };
+    capiws_default.callFunction(call, onSuccess, onError);
+  }
+  /**
+   * Create a promise-based wrapper for plugin methods
+   */
+  createPromiseMethod(methodName) {
+    return (...args) => {
+      return new Promise((resolve, reject) => {
+        this.callMethod(
+          methodName,
+          args,
+          (_event, data) => {
+            if (data.success) {
+              resolve(data);
+            } else {
+              reject(new Error(data.reason ?? "Unknown error"));
+            }
+          },
+          (error) => reject(error instanceof Error ? error : new Error(String(error)))
+        );
+      });
+    };
+  }
+  /**
+   * Create both callback and promise versions of a method
+   */
+  createMethod(methodName) {
+    const promiseMethod = this.createPromiseMethod(methodName);
+    const callbackMethod = (...args) => {
+      const methodArgs = args.slice(0, -2);
+      const onSuccess = args[args.length - 2];
+      const onError = args[args.length - 1];
+      this.callMethod(methodName, methodArgs, onSuccess, onError);
+    };
+    return {
+      promise: promiseMethod,
+      callback: callbackMethod
+    };
+  }
+};
+var PluginManager = class {
+  static plugins = /* @__PURE__ */ new Map();
+  static register(plugin) {
+    this.plugins.set(plugin.name, plugin);
+  }
+  static get(name) {
+    return this.plugins.get(name);
+  }
+  static getAll() {
+    return Array.from(this.plugins.values());
+  }
+  static has(name) {
+    return this.plugins.has(name);
+  }
+};
+function RegisterPlugin(constructor) {
+  const instance = new constructor();
+  PluginManager.register(instance);
+  return constructor;
+}
+
+// src/plugins/certkey.ts
+var _CertKeyPlugin_decorators, _init, _a;
+_CertKeyPlugin_decorators = [RegisterPlugin];
+var CertKeyPlugin = class extends (_a = EIMZOPlugin) {
+  name = "certkey";
+  description = "Plugin for working with electronic keys and certificates";
+  /**
+   * Удалить загруженные ключи по идентификатору
+   */
+  unloadKey = (keyId, onSuccess, onError) => {
+    this.callMethod("unload_key", [keyId], onSuccess, onError);
+  };
+  /**
+   * Получить список дисков
+   */
+  listDisks = (onSuccess, onError) => {
+    this.callMethod("list_disks", [], onSuccess, onError);
+  };
+  /**
+   * Получить список сертификатов пользователя
+   */
+  listCertificates = (diskPath, onSuccess, onError) => {
+    this.callMethod("list_certificates", [diskPath], onSuccess, onError);
+  };
+  /**
+   * Получить список всех сертификатов пользователя
+   */
+  listAllCertificates = (onSuccess, onError) => {
+    this.callMethod("list_all_certificates", [], onSuccess, onError);
+  };
+  /**
+   * Загрузить ключ и получить идентификатор ключа
+   */
+  loadKey = (keyPath, password, onSuccess, onError) => {
+    this.callMethod("load_key", [keyPath, password], onSuccess, onError);
+  };
+};
+_init = __decoratorStart(_a);
+CertKeyPlugin = __decorateElement(_init, 0, "CertKeyPlugin", _CertKeyPlugin_decorators, CertKeyPlugin);
+__runInitializers(_init, 1, CertKeyPlugin);
+
+// src/plugins/cipher.ts
+var _CipherPlugin_decorators, _init2, _a2;
+_CipherPlugin_decorators = [RegisterPlugin];
+var CipherPlugin = class extends (_a2 = EIMZOPlugin) {
+  name = "cipher";
+  description = "Plugin for encryption/decryption using GOST-28147 and ECDH-SHA256";
+  /**
+   * Создать зашифрованный документ
+   */
+  encryptDocument = (data, recipientCertificate, senderKeyId, onSuccess, onError) => {
+    this.callMethod(
+      "encrypt_document",
+      [data, recipientCertificate, senderKeyId],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Дешифровать зашифрованный документ
+   */
+  decryptDocument = (encryptedData, recipientKeyId, onSuccess, onError) => {
+    this.callMethod("decrypt_document", [encryptedData, recipientKeyId], onSuccess, onError);
+  };
+};
+_init2 = __decoratorStart(_a2);
+CipherPlugin = __decorateElement(_init2, 0, "CipherPlugin", _CipherPlugin_decorators, CipherPlugin);
+__runInitializers(_init2, 1, CipherPlugin);
+
+// src/plugins/crl.ts
+var _CRLPlugin_decorators, _init3, _a3;
+_CRLPlugin_decorators = [RegisterPlugin];
+var CRLPlugin = class extends (_a3 = EIMZOPlugin) {
+  name = "crl";
+  description = "Plugin for working with Certificate Revocation Lists";
+  /**
+   * Открывает CRL
+   */
+  openCrl = (crlData, onSuccess, onError) => {
+    this.callMethod("open_crl", [crlData], onSuccess, onError);
+  };
+  /**
+   * Открывает CRL из файла
+   */
+  openCrlFile = (filePath, onSuccess, onError) => {
+    this.callMethod("open_crl_file", [filePath], onSuccess, onError);
+  };
+  /**
+   * Проверка статуса сертификата по CRL
+   */
+  checkCertificate = (certificate, crlId, onSuccess, onError) => {
+    this.callMethod("check_certificate", [certificate, crlId], onSuccess, onError);
+  };
+  /**
+   * Получить информацию о CRL
+   */
+  getCrlInfo = (crlId, onSuccess, onError) => {
+    this.callMethod("get_crl_info", [crlId], onSuccess, onError);
+  };
+  /**
+   * Верификация CRL
+   */
+  verifyCrl = (crlId, issuerCertificate, onSuccess, onError) => {
+    this.callMethod("verify_crl", [crlId, issuerCertificate], onSuccess, onError);
+  };
+};
+_init3 = __decoratorStart(_a3);
+CRLPlugin = __decorateElement(_init3, 0, "CRLPlugin", _CRLPlugin_decorators, CRLPlugin);
+__runInitializers(_init3, 1, CRLPlugin);
+
+// src/plugins/cryptoauth.ts
+var _CryptoAuthPlugin_decorators, _init4, _a4;
+_CryptoAuthPlugin_decorators = [RegisterPlugin];
+var CryptoAuthPlugin = class extends (_a4 = EIMZOPlugin) {
+  name = "cryptoauth";
+  description = "Plugin for low-level cryptographic operations";
+  /**
+   * Подписать данные ключем задаваемым идентификатором
+   */
+  getSignature = (keyId, data, onSuccess, onError) => {
+    this.callMethod("get_signature", [keyId, data], onSuccess, onError);
+  };
+  /**
+   * Вычислить хеш (в формате HEX) данных по алгоритму OZDST-1106-2009-2-A
+   */
+  getDigestHex = (data, onSuccess, onError) => {
+    this.callMethod("get_digest_hex", [data], onSuccess, onError);
+  };
+  /**
+   * Верифицировать подпись данных сертификатом
+   */
+  verifySignatureWithCertificate = (data, signature, certificate, onSuccess, onError) => {
+    this.callMethod(
+      "verify_signature_with_certificate",
+      [data, signature, certificate],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Верифицировать подпись хеша (в формате HEX) ключем задаваемым идентификатором
+   */
+  verifyDigestHexSignatureWithId = (digestHex, signature, keyId, onSuccess, onError) => {
+    this.callMethod(
+      "verify_digest_hex_signature_with_id",
+      [digestHex, signature, keyId],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Подписать хеш (в формате HEX) ключем задаваемым идентификатором
+   */
+  getDigestHexSignature = (digestHex, keyId, onSuccess, onError) => {
+    this.callMethod("get_digest_hex_signature", [digestHex, keyId], onSuccess, onError);
+  };
+  /**
+   * Верифицировать подпись данных ключем задаваемым идентификатором
+   */
+  verifySignatureWithId = (data, signature, keyId, onSuccess, onError) => {
+    this.callMethod("verify_signature_with_id", [data, signature, keyId], onSuccess, onError);
+  };
+  /**
+   * Верифицировать подпись хеша (в формате HEX) сертификатом
+   */
+  verifyDigestHexSignatureWithCertificate = (digestHex, signature, certificate, onSuccess, onError) => {
+    this.callMethod(
+      "verify_digest_hex_signature_with_certificate",
+      [digestHex, signature, certificate],
+      onSuccess,
+      onError
+    );
+  };
+};
+_init4 = __decoratorStart(_a4);
+CryptoAuthPlugin = __decorateElement(_init4, 0, "CryptoAuthPlugin", _CryptoAuthPlugin_decorators, CryptoAuthPlugin);
+__runInitializers(_init4, 1, CryptoAuthPlugin);
+
+// src/plugins/fileio.ts
+var _FileIOPlugin_decorators, _init5, _a5;
+_FileIOPlugin_decorators = [RegisterPlugin];
+var FileIOPlugin = class extends (_a5 = EIMZOPlugin) {
+  name = "fileio";
+  description = "Plugin for file input/output operations";
+  /**
+   * Загруить файл
+   */
+  loadFile = (filePath, onSuccess, onError) => {
+    this.callMethod("load_file", [filePath], onSuccess, onError);
+  };
+  /**
+   * Записать содержимое zip файла на диск
+   */
+  writeFile = (zipContent, destinationPath, onSuccess, onError) => {
+    this.callMethod("write_file", [zipContent, destinationPath], onSuccess, onError);
+  };
+};
+_init5 = __decoratorStart(_a5);
+FileIOPlugin = __decorateElement(_init5, 0, "FileIOPlugin", _FileIOPlugin_decorators, FileIOPlugin);
+__runInitializers(_init5, 1, FileIOPlugin);
+
+// src/plugins/ftjc.ts
+var _FtjcPlugin_decorators, _init6, _a6;
+_FtjcPlugin_decorators = [RegisterPlugin];
+var FtjcPlugin = class extends (_a6 = EIMZOPlugin) {
+  name = "ftjc";
+  description = "Plugin for working with USB FT Javacard tokens - STUB";
+  // Callback-based methods
+  /**
+   * Get list of all keys from connected tokens
+   */
+  listAllKeys = (exceptCards = "", onSuccess, onError) => {
+    this.callMethod("list_all_keys", [exceptCards], onSuccess, onError);
+  };
+  /**
+   * Get list of tokens
+   */
+  listTokens = (onSuccess, onError) => {
+    this.callMethod("list_tokens", [], onSuccess, onError);
+  };
+  /**
+   * Load key and get key identifier
+   */
+  loadKey = (cardUID, onSuccess, onError) => {
+    this.callMethod("load_key", [cardUID], onSuccess, onError);
+  };
+  /**
+   * Unload key by identifier
+   */
+  unloadKey = (tokenId, onSuccess, onError) => {
+    this.callMethod("unload_key", [tokenId], onSuccess, onError);
+  };
+  /**
+   * Verify PIN code of token
+   * @param pinType 0 - Initialization, 1 - User, 2 - Reset
+   */
+  verifyPin = (tokenId, pinType, onSuccess, onError) => {
+    this.callMethod("verify_pin", [tokenId, pinType], onSuccess, onError);
+  };
+  /**
+   * Change PIN code of token
+   * @param pinType 0 - Initialization, 1 - User, 2 - Reset
+   */
+  changePin = (tokenId, pinType, onSuccess, onError) => {
+    this.callMethod("change_pin", [tokenId, pinType], onSuccess, onError);
+  };
+  /**
+   * Set name for USB token
+   */
+  setName = (tokenId, name, onSuccess, onError) => {
+    this.callMethod("set_name", [tokenId, name], onSuccess, onError);
+  };
+  /**
+   * Store certificates in USB token
+   */
+  storeCertificates = (tokenId, subjectCertificate64, caCertificate64, rootCertificate64, onSuccess, onError) => {
+    this.callMethod(
+      "store_certificates",
+      [tokenId, subjectCertificate64, caCertificate64, rootCertificate64],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Get user data from token
+   */
+  getUserData = (tokenId, onSuccess, onError) => {
+    this.callMethod("get_user_data", [tokenId], onSuccess, onError);
+  };
+  /**
+   * Set or delete user data in token
+   * @param data64 Data in BASE64 encoding or empty string to delete
+   */
+  setUserData = (tokenId, data64, onSuccess, onError) => {
+    this.callMethod("set_user_data", [tokenId, data64], onSuccess, onError);
+  };
+  /**
+   * Generate random data in USB token
+   */
+  getRandomData = (tokenId, onSuccess, onError) => {
+    this.callMethod("get_random_data", [tokenId], onSuccess, onError);
+  };
+  /**
+   * Install applet in USB token
+   */
+  installApplet = (cardUID, applet64, signatureHex, onSuccess, onError) => {
+    this.callMethod("install_applet", [cardUID, applet64, signatureHex], onSuccess, onError);
+  };
+  // Promise-based methods
+  /**
+   * List all keys (Promise version)
+   */
+  listAllKeysAsync = this.createPromiseMethod("list_all_keys");
+  /**
+   * List tokens (Promise version)
+   */
+  listTokensAsync = this.createPromiseMethod("list_tokens");
+  /**
+   * Load key (Promise version)
+   */
+  loadKeyAsync = this.createPromiseMethod("load_key");
+  /**
+   * Unload key (Promise version)
+   */
+  unloadKeyAsync = this.createPromiseMethod("unload_key");
+  /**
+   * Verify PIN (Promise version)
+   */
+  verifyPinAsync = this.createPromiseMethod(
+    "verify_pin"
+  );
+  /**
+   * Change PIN (Promise version)
+   */
+  changePinAsync = this.createPromiseMethod(
+    "change_pin"
+  );
+  /**
+   * Set name (Promise version)
+   */
+  setNameAsync = this.createPromiseMethod("set_name");
+  /**
+   * Store certificates (Promise version)
+   */
+  storeCertificatesAsync = this.createPromiseMethod("store_certificates");
+  /**
+   * Get user data (Promise version)
+   */
+  getUserDataAsync = this.createPromiseMethod("get_user_data");
+  /**
+   * Set user data (Promise version)
+   */
+  setUserDataAsync = this.createPromiseMethod("set_user_data");
+  /**
+   * Get random data (Promise version)
+   */
+  getRandomDataAsync = this.createPromiseMethod("get_random_data");
+  /**
+   * Install applet (Promise version)
+   */
+  installAppletAsync = this.createPromiseMethod(
+    "install_applet"
+  );
+};
+_init6 = __decoratorStart(_a6);
+FtjcPlugin = __decorateElement(_init6, 0, "FtjcPlugin", _FtjcPlugin_decorators, FtjcPlugin);
+__runInitializers(_init6, 1, FtjcPlugin);
+var ftjcPlugin = new FtjcPlugin();
+
+// src/plugins/idcard.ts
+var _IDCardPlugin_decorators, _init7, _a7;
+_IDCardPlugin_decorators = [RegisterPlugin];
+var IDCardPlugin = class extends (_a7 = EIMZOPlugin) {
+  name = "idcard";
+  description = "Plugin for working with E-IMZO ID cards";
+  /**
+   * Проверить пароль хранилища ключей (заглушка)
+   */
+  verifyPassword = (password, onSuccess, onError) => {
+    this.callMethod("verify_password", [password], onSuccess, onError);
+  };
+  /**
+   * Персонализировать ID-карту записав новые сертификаты и установив PIN-код
+   */
+  personalize = (certificates, pinCode, onSuccess, onError) => {
+    this.callMethod("personalize", [certificates, pinCode], onSuccess, onError);
+  };
+  /**
+   * Получить список считывателей
+   */
+  listReaders = (onSuccess, onError) => {
+    this.callMethod("list_readers", [], onSuccess, onError);
+  };
+  /**
+   * Получить список всех сертификатов пользователя (заглушка)
+   */
+  listAllCertificates = (onSuccess, onError) => {
+    this.callMethod("list_all_certificates", [], onSuccess, onError);
+  };
+  /**
+   * Получить зашифрованный и подписанный заводской номер USB-токена
+   */
+  getEncryptedSignedCplc = (onSuccess, onError) => {
+    this.callMethod("get_encrypted_signed_cplc", [], onSuccess, onError);
+  };
+  /**
+   * Загрузить ключ и получить идентификатор ключа. Ключ будет доступен определенное время (заглушка)
+   */
+  loadKey = (cardIndex, password, onSuccess, onError) => {
+    this.callMethod("load_key", [cardIndex, password], onSuccess, onError);
+  };
+};
+_init7 = __decoratorStart(_a7);
+IDCardPlugin = __decorateElement(_init7, 0, "IDCardPlugin", _IDCardPlugin_decorators, IDCardPlugin);
+__runInitializers(_init7, 1, IDCardPlugin);
+
+// src/plugins/pfx.ts
+var _PfxPlugin_decorators, _init8, _a8;
+_PfxPlugin_decorators = [RegisterPlugin];
+var PfxPlugin = class extends (_a8 = EIMZOPlugin) {
+  name = "pfx";
+  description = "Plugin for working with PFX key storage files";
+  // Callback-based methods
+  /**
+   * Get list of available disks
+   */
+  listDisks = (onSuccess, onError) => {
+    this.callMethod("list_disks", [], onSuccess, onError);
+  };
+  /**
+   * Get list of certificates from specific disk
+   */
+  listCertificates = (disk, onSuccess, onError) => {
+    this.callMethod("list_certificates", [disk], onSuccess, onError);
+  };
+  /**
+   * Get list of all certificates from all disks
+   */
+  listAllCertificates = (onSuccess, onError) => {
+    this.callMethod("list_all_certificates", [], onSuccess, onError);
+  };
+  /**
+   * Load key and get key identifier
+   */
+  loadKey = (disk, path, name, alias, onSuccess, onError) => {
+    this.callMethod("load_key", [disk, path, name, alias], onSuccess, onError);
+  };
+  /**
+   * Unload key by identifier
+   */
+  unloadKey = (keyId, onSuccess, onError) => {
+    this.callMethod("unload_key", [keyId], onSuccess, onError);
+  };
+  /**
+   * Verify password for key storage
+   */
+  verifyPassword = (keyId, onSuccess, onError) => {
+    this.callMethod("verify_password", [keyId], onSuccess, onError);
+  };
+  /**
+   * Change password for key storage
+   */
+  changePassword = (keyId, onSuccess, onError) => {
+    this.callMethod("change_password", [keyId], onSuccess, onError);
+  };
+  /**
+   * Save key pair and certificates to new PFX file
+   */
+  savePfx = (disk, path, name, alias, id, newKeyPassword, subjectCertificate64, caCertificate64, rootCertificate64, onSuccess, onError) => {
+    this.callMethod(
+      "save_pfx",
+      [
+        disk,
+        path,
+        name,
+        alias,
+        id,
+        newKeyPassword,
+        subjectCertificate64,
+        caCertificate64,
+        rootCertificate64
+      ],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Save temporary PFX with self-signed certificate
+   */
+  saveTemporaryPfx = (disk, path, name, alias, id, password, subjectX500Name, onSuccess, onError) => {
+    this.callMethod(
+      "save_temporary_pfx",
+      [disk, path, name, alias, id, password, subjectX500Name],
+      onSuccess,
+      onError
+    );
+  };
+  // Promise-based methods
+  /**
+   * Get list of available disks (Promise version)
+   */
+  listDisksAsync = this.createPromiseMethod("list_disks");
+  /**
+   * Get list of certificates from specific disk (Promise version)
+   */
+  listCertificatesAsync = this.createPromiseMethod("list_certificates");
+  /**
+   * Get list of all certificates (Promise version)
+   */
+  listAllCertificatesAsync = this.createPromiseMethod("list_all_certificates");
+  /**
+   * Load key (Promise version)
+   */
+  loadKeyAsync = this.createPromiseMethod(
+    "load_key"
+  );
+  /**
+   * Unload key (Promise version)
+   */
+  unloadKeyAsync = this.createPromiseMethod("unload_key");
+  /**
+   * Verify password (Promise version)
+   */
+  verifyPasswordAsync = this.createPromiseMethod("verify_password");
+  /**
+   * Change password (Promise version)
+   */
+  changePasswordAsync = this.createPromiseMethod("change_password");
+  /**
+   * Save PFX (Promise version)
+   */
+  savePfxAsync = this.createPromiseMethod("save_pfx");
+  /**
+   * Save temporary PFX (Promise version)
+   */
+  saveTemporaryPfxAsync = this.createPromiseMethod("save_temporary_pfx");
+};
+_init8 = __decoratorStart(_a8);
+PfxPlugin = __decorateElement(_init8, 0, "PfxPlugin", _PfxPlugin_decorators, PfxPlugin);
+__runInitializers(_init8, 1, PfxPlugin);
+var pfxPlugin = new PfxPlugin();
+
+// src/plugins/pkcs10.ts
+var _PKCS10Plugin_decorators, _init9, _a9;
+_PKCS10Plugin_decorators = [RegisterPlugin];
+var PKCS10Plugin = class extends (_a9 = EIMZOPlugin) {
+  name = "pkcs10";
+  description = "Plugin for generating key pairs and PKCS#10 certificate requests";
+  /**
+   * Формировать запрос на сертификат формата PKCS#10 из существующего ключа
+   */
+  createPkcs10FromKey = (keyId, subject, onSuccess, onError) => {
+    this.callMethod("create_pkcs10_from_key", [keyId, subject], onSuccess, onError);
+  };
+  /**
+   * Сгенерировать ключевую пару
+   */
+  generateKeypair = (keySize, onSuccess, onError) => {
+    this.callMethod("generate_keypair", [keySize], onSuccess, onError);
+  };
+  /**
+   * Формировать запрос на сертификат формата PKCS#10
+   */
+  createPkcs10 = (subject, keySize, onSuccess, onError) => {
+    this.callMethod("create_pkcs10", [subject, keySize], onSuccess, onError);
+  };
+  /**
+   * Получить информацию о запросе PKCS#10
+   */
+  getPkcs10Info = (pkcs10, onSuccess, onError) => {
+    this.callMethod("get_pkcs10_info", [pkcs10], onSuccess, onError);
+  };
+};
+_init9 = __decoratorStart(_a9);
+PKCS10Plugin = __decorateElement(_init9, 0, "PKCS10Plugin", _PKCS10Plugin_decorators, PKCS10Plugin);
+__runInitializers(_init9, 1, PKCS10Plugin);
+
+// src/plugins/pkcs7.ts
+var _Pkcs7Plugin_decorators, _init10, _a10;
+_Pkcs7Plugin_decorators = [RegisterPlugin];
+var Pkcs7Plugin = class extends (_a10 = EIMZOPlugin) {
+  name = "pkcs7";
+  description = "Plugin for working with PKCS#7/CMS format";
+  // Callback-based methods
+  /**
+   * Create PKCS#7/CMS document by signing with key
+   */
+  createPkcs7 = (data64, keyId, detached = "", onSuccess, onError) => {
+    this.callMethod("create_pkcs7", [data64, keyId, detached], onSuccess, onError);
+  };
+  /**
+   * Get full information about PKCS#7/CMS document (attached)
+   */
+  getPkcs7AttachedInfo = (pkcs764, trustStoreId = "", onSuccess, onError) => {
+    this.callMethod("get_pkcs7_attached_info", [pkcs764, trustStoreId], onSuccess, onError);
+  };
+  /**
+   * Get full information about PKCS#7/CMS document (detached)
+   */
+  getPkcs7DetachedInfo = (data64, pkcs764, trustStoreId = "", onSuccess, onError) => {
+    this.callMethod("get_pkcs7_detached_info", [data64, pkcs764, trustStoreId], onSuccess, onError);
+  };
+  /**
+   * Verify PKCS#7/CMS document (attached) - STUB
+   */
+  verifyPkcs7Attached = (pkcs764, trustStoreId, requesterId = "", onSuccess, onError) => {
+    this.callMethod(
+      "verify_pkcs7_attached",
+      [pkcs764, trustStoreId, requesterId],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Verify PKCS#7/CMS document (detached) - STUB
+   */
+  verifyPkcs7Detached = (data64, pkcs764, trustStoreId, requesterId = "", onSuccess, onError) => {
+    this.callMethod(
+      "verify_pkcs7_detached",
+      [data64, pkcs764, trustStoreId, requesterId],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Verify PKCS#7/CMS document with CRL (attached) - STUB
+   */
+  verifyPkcs7AttachedCrl = (pkcs764, trustStoreId, crlId, onSuccess, onError) => {
+    this.callMethod(
+      "verify_pkcs7_attached_crl",
+      [pkcs764, trustStoreId, crlId],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Verify PKCS#7/CMS document with CRL (detached) - STUB
+   */
+  verifyPkcs7DetachedCrl = (data64, pkcs764, trustStoreId, crlId, onSuccess, onError) => {
+    this.callMethod(
+      "verify_pkcs7_detached_crl",
+      [data64, pkcs764, trustStoreId, crlId],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Attach timestamp token to PKCS#7/CMS document - STUB
+   */
+  attachTimestampTokenPkcs7 = (pkcs764, signerSerialNumber, timestampToken64, onSuccess, onError) => {
+    this.callMethod(
+      "attach_timestamp_token_pkcs7",
+      [pkcs764, signerSerialNumber, timestampToken64],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Add signature to existing PKCS#7/CMS document (attached) - DEPRECATED
+   */
+  appendPkcs7Attached = (pkcs764, keyId, onSuccess, onError) => {
+    this.callMethod("append_pkcs7_attached", [pkcs764, keyId], onSuccess, onError);
+  };
+  /**
+   * Add signature to existing PKCS#7/CMS document (detached) - DEPRECATED
+   */
+  appendPkcs7Detached = (data64, pkcs764, keyId, onSuccess, onError) => {
+    this.callMethod("append_pkcs7_detached", [data64, pkcs764, keyId], onSuccess, onError);
+  };
+  // Promise-based methods
+  /**
+   * Create PKCS#7/CMS document (Promise version)
+   */
+  createPkcs7Async = this.createPromiseMethod("create_pkcs7");
+  /**
+   * Get PKCS#7 attached info (Promise version)
+   */
+  getPkcs7AttachedInfoAsync = this.createPromiseMethod(
+    "get_pkcs7_attached_info"
+  );
+  /**
+   * Get PKCS#7 detached info (Promise version)
+   */
+  getPkcs7DetachedInfoAsync = this.createPromiseMethod("get_pkcs7_detached_info");
+  /**
+   * Verify PKCS#7 attached (Promise version)
+   */
+  verifyPkcs7AttachedAsync = this.createPromiseMethod("verify_pkcs7_attached");
+  /**
+   * Verify PKCS#7 detached (Promise version)
+   */
+  verifyPkcs7DetachedAsync = this.createPromiseMethod("verify_pkcs7_detached");
+  /**
+   * Attach timestamp token (Promise version)
+   */
+  attachTimestampTokenPkcs7Async = this.createPromiseMethod("attach_timestamp_token_pkcs7");
+};
+_init10 = __decoratorStart(_a10);
+Pkcs7Plugin = __decorateElement(_init10, 0, "Pkcs7Plugin", _Pkcs7Plugin_decorators, Pkcs7Plugin);
+__runInitializers(_init10, 1, Pkcs7Plugin);
+var pkcs7Plugin = new Pkcs7Plugin();
+
+// src/plugins/pki.ts
+var _PKIPlugin_decorators, _init11, _a11;
+_PKIPlugin_decorators = [RegisterPlugin];
+var PKIPlugin = class extends (_a11 = EIMZOPlugin) {
+  name = "pki";
+  description = "Plugin for PKI (Public Key Infrastructure) interaction";
+  /**
+   * Шаг №1 для получения ключа PFX
+   */
+  enrollPfxStep1 = (request, onSuccess, onError) => {
+    this.callMethod("enroll_pfx_step1", [request], onSuccess, onError);
+  };
+  /**
+   * Шаг №2 для получения ключа PFX
+   */
+  enrollPfxStep2 = (response, onSuccess, onError) => {
+    this.callMethod("enroll_pfx_step2", [response], onSuccess, onError);
+  };
+};
+_init11 = __decoratorStart(_a11);
+PKIPlugin = __decorateElement(_init11, 0, "PKIPlugin", _PKIPlugin_decorators, PKIPlugin);
+__runInitializers(_init11, 1, PKIPlugin);
+
+// src/plugins/truststore-jks.ts
+var _TruststoreJKSPlugin_decorators, _init12, _a12;
+_TruststoreJKSPlugin_decorators = [RegisterPlugin];
+var TruststoreJKSPlugin = class extends (_a12 = EIMZOPlugin) {
+  name = "truststore-jks";
+  description = "Plugin for working with JKS trust stores";
+  /**
+   * Открывает хранилище доверенных сертификатов 'truststore.jks' в домашней директории пользователя
+   */
+  openTruststore = (onSuccess, onError) => {
+    this.callMethod("open_truststore", [], onSuccess, onError);
+  };
+  // Promise-based methods
+  /**
+   * Открывает хранилище доверенных сертификатов 'truststore.jks' в домашней директории пользователя
+   */
+  async openTruststoreAsync() {
+    return new Promise((resolve, reject) => {
+      this.openTruststore(
+        (event, data) => {
+          if (data.success) {
+            resolve(data);
+          } else {
+            reject(new Error(data.reason ?? "Unknown error"));
+          }
+        },
+        (error) => reject(new Error(String(error)))
+      );
+    });
+  }
+};
+_init12 = __decoratorStart(_a12);
+TruststoreJKSPlugin = __decorateElement(_init12, 0, "TruststoreJKSPlugin", _TruststoreJKSPlugin_decorators, TruststoreJKSPlugin);
+__runInitializers(_init12, 1, TruststoreJKSPlugin);
+
+// src/plugins/truststore.ts
+var _TruststorePlugin_decorators, _init13, _a13;
+_TruststorePlugin_decorators = [RegisterPlugin];
+var TruststorePlugin = class extends (_a13 = EIMZOPlugin) {
+  name = "truststore";
+  description = "Plugin for working with trust stores";
+  /**
+   * Получить список доверенных сертификатов (ЗАГЛУШКА)
+   */
+  listTruststore = (onSuccess, onError) => {
+    this.callMethod("list_truststore", [], onSuccess, onError);
+  };
+};
+_init13 = __decoratorStart(_a13);
+TruststorePlugin = __decorateElement(_init13, 0, "TruststorePlugin", _TruststorePlugin_decorators, TruststorePlugin);
+__runInitializers(_init13, 1, TruststorePlugin);
+
+// src/plugins/tsaclient.ts
+var _TSAClientPlugin_decorators, _init14, _a14;
+_TSAClientPlugin_decorators = [RegisterPlugin];
+var TSAClientPlugin = class extends (_a14 = EIMZOPlugin) {
+  name = "tsaclient";
+  description = "Plugin for working with timestamp tokens";
+  /**
+   * Получить запрос на получения токена штампа времени для данных
+   */
+  getTimestampTokenRequestForData = (data, onSuccess, onError) => {
+    this.callMethod("get_timestamp_token_request_for_data", [data], onSuccess, onError);
+  };
+  /**
+   * Получить токен штампа времени на подпись от службы штампов времени по веб-ссылке
+   */
+  getTimestampTokenForSignature = (signature, tsaUrl, onSuccess, onError) => {
+    this.callMethod("get_timestamp_token_for_signature", [signature, tsaUrl], onSuccess, onError);
+  };
+  /**
+   * Получить токен штампа времени на данные от службы штампов времени по веб-ссылке
+   */
+  getTimestampTokenForData = (data, tsaUrl, onSuccess, onError) => {
+    this.callMethod("get_timestamp_token_for_data", [data, tsaUrl], onSuccess, onError);
+  };
+  /**
+   * Получить информацию о токене штампа времени
+   */
+  getTimestampTokenInfo = (token, onSuccess, onError) => {
+    this.callMethod("get_timestamp_token_info", [token], onSuccess, onError);
+  };
+  /**
+   * Получить запрос на получения токена штампа времени для подписи
+   */
+  getTimestampTokenRequestForSignature = (signature, onSuccess, onError) => {
+    this.callMethod("get_timestamp_token_request_for_signature", [signature], onSuccess, onError);
+  };
+};
+_init14 = __decoratorStart(_a14);
+TSAClientPlugin = __decorateElement(_init14, 0, "TSAClientPlugin", _TSAClientPlugin_decorators, TSAClientPlugin);
+__runInitializers(_init14, 1, TSAClientPlugin);
+
+// src/plugins/tunnel.ts
+var _TunnelPlugin_decorators, _init15, _a15;
+_TunnelPlugin_decorators = [RegisterPlugin];
+var TunnelPlugin = class extends (_a15 = EIMZOPlugin) {
+  name = "tunnel";
+  description = "Plugin for establishing encrypted connections using GOST-28147";
+  /**
+   * Создать зашифрованного соединения с сервером и вернуть TCP-порт для приема/передачи данных
+   */
+  createTunnel = (serverHost, serverPort, keyId, onSuccess, onError) => {
+    this.callMethod("create_tunnel", [serverHost, serverPort, keyId], onSuccess, onError);
+  };
+  // Promise-based wrapper (если нужен)
+  async createTunnelAsync(serverHost, serverPort, keyId) {
+    return new Promise((resolve, reject) => {
+      this.createTunnel(
+        serverHost,
+        serverPort,
+        keyId,
+        (event, data) => {
+          if (data.success) {
+            resolve(data);
+          } else {
+            reject(new Error(data.reason ?? "Unknown error"));
+          }
+        },
+        (error) => reject(new Error(String(error)))
+      );
+    });
+  }
+};
+_init15 = __decoratorStart(_a15);
+TunnelPlugin = __decorateElement(_init15, 0, "TunnelPlugin", _TunnelPlugin_decorators, TunnelPlugin);
+__runInitializers(_init15, 1, TunnelPlugin);
+
+// src/plugins/x509.ts
+var _X509Plugin_decorators, _init16, _a16;
+_X509Plugin_decorators = [RegisterPlugin];
+var X509Plugin = class extends (_a16 = EIMZOPlugin) {
+  name = "x509";
+  description = "Plugin for working with X.509 certificates";
+  /**
+   * Верификация подписи сертификата субъектка сертификатом издателя
+   */
+  verifyCertificate = (subjectCert, issuerCert, onSuccess, onError) => {
+    this.callMethod("verify_certificate", [subjectCert, issuerCert], onSuccess, onError);
+  };
+  /**
+   * Получить цепочку сертификатов в кодировке BASE64 по идентификатору ключа
+   */
+  getCertificateChain = (keyId, onSuccess, onError) => {
+    this.callMethod("get_certificate_chain", [keyId], onSuccess, onError);
+  };
+  /**
+   * Получить информацию о сертификате
+   */
+  getCertificateInfo = (certificate, onSuccess, onError) => {
+    this.callMethod("get_certificate_info", [certificate], onSuccess, onError);
+  };
+};
+_init16 = __decoratorStart(_a16);
+X509Plugin = __decorateElement(_init16, 0, "X509Plugin", _X509Plugin_decorators, X509Plugin);
+__runInitializers(_init16, 1, X509Plugin);
+
+// src/plugins/ytks.ts
+var _YTKSPlugin_decorators, _init17, _a17;
+_YTKSPlugin_decorators = [RegisterPlugin];
+var YTKSPlugin = class extends (_a17 = EIMZOPlugin) {
+  name = "ytks";
+  description = "Plugin for working with YTKS key storage files";
+  /**
+   * Удалить загруженные ключи по идентификатору
+   */
+  unloadKey = (keyId, onSuccess, onError) => {
+    this.callMethod("unload_key", [keyId], onSuccess, onError);
+  };
+  /**
+   * Изменить пароль хранилища ключей
+   */
+  changePassword = (disk, path, name, oldPassword, newPassword, onSuccess, onError) => {
+    this.callMethod(
+      "change_password",
+      [disk, path, name, oldPassword, newPassword],
+      onSuccess,
+      onError
+    );
+  };
+  /**
+   * Получить список дисков
+   */
+  listDisks = (onSuccess, onError) => {
+    this.callMethod("list_disks", [], onSuccess, onError);
+  };
+  /**
+   * Получить список сертификатов пользователя
+   */
+  listCertificates = (disk, onSuccess, onError) => {
+    this.callMethod("list_certificates", [disk], onSuccess, onError);
+  };
+  /**
+   * Проверить пароль хранилища ключей
+   */
+  verifyPassword = (disk, path, name, password, onSuccess, onError) => {
+    this.callMethod("verify_password", [disk, path, name, password], onSuccess, onError);
+  };
+  /**
+   * Получить список всех сертификатов пользователя
+   */
+  listAllCertificates = (onSuccess, onError) => {
+    this.callMethod("list_all_certificates", [], onSuccess, onError);
+  };
+  /**
+   * Загрузить ключ и получить идентификатор ключа
+   */
+  loadKey = (disk, path, name, alias, onSuccess, onError) => {
+    this.callMethod("load_key", [disk, path, name, alias], onSuccess, onError);
+  };
+  /**
+   * Сохранить ключевую пару или существующий ключ и новые сертификаты в новый файл формата YTKS
+   */
+  saveYtks = (disk, path, name, password, keyId, certificates, onSuccess, onError) => {
+    this.callMethod(
+      "save_ytks",
+      [disk, path, name, password, keyId, certificates],
+      onSuccess,
+      onError
+    );
+  };
+};
+_init17 = __decoratorStart(_a17);
+YTKSPlugin = __decorateElement(_init17, 0, "YTKSPlugin", _YTKSPlugin_decorators, YTKSPlugin);
+__runInitializers(_init17, 1, YTKSPlugin);
+
+// src/eimzo-api.ts
+var EIMZOApi = class {
+  // Core CAPIWS access
+  capiws = capiws_default;
+  // Legacy client for backward compatibility
+  client = e_imzo_client_default;
+  // Plugin manager for accessing plugins
+  plugins = PluginManager;
+  // Direct plugin access
+  pfx = PluginManager.get("pfx");
+  pkcs7 = PluginManager.get("pkcs7");
+  ftjc = PluginManager.get("ftjc");
+  cryptoauth = PluginManager.get("cryptoauth");
+  truststoreJks = PluginManager.get("truststore-jks");
+  tunnel = PluginManager.get("tunnel");
+  certkey = PluginManager.get("certkey");
+  x509 = PluginManager.get("x509");
+  cipher = PluginManager.get("cipher");
+  pki = PluginManager.get("pki");
+  pkcs10 = PluginManager.get("pkcs10");
+  idcard = PluginManager.get("idcard");
+  truststore = PluginManager.get("truststore");
+  crl = PluginManager.get("crl");
+  fileio = PluginManager.get("fileio");
+  tsaclient = PluginManager.get("tsaclient");
+  ytks = PluginManager.get("ytks");
+  /**
+   * Initialize E-IMZO API and check version
+   */
+  async initialize() {
+    return new Promise((resolve, reject) => {
+      this.client.checkVersion(
+        (major, minor) => resolve({ major, minor }),
+        (error, reason) => reject(new Error(reason ?? "Version check failed"))
+      );
+    });
+  }
+  /**
+   * Install API keys
+   */
+  async installApiKeys() {
+    return new Promise((resolve, reject) => {
+      this.client.installApiKeys(
+        () => resolve(),
+        (error, reason) => reject(new Error(reason ?? "API key installation failed"))
+      );
+    });
+  }
+  /**
+   * Check if ID card is plugged in
+   */
+  async isIdCardPluggedIn() {
+    return new Promise((resolve, reject) => {
+      this.client.idCardIsPLuggedIn(
+        (isPlugged) => resolve(isPlugged),
+        (error, reason) => reject(new Error(reason ?? "ID card check failed"))
+      );
+    });
+  }
+  /**
+   * Get version information
+   */
+  async getVersion() {
+    return new Promise((resolve, reject) => {
+      this.capiws.version(
+        (event, data) => {
+          if (data.success && data.major && data.minor) {
+            resolve({ major: data.major, minor: data.minor });
+          } else {
+            reject(new Error(data.reason ?? "Failed to get version"));
+          }
+        },
+        (error) => reject(new Error(String(error) || "Version check failed"))
+      );
+    });
+  }
+  /**
+   * Get API documentation
+   */
+  async getApiDoc() {
+    return new Promise((resolve, reject) => {
+      this.capiws.apidoc(
+        (event, data) => {
+          if (data.success) {
+            resolve(data);
+          } else {
+            reject(new Error(data.reason ?? "Failed to get API documentation"));
+          }
+        },
+        (error) => reject(new Error(String(error) || "API documentation request failed"))
+      );
+    });
+  }
+  /**
+   * Setup API keys
+   */
+  async setupApiKeys(domainAndKey) {
+    return new Promise((resolve, reject) => {
+      this.capiws.apikey(
+        domainAndKey,
+        (event, data) => {
+          if (data.success) {
+            resolve();
+          } else {
+            reject(new Error(data.reason ?? "Failed to setup API keys"));
+          }
+        },
+        (error) => reject(new Error(String(error) || "API keys setup failed"))
+      );
+    });
+  }
+  /**
+   * Get all available plugins
+   */
+  getAvailablePlugins() {
+    return this.plugins.getAll().map((plugin) => plugin.name);
+  }
+  /**
+   * Check if a plugin is available
+   */
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+  /**
+   * Get plugin by name with type safety
+   */
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+};
+var eimzoApi = new EIMZOApi();
+var eimzo_api_default = eimzoApi;
+
+// src/global.ts
+function setupGlobalObjects() {
+  if (typeof window !== "undefined") {
+    const win = window;
+    win.CAPIWS = capiws_default;
+    win.EIMZOClient = e_imzo_client_default;
+    win.capiws = capiws_default;
+    win.eimzoApi = eimzoApi;
+    const processEnv = process.env;
+    const isDev = typeof process !== "undefined" && processEnv.NODE_ENV === "development";
+    if (isDev) {
+      win.imzoPlugins = {
+        version: "1.0.0",
+        loaded: true,
+        plugins: [],
+        debug: true
+      };
+      console.info("\u{1F527} E-IMZO Agnostic Library - Development Mode");
+      console.info("Available APIs:", {
+        CAPIWS: "Main CAPIWS client for E-IMZO communication",
+        EIMZOClient: "Legacy E-IMZO client wrapper",
+        capiws: "Legacy alias for CAPIWS",
+        eimzoApi: "Modern plugin-based E-IMZO API",
+        imzoPlugins: "Plugin system information"
+      });
+    }
+    if (isDev) {
+      console.info("\u2705 E-IMZO Global Setup - Success");
+      console.info("Global status:", {
+        CAPIWS: Boolean(win.CAPIWS),
+        EIMZOClient: Boolean(win.EIMZOClient),
+        capiws: Boolean(win.capiws),
+        eimzoApi: Boolean(win.eimzoApi),
+        imzoPlugins: Boolean(win.imzoPlugins)
+      });
+    }
+  }
+}
+setupGlobalObjects();
+
+exports.CAPIWS = capiws_default;
+exports.EIMZOApi = EIMZOApi;
+exports.EIMZOClient = e_imzo_client_default;
+exports.EIMZOPlugin = EIMZOPlugin;
+exports.PluginManager = PluginManager;
+exports.dates = dates;
+exports.eimzoApi = eimzo_api_default;
+exports.ftjcPlugin = ftjcPlugin;
+exports.pfxPlugin = pfxPlugin;
+exports.pkcs7Plugin = pkcs7Plugin;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map