wapi-client 0.18.0-beta.2 → 0.18.0-beta.3

package/dist/api/ws-client.browser.js

@@ -0,0 +1,284 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/ws-client.ts
+import WebSocket from "../lib/ws-browser-shim.browser.js";
+import { debugLog } from "../lib/debug.browser.js";
+import {
+  AuthenticationError,
+  ConfigError,
+  ERROR_GROUPS
+} from "../lib/errors.browser.js";
+import { getConnectionParams, wait } from "../lib/utils.browser.js";
+import { BaseClient } from "./base-client.browser.js";
+import {
+  ConnectionStatus,
+  SocketStatuses
+} from "./connection/connection.enums.browser.js";
+import { WapiClientType } from "../wapi-client.browser.js";
+import { CLIENT_VERSION, getEnvConfig } from "../lib/env.browser.js";
+function createWsClient(opts, config) {
+  const initialConnection = createConnection(opts, {
+    timeout: config == null ? void 0 : config.connectingTimeout,
+    connectionName: config == null ? void 0 : config.connectionName
+  });
+  return new WsClient(initialConnection, opts, config);
+}
+function createConnection(opts, connectionConfig) {
+  var _a;
+  const config = __spreadValues({
+    rejectUnauthorized: (_a = opts.rejectUnauthorized) != null ? _a : true,
+    connectionName: connectionConfig == null ? void 0 : connectionConfig.connectionName,
+    clientVersion: CLIENT_VERSION
+  }, opts);
+  const params = getConnectionParams(config);
+  const ws = new WebSocket(...params);
+  let _resolve;
+  let _reject;
+  let isCleaned = false;
+  let initialMessage = false;
+  let _id;
+  ws.onclose = close;
+  ws.onerror = error;
+  ws.onmessage = message;
+  function close(event) {
+    debugLog(
+      `createConnection>close(reason:${event.reason},code:${event.code},wasClean:${event.wasClean})`
+    );
+    if (event.code === SocketStatuses.authError) {
+      return clean(new AuthenticationError());
+    }
+    clean(new Error("WS closed"));
+  }
+  function error(event) {
+    debugLog(
+      `createConnection>error(message:${event.message},error:${event.error},type:${event.type})`
+    );
+    clean(event.error);
+  }
+  function message(event) {
+    debugLog(`createConnection>message(type:${event.type},data:${event.data})`);
+    initialMessage = true;
+    const { data } = event;
+    let obj;
+    try {
+      obj = JSON.parse(data.toString());
+    } catch (e) {
+      debugLog("Invalid JSON response", e);
+      return clean(new Error("Invalid JSON response"));
+    }
+    if (obj.result !== ConnectionStatus.ready) {
+      debugLog("Invalid first message");
+      return clean(new Error("Invalid first message - " + JSON.stringify(obj)));
+    }
+    clean();
+  }
+  debugLog(
+    `createConnection>(message:setting up ws connection${(connectionConfig == null ? void 0 : connectionConfig.timeout) ? " with timeout " + connectionConfig.timeout : ""})`
+  );
+  const connectingTimeout = (connectionConfig == null ? void 0 : connectionConfig.timeout) ? setTimeout(() => {
+    clean(
+      new ConfigError("CONNECTION_TIMEOUT", {
+        timeout: connectionConfig.timeout
+      })
+    );
+  }, connectionConfig.timeout) : void 0;
+  function clean(err) {
+    if (isCleaned) {
+      return;
+    }
+    clearTimeout(connectingTimeout);
+    ws.onmessage = () => {
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = () => {
+    };
+    if (err) {
+      _reject(err);
+      if (initialMessage || "_sender" in ws && Boolean(ws._sender)) {
+        ws.close();
+      }
+    } else {
+      _resolve(_id);
+    }
+    isCleaned = true;
+  }
+  const $connect = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    ws,
+    $connect
+  };
+}
+var WsClient = class extends BaseClient {
+  constructor(initial, opts, config) {
+    var _a;
+    super(initial.ws, WapiClientType.ws, initial.$connect);
+    __publicField(this, "_pingTimeout");
+    __publicField(this, "_opts");
+    __publicField(this, "_connectionConfig");
+    __publicField(this, "_tryToReconnect", true);
+    this._opts = opts;
+    this._connectionConfig = config;
+    this.host = opts.host;
+    (_a = this.$connect) == null ? void 0 : _a.then((_id) => {
+      this.socId = _id;
+      return this._ready();
+    }).catch((err) => {
+      if (this.socId) {
+        return;
+      }
+      this._setErrored(err);
+    });
+  }
+  _setErrored(err) {
+    super._setErrored(err);
+    if (err instanceof AuthenticationError || "code" in err && err.code === ERROR_GROUPS.AUTH.ERRORS.AUTHENTICATION_ERROR.code) {
+      this._tryToReconnect = false;
+    }
+  }
+  _ready() {
+    this._setConnected(true);
+    this._connection.onmessage = (event) => {
+      const { data, type } = event;
+      debugLog(`message(type:${type},data:$0)`, data);
+      if (type === "message") {
+        const obj = JSON.parse(data.toString());
+        this._handleMessage(obj);
+        this._heartbeat();
+      }
+    };
+    this._connection.onerror = (event) => {
+      const { message, error, type } = event;
+      debugLog(`error(message:$0,error:$1,type:${type})`, message, error);
+    };
+    this._connection.onclose = (event) => {
+      const { reason, code, wasClean } = event;
+      debugLog(`close(reason:$0,code:${code},wasClean:${wasClean})`, reason);
+      this._setConnected(false);
+      clearTimeout(this._pingTimeout);
+      this._connectionLost();
+      this._reconnect();
+    };
+    this._heartbeat();
+  }
+  _reconnect(nrOfAttempts) {
+    debugLog("reconnect(),tryToReconnect:", this._tryToReconnect);
+    if (!this._tryToReconnect) {
+      return;
+    }
+    if (this.hooks.reconnect && this.hooks.reconnect() === false) {
+      debugLog("reconnect hook returned false");
+      return;
+    }
+    if (this.$connect) {
+      debugLog("already connecting");
+      return;
+    }
+    super._clearError();
+    nrOfAttempts = Math.min(
+      nrOfAttempts != null ? nrOfAttempts : 10,
+      getEnvConfig("WAPI_RECONNECT_ATTEMPTS", 10)
+    );
+    const maxWaitTime = getEnvConfig("WAPI_MAX_RECONNECT_WAIT", 1e4);
+    debugLog(
+      `Start connection. Max attempts: ${nrOfAttempts}; Max wait: ${maxWaitTime}`
+    );
+    this.$connect = (() => __async(this, null, function* () {
+      var _a, _b, _c;
+      let _id;
+      for (let i = 0; i < nrOfAttempts + 1; i++) {
+        try {
+          debugLog("Trying to connect, attempt:", i);
+          const { ws, $connect } = createConnection(this._opts, {
+            timeout: (_a = this._connectionConfig) == null ? void 0 : _a.reconnectingTimeout
+          });
+          _id = yield $connect;
+          this.socId = _id;
+          this._connection = ws;
+          this._ready();
+          break;
+        } catch (err) {
+          const isAuthError = err && typeof err === "object" && "code" in err && err.code === ERROR_GROUPS.AUTH.ERRORS.AUTHENTICATION_ERROR.code;
+          const outOfAttempts = i > nrOfAttempts - 1;
+          if (isAuthError || outOfAttempts) {
+            this._setErrored(err);
+            (_c = (_b = this.hooks).reconnectError) == null ? void 0 : _c.call(_b, err);
+            break;
+          }
+          yield wait(Math.min(Math.pow(1.5, i) * 1e3, maxWaitTime));
+        }
+      }
+      return _id;
+    }))();
+  }
+  _heartbeat() {
+    debugLog("heartbeat");
+    clearTimeout(this._pingTimeout);
+    this._pingTimeout = setTimeout(() => {
+      if (this._sending.size) {
+        debugLog("pingTimeout reached, but sending.size:", this._sending.size);
+        return this._heartbeat();
+      }
+      debugLog("timeout");
+      this._connection.close();
+      this._setConnected(false);
+      this._reconnect();
+    }, 31e3);
+  }
+  _send(input) {
+    debugLog("send()", input);
+    this._connection.send(JSON.stringify(input));
+  }
+  close() {
+    return __async(this, null, function* () {
+      debugLog("close()");
+      this._tryToReconnect = false;
+      clearTimeout(this._pingTimeout);
+      this._setConnected(false);
+      return this._connection.close();
+    });
+  }
+};
+export {
+  WsClient,
+  createWsClient
+};

package/dist/api/ws-client.cjs

@@ -0,0 +1,310 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/ws-client.ts
+var ws_client_exports = {};
+__export(ws_client_exports, {
+  WsClient: () => WsClient,
+  createWsClient: () => createWsClient
+});
+module.exports = __toCommonJS(ws_client_exports);
+var import_ws = __toESM(require("ws"), 1);
+var import_debug = require("../lib/debug.cjs");
+var import_errors = require("../lib/errors.cjs");
+var import_utils = require("../lib/utils.cjs");
+var import_base_client = require("./base-client.cjs");
+var import_connection_enums = require("./connection/connection.enums.cjs");
+var import_wapi_client = require("../wapi-client.cjs");
+var import_env = require("../lib/env.cjs");
+function createWsClient(opts, config) {
+  const initialConnection = createConnection(opts, {
+    timeout: config == null ? void 0 : config.connectingTimeout,
+    connectionName: config == null ? void 0 : config.connectionName
+  });
+  return new WsClient(initialConnection, opts, config);
+}
+function createConnection(opts, connectionConfig) {
+  var _a;
+  const config = __spreadValues({
+    rejectUnauthorized: (_a = opts.rejectUnauthorized) != null ? _a : true,
+    connectionName: connectionConfig == null ? void 0 : connectionConfig.connectionName,
+    clientVersion: import_env.CLIENT_VERSION
+  }, opts);
+  const params = (0, import_utils.getConnectionParams)(config);
+  const ws = new import_ws.default(...params);
+  let _resolve;
+  let _reject;
+  let isCleaned = false;
+  let initialMessage = false;
+  let _id;
+  ws.onclose = close;
+  ws.onerror = error;
+  ws.onmessage = message;
+  function close(event) {
+    (0, import_debug.debugLog)(
+      `createConnection>close(reason:${event.reason},code:${event.code},wasClean:${event.wasClean})`
+    );
+    if (event.code === import_connection_enums.SocketStatuses.authError) {
+      return clean(new import_errors.AuthenticationError());
+    }
+    clean(new Error("WS closed"));
+  }
+  function error(event) {
+    (0, import_debug.debugLog)(
+      `createConnection>error(message:${event.message},error:${event.error},type:${event.type})`
+    );
+    clean(event.error);
+  }
+  function message(event) {
+    (0, import_debug.debugLog)(`createConnection>message(type:${event.type},data:${event.data})`);
+    initialMessage = true;
+    const { data } = event;
+    let obj;
+    try {
+      obj = JSON.parse(data.toString());
+    } catch (e) {
+      (0, import_debug.debugLog)("Invalid JSON response", e);
+      return clean(new Error("Invalid JSON response"));
+    }
+    if (obj.result !== import_connection_enums.ConnectionStatus.ready) {
+      (0, import_debug.debugLog)("Invalid first message");
+      return clean(new Error("Invalid first message - " + JSON.stringify(obj)));
+    }
+    clean();
+  }
+  (0, import_debug.debugLog)(
+    `createConnection>(message:setting up ws connection${(connectionConfig == null ? void 0 : connectionConfig.timeout) ? " with timeout " + connectionConfig.timeout : ""})`
+  );
+  const connectingTimeout = (connectionConfig == null ? void 0 : connectionConfig.timeout) ? setTimeout(() => {
+    clean(
+      new import_errors.ConfigError("CONNECTION_TIMEOUT", {
+        timeout: connectionConfig.timeout
+      })
+    );
+  }, connectionConfig.timeout) : void 0;
+  function clean(err) {
+    if (isCleaned) {
+      return;
+    }
+    clearTimeout(connectingTimeout);
+    ws.onmessage = () => {
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = () => {
+    };
+    if (err) {
+      _reject(err);
+      if (initialMessage || "_sender" in ws && Boolean(ws._sender)) {
+        ws.close();
+      }
+    } else {
+      _resolve(_id);
+    }
+    isCleaned = true;
+  }
+  const $connect = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    ws,
+    $connect
+  };
+}
+var WsClient = class extends import_base_client.BaseClient {
+  constructor(initial, opts, config) {
+    var _a;
+    super(initial.ws, import_wapi_client.WapiClientType.ws, initial.$connect);
+    __publicField(this, "_pingTimeout");
+    __publicField(this, "_opts");
+    __publicField(this, "_connectionConfig");
+    __publicField(this, "_tryToReconnect", true);
+    this._opts = opts;
+    this._connectionConfig = config;
+    this.host = opts.host;
+    (_a = this.$connect) == null ? void 0 : _a.then((_id) => {
+      this.socId = _id;
+      return this._ready();
+    }).catch((err) => {
+      if (this.socId) {
+        return;
+      }
+      this._setErrored(err);
+    });
+  }
+  _setErrored(err) {
+    super._setErrored(err);
+    if (err instanceof import_errors.AuthenticationError || "code" in err && err.code === import_errors.ERROR_GROUPS.AUTH.ERRORS.AUTHENTICATION_ERROR.code) {
+      this._tryToReconnect = false;
+    }
+  }
+  _ready() {
+    this._setConnected(true);
+    this._connection.onmessage = (event) => {
+      const { data, type } = event;
+      (0, import_debug.debugLog)(`message(type:${type},data:$0)`, data);
+      if (type === "message") {
+        const obj = JSON.parse(data.toString());
+        this._handleMessage(obj);
+        this._heartbeat();
+      }
+    };
+    this._connection.onerror = (event) => {
+      const { message, error, type } = event;
+      (0, import_debug.debugLog)(`error(message:$0,error:$1,type:${type})`, message, error);
+    };
+    this._connection.onclose = (event) => {
+      const { reason, code, wasClean } = event;
+      (0, import_debug.debugLog)(`close(reason:$0,code:${code},wasClean:${wasClean})`, reason);
+      this._setConnected(false);
+      clearTimeout(this._pingTimeout);
+      this._connectionLost();
+      this._reconnect();
+    };
+    this._heartbeat();
+  }
+  _reconnect(nrOfAttempts) {
+    (0, import_debug.debugLog)("reconnect(),tryToReconnect:", this._tryToReconnect);
+    if (!this._tryToReconnect) {
+      return;
+    }
+    if (this.hooks.reconnect && this.hooks.reconnect() === false) {
+      (0, import_debug.debugLog)("reconnect hook returned false");
+      return;
+    }
+    if (this.$connect) {
+      (0, import_debug.debugLog)("already connecting");
+      return;
+    }
+    super._clearError();
+    nrOfAttempts = Math.min(
+      nrOfAttempts != null ? nrOfAttempts : 10,
+      (0, import_env.getEnvConfig)("WAPI_RECONNECT_ATTEMPTS", 10)
+    );
+    const maxWaitTime = (0, import_env.getEnvConfig)("WAPI_MAX_RECONNECT_WAIT", 1e4);
+    (0, import_debug.debugLog)(
+      `Start connection. Max attempts: ${nrOfAttempts}; Max wait: ${maxWaitTime}`
+    );
+    this.$connect = (() => __async(this, null, function* () {
+      var _a, _b, _c;
+      let _id;
+      for (let i = 0; i < nrOfAttempts + 1; i++) {
+        try {
+          (0, import_debug.debugLog)("Trying to connect, attempt:", i);
+          const { ws, $connect } = createConnection(this._opts, {
+            timeout: (_a = this._connectionConfig) == null ? void 0 : _a.reconnectingTimeout
+          });
+          _id = yield $connect;
+          this.socId = _id;
+          this._connection = ws;
+          this._ready();
+          break;
+        } catch (err) {
+          const isAuthError = err && typeof err === "object" && "code" in err && err.code === import_errors.ERROR_GROUPS.AUTH.ERRORS.AUTHENTICATION_ERROR.code;
+          const outOfAttempts = i > nrOfAttempts - 1;
+          if (isAuthError || outOfAttempts) {
+            this._setErrored(err);
+            (_c = (_b = this.hooks).reconnectError) == null ? void 0 : _c.call(_b, err);
+            break;
+          }
+          yield (0, import_utils.wait)(Math.min(Math.pow(1.5, i) * 1e3, maxWaitTime));
+        }
+      }
+      return _id;
+    }))();
+  }
+  _heartbeat() {
+    (0, import_debug.debugLog)("heartbeat");
+    clearTimeout(this._pingTimeout);
+    this._pingTimeout = setTimeout(() => {
+      if (this._sending.size) {
+        (0, import_debug.debugLog)("pingTimeout reached, but sending.size:", this._sending.size);
+        return this._heartbeat();
+      }
+      (0, import_debug.debugLog)("timeout");
+      this._connection.close();
+      this._setConnected(false);
+      this._reconnect();
+    }, 31e3);
+  }
+  _send(input) {
+    (0, import_debug.debugLog)("send()", input);
+    this._connection.send(JSON.stringify(input));
+  }
+  close() {
+    return __async(this, null, function* () {
+      (0, import_debug.debugLog)("close()");
+      this._tryToReconnect = false;
+      clearTimeout(this._pingTimeout);
+      this._setConnected(false);
+      return this._connection.close();
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WsClient,
+  createWsClient
+});

package/dist/client-options.schema.zod.browser.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client-options.schema.zod.ts
+var client_options_schema_zod_exports = {};
+__export(client_options_schema_zod_exports, {
+  clientOptionsSchema: () => clientOptionsSchema,
+  clientTypeSchema: () => clientTypeSchema,
+  connectionSchema: () => connectionSchema,
+  credsConnectionSchema: () => credsConnectionSchema,
+  jwtConnectionSchema: () => jwtConnectionSchema
+});
+module.exports = __toCommonJS(client_options_schema_zod_exports);
+var import_zod = require("./lib/zod.browser.cjs");
+var clientTypeSchema = import_zod.z.enum(["ws", "https"]);
+var credsConnectionSchema = import_zod.z.looseObject({
+  host: import_zod.z.string().describe("URL of the API"),
+  apikey: import_zod.z.string().describe("API key for the client"),
+  apisecret: import_zod.z.string().describe("API secret for the client")
+});
+var jwtConnectionSchema = import_zod.z.looseObject({
+  host: import_zod.z.string().describe("URL of the API"),
+  jwt: import_zod.z.string().describe("Auth token for calling api")
+});
+var connectionSchema = import_zod.z.union([
+  jwtConnectionSchema,
+  credsConnectionSchema
+]);
+var clientOptionsSchema = import_zod.z.object({
+  client: clientTypeSchema,
+  connection: connectionSchema
+});

package/dist/client-options.schema.zod.browser.js

@@ -0,0 +1,27 @@
+// src/client-options.schema.zod.ts
+import { z } from "./lib/zod.browser.js";
+var clientTypeSchema = z.enum(["ws", "https"]);
+var credsConnectionSchema = z.looseObject({
+  host: z.string().describe("URL of the API"),
+  apikey: z.string().describe("API key for the client"),
+  apisecret: z.string().describe("API secret for the client")
+});
+var jwtConnectionSchema = z.looseObject({
+  host: z.string().describe("URL of the API"),
+  jwt: z.string().describe("Auth token for calling api")
+});
+var connectionSchema = z.union([
+  jwtConnectionSchema,
+  credsConnectionSchema
+]);
+var clientOptionsSchema = z.object({
+  client: clientTypeSchema,
+  connection: connectionSchema
+});
+export {
+  clientOptionsSchema,
+  clientTypeSchema,
+  connectionSchema,
+  credsConnectionSchema,
+  jwtConnectionSchema
+};