imzo-agnost 1.0.0

package/dist/index.js

@@ -0,0 +1,1823 @@
+var EIMZOAgnost = (function (exports) {
+  '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;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map