@genai-fi/base 3.0.1

package/dist/hooks/id.d.ts

@@ -0,0 +1 @@
+export declare function useID(size?: number): string;

package/dist/hooks/id.js

@@ -0,0 +1,16 @@
+import t from "../util/randomId.js";
+import { useMemo as r } from "react";
+function m(e) {
+  return r(() => {
+    const o = window.sessionStorage.getItem(`genai-sm-idcode-${e}`);
+    if (o)
+      return o;
+    {
+      const n = t(e);
+      return window.sessionStorage.setItem(`genai-sm-idcode-${e}`, n), n;
+    }
+  }, [e]);
+}
+export {
+  m as useID
+};

package/dist/hooks/onlyOnce.d.ts

@@ -0,0 +1 @@
+export declare function useOnlyOnce(key: string, value: boolean): boolean;

package/dist/hooks/onlyOnce.js

@@ -0,0 +1,7 @@
+import { useMemo as e } from "react";
+function s(r, t) {
+  return e(() => window.sessionStorage.getItem(r) ? !0 : (t && window.sessionStorage.setItem(r, "true"), t), [r, t]);
+}
+export {
+  s as useOnlyOnce
+};

package/dist/hooks/peer.d.ts

@@ -0,0 +1,25 @@
+import { default as Peer2Peer, P2POptions } from '../services/peer2peer/Peer2Peer';
+import { Connection, PeerEvent } from '../services/peer2peer/types';
+interface Callbacks<T extends PeerEvent> {
+    onOpen?: () => void;
+    onConnect?: (conn: Connection<T>) => void;
+    onClose?: (conn?: Connection<T>) => void;
+    onError?: (e: unknown) => void;
+    onData?: (data: T, conn: Connection<T>) => void;
+}
+interface Props<T extends PeerEvent> extends Callbacks<T>, P2POptions {
+    code?: string;
+    server?: string;
+    host: string;
+    secure?: boolean;
+    key?: string;
+    port?: number;
+    disabled?: boolean;
+}
+export type PeerProps<T extends PeerEvent> = Props<T>;
+export default function usePeer<T extends PeerEvent>({ code, server, host, secure, port, key, disabled, onOpen, onClose, onError, onData, onConnect, forceTURN, forceWebsocket, }: Props<T>): {
+    send: ((data: T, exclude?: string[]) => void) | undefined;
+    ready: boolean;
+    peer: Peer2Peer<T> | undefined;
+};
+export {};

package/dist/hooks/peer.js

@@ -0,0 +1,70 @@
+import { useState as S, useRef as x, useEffect as D } from "react";
+import { i as E, w as T } from "../webrtcState-D0nJpE9Z.js";
+import V from "../services/peer2peer/Peer2Peer.js";
+import { u as q, a as z } from "../react-D-b-Xrzv.js";
+function I({
+  code: u,
+  server: i,
+  host: f,
+  secure: l,
+  port: d,
+  key: m,
+  disabled: p,
+  onOpen: C,
+  onClose: b,
+  onError: w,
+  onData: A,
+  onConnect: P,
+  forceTURN: g,
+  forceWebsocket: y
+}) {
+  const [s, R] = S(), e = x({}), [o, c] = q(T), a = z(E), [j, n] = S("connecting");
+  return D(() => {
+    e.current.onClose = b, e.current.onOpen = C, e.current.onConnect = P, e.current.onError = w, e.current.onData = A;
+  }, [A, C, b, w, P]), D(() => {
+    if (p) {
+      n("failed"), c("disabled");
+      return;
+    } else
+      n("connecting");
+    if (o === "unset") return;
+    if (o === "disabled") {
+      c("unset");
+      return;
+    }
+    if (!u) return;
+    if (!a) {
+      setTimeout(() => {
+        n("failed");
+      }, 5e3), n("failed");
+      return;
+    }
+    const t = new V(
+      u,
+      f,
+      l || !1,
+      m || "peerjs",
+      d || 443,
+      a,
+      o === "relay",
+      i,
+      { forceTURN: g, forceWebsocket: y }
+    );
+    return t.on("status", n), t.on("data", (r, v) => {
+      e.current.onData && e.current.onData(r, v);
+    }), t.on("close", (r) => {
+      e.current.onClose && e.current.onClose(r);
+    }), t.on("connect", (r) => {
+      e.current.onConnect && e.current.onConnect(r);
+    }), R(t), () => {
+      t.destroy();
+    };
+  }, [u, i, o, a, f, m, d, l, p, c, g, y]), {
+    send: s ? s.boundSendAll : void 0,
+    ready: j === "ready",
+    peer: s
+  };
+}
+export {
+  I as default
+};

package/dist/hooks/random.d.ts

@@ -0,0 +1 @@
+export default function useRandom(size: number): string;

package/dist/hooks/random.js

@@ -0,0 +1,9 @@
+import o from "../util/randomId.js";
+import { useRef as t } from "react";
+function f(e) {
+  const r = t();
+  return r.current === void 0 && (r.current = o(e)), r.current;
+}
+export {
+  f as default
+};

package/dist/hooks/useTabActive.d.ts

@@ -0,0 +1 @@
+export declare function useTabActive(): boolean;

package/dist/hooks/useTabActive.js

@@ -0,0 +1,17 @@
+import { useState as r, useEffect as i } from "react";
+function u() {
+  const [o, e] = r(!0);
+  return i(() => {
+    const t = () => {
+      e(!1);
+    }, n = () => {
+      e(!0);
+    };
+    return window.addEventListener("blur", t), window.addEventListener("focus", n), () => {
+      window.removeEventListener("blur", t), window.removeEventListener("focus", n);
+    };
+  }, [e]), o;
+}
+export {
+  u as useTabActive
+};

package/dist/index-SOhdqzHq.js

@@ -0,0 +1,113 @@
+import { g as L } from "./_commonjsHelpers-DaMA6jEr.js";
+var x = { exports: {} }, E;
+function C() {
+  return E || (E = 1, function(g) {
+    var w = Object.prototype.hasOwnProperty, c = "~";
+    function h() {
+    }
+    Object.create && (h.prototype = /* @__PURE__ */ Object.create(null), new h().__proto__ || (c = !1));
+    function d(s, t, n) {
+      this.fn = s, this.context = t, this.once = n || !1;
+    }
+    function m(s, t, n, r, l) {
+      if (typeof n != "function")
+        throw new TypeError("The listener must be a function");
+      var u = new d(n, r || s, l), o = c ? c + t : t;
+      return s._events[o] ? s._events[o].fn ? s._events[o] = [s._events[o], u] : s._events[o].push(u) : (s._events[o] = u, s._eventsCount++), s;
+    }
+    function y(s, t) {
+      --s._eventsCount === 0 ? s._events = new h() : delete s._events[t];
+    }
+    function f() {
+      this._events = new h(), this._eventsCount = 0;
+    }
+    f.prototype.eventNames = function() {
+      var t = [], n, r;
+      if (this._eventsCount === 0) return t;
+      for (r in n = this._events)
+        w.call(n, r) && t.push(c ? r.slice(1) : r);
+      return Object.getOwnPropertySymbols ? t.concat(Object.getOwnPropertySymbols(n)) : t;
+    }, f.prototype.listeners = function(t) {
+      var n = c ? c + t : t, r = this._events[n];
+      if (!r) return [];
+      if (r.fn) return [r.fn];
+      for (var l = 0, u = r.length, o = new Array(u); l < u; l++)
+        o[l] = r[l].fn;
+      return o;
+    }, f.prototype.listenerCount = function(t) {
+      var n = c ? c + t : t, r = this._events[n];
+      return r ? r.fn ? 1 : r.length : 0;
+    }, f.prototype.emit = function(t, n, r, l, u, o) {
+      var a = c ? c + t : t;
+      if (!this._events[a]) return !1;
+      var e = this._events[a], v = arguments.length, p, i;
+      if (e.fn) {
+        switch (e.once && this.removeListener(t, e.fn, void 0, !0), v) {
+          case 1:
+            return e.fn.call(e.context), !0;
+          case 2:
+            return e.fn.call(e.context, n), !0;
+          case 3:
+            return e.fn.call(e.context, n, r), !0;
+          case 4:
+            return e.fn.call(e.context, n, r, l), !0;
+          case 5:
+            return e.fn.call(e.context, n, r, l, u), !0;
+          case 6:
+            return e.fn.call(e.context, n, r, l, u, o), !0;
+        }
+        for (i = 1, p = new Array(v - 1); i < v; i++)
+          p[i - 1] = arguments[i];
+        e.fn.apply(e.context, p);
+      } else {
+        var b = e.length, _;
+        for (i = 0; i < b; i++)
+          switch (e[i].once && this.removeListener(t, e[i].fn, void 0, !0), v) {
+            case 1:
+              e[i].fn.call(e[i].context);
+              break;
+            case 2:
+              e[i].fn.call(e[i].context, n);
+              break;
+            case 3:
+              e[i].fn.call(e[i].context, n, r);
+              break;
+            case 4:
+              e[i].fn.call(e[i].context, n, r, l);
+              break;
+            default:
+              if (!p) for (_ = 1, p = new Array(v - 1); _ < v; _++)
+                p[_ - 1] = arguments[_];
+              e[i].fn.apply(e[i].context, p);
+          }
+      }
+      return !0;
+    }, f.prototype.on = function(t, n, r) {
+      return m(this, t, n, r, !1);
+    }, f.prototype.once = function(t, n, r) {
+      return m(this, t, n, r, !0);
+    }, f.prototype.removeListener = function(t, n, r, l) {
+      var u = c ? c + t : t;
+      if (!this._events[u]) return this;
+      if (!n)
+        return y(this, u), this;
+      var o = this._events[u];
+      if (o.fn)
+        o.fn === n && (!l || o.once) && (!r || o.context === r) && y(this, u);
+      else {
+        for (var a = 0, e = [], v = o.length; a < v; a++)
+          (o[a].fn !== n || l && !o[a].once || r && o[a].context !== r) && e.push(o[a]);
+        e.length ? this._events[u] = e.length === 1 ? e[0] : e : y(this, u);
+      }
+      return this;
+    }, f.prototype.removeAllListeners = function(t) {
+      var n;
+      return t ? (n = c ? c + t : t, this._events[n] && y(this, n)) : (this._events = new h(), this._eventsCount = 0), this;
+    }, f.prototype.off = f.prototype.removeListener, f.prototype.addListener = f.prototype.on, f.prefixed = c, f.EventEmitter = f, g.exports = f;
+  }(x)), x.exports;
+}
+var O = C();
+const k = /* @__PURE__ */ L(O);
+export {
+  k as E
+};

package/dist/main.d.ts

@@ -0,0 +1,21 @@
+export { default as ConnectionStatus } from './components/ConnectionStatus/ConnectionStatus';
+export { Button, LargeButton } from './components/Button/Button';
+export { default as usePeer } from './hooks/peer';
+export type { SenderType, PeerEvent, PeerErrorType, PeerStatus, BuiltinEvent, Connection, PeerConnectionType, } from './services/peer2peer/types';
+export { default as Peer2Peer } from './services/peer2peer/Peer2Peer';
+export { useID } from './hooks/id';
+export { useOnlyOnce } from './hooks/onlyOnce';
+export { default as useRandom } from './hooks/random';
+export { theme } from './style/theme';
+export { default as randomId } from './util/randomId';
+export { cropTo, canvasFromFile, canvasesFromFiles, canvasFromImage, canvasFromURL, canvasFromDataTransfer, urlFromDataTransfer, } from './util/canvas';
+export { loadZipFile, saveZipFile, createZipBlob } from './util/zip';
+export type { ZipData } from './util/zip';
+export { useTabActive } from './hooks/useTabActive';
+export { default as Spinner } from './components/Spinner/Spinner';
+export { default as Privacy } from './components/Privacy/Privacy';
+export { default as BusyButton } from './components/BusyButton/BusyButton';
+export { default as AlertPara } from './components/AlertPara/AlertPara';
+export { default as QRCode } from './components/QRCode/QRCode';
+export { default as Webcam } from './components/Webcam/Webcam';
+export { default as ContentLoader } from './components/ContentLoader/ContentLoader';

package/dist/main.js

@@ -0,0 +1,49 @@
+import { default as o } from "./components/ConnectionStatus/ConnectionStatus.js";
+import { B as t, L as f } from "./Button-DQwRVw4a.js";
+import { default as m } from "./hooks/peer.js";
+import { default as u } from "./services/peer2peer/Peer2Peer.js";
+import { useID as n } from "./hooks/id.js";
+import { useOnlyOnce as d } from "./hooks/onlyOnce.js";
+import { default as i } from "./hooks/random.js";
+import { theme as v } from "./style/theme.js";
+import { default as P } from "./util/randomId.js";
+import { canvasFromDataTransfer as T, canvasFromFile as b, canvasFromImage as y, canvasFromURL as C, canvasesFromFiles as D, cropTo as I, urlFromDataTransfer as R } from "./util/canvas.js";
+import { createZipBlob as g, loadZipFile as A, saveZipFile as O } from "./util/zip.js";
+import { useTabActive as h } from "./hooks/useTabActive.js";
+import { default as U } from "./components/Spinner/Spinner.js";
+import { default as j } from "./components/Privacy/Privacy.js";
+import { default as q } from "./components/BusyButton/BusyButton.js";
+import { default as z } from "./components/AlertPara/AlertPara.js";
+import { default as G } from "./components/QRCode/QRCode.js";
+import { default as J } from "./components/Webcam/Webcam.js";
+import { default as M } from "./components/ContentLoader/ContentLoader.js";
+export {
+  z as AlertPara,
+  q as BusyButton,
+  t as Button,
+  o as ConnectionStatus,
+  M as ContentLoader,
+  f as LargeButton,
+  u as Peer2Peer,
+  j as Privacy,
+  G as QRCode,
+  U as Spinner,
+  J as Webcam,
+  T as canvasFromDataTransfer,
+  b as canvasFromFile,
+  y as canvasFromImage,
+  C as canvasFromURL,
+  D as canvasesFromFiles,
+  g as createZipBlob,
+  I as cropTo,
+  A as loadZipFile,
+  P as randomId,
+  O as saveZipFile,
+  v as theme,
+  R as urlFromDataTransfer,
+  n as useID,
+  d as useOnlyOnce,
+  m as usePeer,
+  i as useRandom,
+  h as useTabActive
+};

package/dist/react-D-b-Xrzv.js

@@ -0,0 +1,98 @@
+import w, { useReducer as v, useEffect as R, useDebugValue as S, useCallback as P, useContext as x, createContext as y } from "react";
+import { g as C, I as h } from "./webrtcState-D0nJpE9Z.js";
+const F = {}, V = y(
+  void 0
+);
+function A(t) {
+  return x(V) || C();
+}
+const b = (t) => typeof (t == null ? void 0 : t.then) == "function", g = (t) => {
+  t.status || (t.status = "pending", t.then(
+    (o) => {
+      t.status = "fulfilled", t.value = o;
+    },
+    (o) => {
+      t.status = "rejected", t.reason = o;
+    }
+  ));
+}, j = w.use || // A shim for older React versions
+((t) => {
+  if (t.status === "pending")
+    throw t;
+  if (t.status === "fulfilled")
+    return t.value;
+  throw t.status === "rejected" ? t.reason : (g(t), t);
+}), d = /* @__PURE__ */ new WeakMap(), _ = (t, o) => {
+  let s = d.get(t);
+  return s || (s = new Promise((r, n) => {
+    let l = t;
+    const a = (e) => (u) => {
+      l === e && r(u);
+    }, f = (e) => (u) => {
+      l === e && n(u);
+    }, c = () => {
+      try {
+        const e = o();
+        b(e) ? (d.set(e, s), l = e, e.then(a(e), f(e)), h(e, c)) : r(e);
+      } catch (e) {
+        n(e);
+      }
+    };
+    t.then(a(t), f(t)), h(t, c);
+  }), d.set(t, s)), s;
+};
+function k(t, o) {
+  const { delay: s, unstable_promiseStatus: r = !w.use } = {}, n = A(), [[l, a, f], c] = v(
+    (u) => {
+      const i = n.get(t);
+      return Object.is(u[0], i) && u[1] === n && u[2] === t ? u : [i, n, t];
+    },
+    void 0,
+    () => [n.get(t), n, t]
+  );
+  let e = l;
+  if ((a !== n || f !== t) && (c(), e = n.get(t)), R(() => {
+    const u = n.sub(t, () => {
+      if (r)
+        try {
+          const i = n.get(t);
+          b(i) && g(
+            _(i, () => n.get(t))
+          );
+        } catch {
+        }
+      if (typeof s == "number") {
+        setTimeout(c, s);
+        return;
+      }
+      c();
+    });
+    return c(), u;
+  }, [n, t, s, r]), S(e), b(e)) {
+    const u = _(e, () => n.get(t));
+    return r && g(u), j(u);
+  }
+  return e;
+}
+function E(t, o) {
+  const s = A();
+  return P(
+    (...n) => {
+      if ((F ? "production" : void 0) !== "production" && !("write" in t))
+        throw new Error("not writable atom");
+      return s.set(t, ...n);
+    },
+    [s, t]
+  );
+}
+function L(t, o) {
+  return [
+    k(t),
+    // We do wrong type assertion here, which results in throwing an error.
+    E(t)
+  ];
+}
+export {
+  k as a,
+  L as u
+};

package/dist/services/peer2peer/Incoming.d.ts

@@ -0,0 +1,13 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { default as PeerConnection, IConnectionIO } from './PeerConnection';
+import { PeerStatus } from './types';
+export default class Incoming extends EventEmitter<'connect' | 'close' | 'data'> implements IConnectionIO {
+    private _connection;
+    readonly direction: 'outgoing' | 'incoming';
+    private _status;
+    constructor(connection: PeerConnection);
+    get status(): PeerStatus;
+    private addHandlers;
+    get connection(): PeerConnection;
+    close(): void;
+}

package/dist/services/peer2peer/Incoming.js

@@ -0,0 +1,39 @@
+var s = Object.defineProperty;
+var i = (n, e, t) => e in n ? s(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var o = (n, e, t) => i(n, typeof e != "symbol" ? e + "" : e, t);
+import { E as c } from "../../index-SOhdqzHq.js";
+function r(n) {
+  return typeof n.event == "string";
+}
+class _ extends c {
+  constructor(t) {
+    super();
+    o(this, "_connection");
+    o(this, "direction", "incoming");
+    o(this, "_status", "connecting");
+    this._connection = t, this.addHandlers();
+  }
+  get status() {
+    return this._status;
+  }
+  addHandlers() {
+    this._connection.on("open", () => {
+      this._connection.send({ event: "eter:welcome" }), this._status = "ready", this.emit("connect", this._connection);
+    }), this._connection.on("data", async (t) => {
+      r(t) && this.emit("data", t, this._connection);
+    }), this._connection.on("error", (t) => {
+      console.error(t.type);
+    }), this._connection.on("close", () => {
+      this._connection.removeAllListeners(), this._connection.close(), this._status = "failed", this.emit("close");
+    });
+  }
+  get connection() {
+    return this._connection;
+  }
+  close() {
+    this._connection.removeAllListeners(), this._connection.close(), this._status = "failed", this.emit("close");
+  }
+}
+export {
+  _ as default
+};

package/dist/services/peer2peer/Outgoing.d.ts

@@ -0,0 +1,25 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { default as PeerConnection, IConnectionIO } from './PeerConnection';
+import { PeerStatus } from './types';
+interface OutgoingOptions {
+    retryDelay?: number;
+}
+export default class Outgoing extends EventEmitter<'connect' | 'retry' | 'close' | 'data'> implements IConnectionIO {
+    private _connection;
+    private timeout;
+    private retryCount;
+    private timeouts;
+    private options?;
+    readonly direction: 'outgoing' | 'incoming';
+    private connectionCount;
+    private _status;
+    constructor(connection: PeerConnection, options?: OutgoingOptions);
+    get status(): PeerStatus;
+    private delayedRecreate;
+    private recreate;
+    private addHandlers;
+    get connection(): PeerConnection;
+    /** Close and do not reconnect */
+    close(): void;
+}
+export {};

package/dist/services/peer2peer/Outgoing.js

@@ -0,0 +1,65 @@
+var s = Object.defineProperty;
+var c = (i, o, t) => o in i ? s(i, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[o] = t;
+var n = (i, o, t) => c(i, typeof o != "symbol" ? o + "" : o, t);
+import { E as r } from "../../index-SOhdqzHq.js";
+import h from "./PeerConnection.js";
+import { expBackoff as a } from "../../util/backoff.js";
+function u(i) {
+  return typeof i.event == "string";
+}
+class p extends r {
+  constructor(t, e) {
+    super();
+    n(this, "_connection");
+    n(this, "timeout", -1);
+    n(this, "retryCount", 0);
+    n(this, "timeouts", 0);
+    n(this, "options");
+    n(this, "direction", "outgoing");
+    n(this, "connectionCount", 0);
+    n(this, "_status", "connecting");
+    this._connection = t, this.options = e, this.addHandlers();
+  }
+  get status() {
+    return this._status;
+  }
+  delayedRecreate() {
+    var t;
+    this._status = "connecting", this.timeout >= 0 && clearTimeout(this.timeout), this.timeout = window.setTimeout(() => {
+      this.recreate();
+    }, ((t = this.options) == null ? void 0 : t.retryDelay) || a(this.retryCount++));
+  }
+  recreate(t = !1) {
+    this._status = "connecting";
+    const e = this._connection;
+    e.removeAllListeners(), e.close(), !e.peerInstance.destroyed && (this._connection = new h(
+      e.peer,
+      e.peerInstance,
+      !0,
+      t || e.connectionType === "server" ? void 0 : e.peerInstance.connect(e.peer, { reliable: !0 })
+    ), this.addHandlers());
+  }
+  addHandlers() {
+    this._connection.on("timeout", () => {
+      this.emit("retry"), this.timeouts += 1, this.recreate(this.timeouts > 1);
+    }), this._connection.on("open", () => {
+      this.retryCount = 0, this.timeouts = 0, this._connection.send({ event: "eter:join" }), this.connectionCount += 1, this._status = "ready", this.emit("connect", this._connection);
+    }), this._connection.on("data", async (t) => {
+      u(t) && this.emit("data", t, this._connection);
+    }), this._connection.on("error", (t) => {
+      console.error(t.type);
+    }), this._connection.on("close", (t, e) => {
+      e ? this.close() : (this.emit("retry"), this.delayedRecreate());
+    });
+  }
+  get connection() {
+    return this._connection;
+  }
+  /** Close and do not reconnect */
+  close() {
+    this.timeout >= 0 && clearTimeout(this.timeout), this._connection.removeAllListeners(), this._connection.close(), this._status = "failed", this.emit("close");
+  }
+}
+export {
+  p as default
+};

package/dist/services/peer2peer/Peer2Peer.d.ts

@@ -0,0 +1,80 @@
+import { CommunicationRelayConfiguration } from '../../components/ConnectionStatus/ice';
+import { Connection, PeerErrorType, PeerEvent, PeerStatus } from './types';
+import { IConnectionIO } from './PeerConnection';
+type P2PDataEvent<T extends PeerEvent> = {
+    data: [data: T, conn: Connection<T>];
+};
+type P2PStatusEvent = {
+    status: [status: PeerStatus];
+};
+type P2PQualityEvent = {
+    quality: [quality: number];
+};
+type P2PErrorEvent = {
+    error: [error: PeerErrorType];
+};
+type P2PConnectEvent<T extends PeerEvent> = {
+    connect: [conn: Connection<T>];
+};
+type P2PCloseEvent<T extends PeerEvent> = {
+    close: [conn: Connection<T>];
+};
+type P2POpenEvent = {
+    open: [];
+};
+type P2PRetryEvent = {
+    retry: [];
+};
+type P2PEvents<T extends PeerEvent> = P2PDataEvent<T> & P2PErrorEvent & P2PStatusEvent & P2PConnectEvent<T> & P2PCloseEvent<T> & P2POpenEvent & P2PRetryEvent & P2PQualityEvent;
+export interface P2POptions {
+    forceWebsocket?: boolean;
+    forceTURN?: boolean;
+    dropICE?: boolean;
+}
+export default class Peer2Peer<T extends PeerEvent> {
+    private emitter;
+    private peer;
+    private connections;
+    private heatbeatTimeout;
+    private retryTimeout;
+    status: PeerStatus;
+    private connRetryCount;
+    isRelay: boolean;
+    error: PeerErrorType;
+    private peerRetryCount;
+    private idRetryCount;
+    private server?;
+    private host;
+    private secure;
+    private port;
+    private key;
+    private ice;
+    private relay;
+    readonly code: string;
+    private _quality;
+    private options?;
+    boundSendAll: (typeof this)['sendAll'];
+    private failed;
+    constructor(code: string, host: string, secure: boolean, key: string, port: number, ice: CommunicationRelayConfiguration, relay: boolean, server?: string, options?: P2POptions);
+    get quality(): number;
+    get size(): number;
+    private update;
+    private emit;
+    on<TEventName extends keyof P2PEvents<T> & string>(eventName: TEventName, handler: (...eventArg: P2PEvents<T>[TEventName]) => void): void;
+    off<TEventName extends keyof P2PEvents<T> & string>(eventName: TEventName, handler: (...eventArg: P2PEvents<T>[TEventName]) => void): void;
+    private createPeerServer;
+    /** Completely restart the connection from scratch. */
+    reset(): void;
+    destroy(): void;
+    private setError;
+    private retryConnection;
+    /** Initiate a connection to a peer */
+    createPeer(code: string, useServer?: boolean): void;
+    private retry;
+    private onOpen;
+    getConnection(id: string): IConnectionIO | undefined;
+    private onConnection;
+    private onError;
+    sendAll(data: T, exclude?: string[]): void;
+}
+export {};