visualvault-api 1.1.0 → 2.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,2563 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// lib/http/sessionToken.js
+var SessionToken;
+var init_sessionToken = __esm({
+  "lib/http/sessionToken.js"() {
+    init_esm_shims();
+    SessionToken = class _SessionToken {
+      constructor() {
+        this.isAuthenticated = false;
+        this.apiUrl = null;
+        this.baseUrl = null;
+        this.authenticationUrl = null;
+        this.customerAlias = null;
+        this.databaseAlias = null;
+        this.expirationDate = null;
+        this.accessToken = null;
+        this.tokenType = null;
+        this.refreshToken = null;
+        this.expiresIn = 0;
+        this.clientId = null;
+        this.clientSecret = null;
+        this.userId = null;
+        this.password = null;
+        this.audience = null;
+      }
+      createCopy() {
+        const newSession = new _SessionToken();
+        newSession.isAuthenticated = this.isAuthenticated;
+        newSession.apiUrl = this.apiUrl;
+        newSession.baseUrl = this.baseUrl;
+        newSession.authenticationUrl = this.authenticationUrl;
+        newSession.customerAlias = this.customerAlias;
+        newSession.databaseAlias = this.databaseAlias;
+        newSession.expirationDate = this.expirationDate;
+        newSession.accessToken = this.accessToken;
+        newSession.tokenType = this.tokenType;
+        newSession.refreshToken = this.refreshToken;
+        newSession.expiresIn = this.expiresIn;
+        newSession.clientId = this.clientId;
+        newSession.clientSecret = this.clientSecret;
+        newSession.userId = this.userId;
+        newSession.password = this.password;
+        newSession.audience = this.audience;
+        return newSession;
+      }
+      convertToJwt(jwt) {
+        this.tokenType = "jwt";
+        this.accessToken = jwt["token"];
+        this.expirationDate = new Date(jwt["expires"]);
+        this.expiresIn = 0;
+      }
+    };
+  }
+});
+
+// lib/http/authorize.js
+var authorize_exports = {};
+__export(authorize_exports, {
+  Authorize: () => Authorize,
+  default: () => authorize_default
+});
+import createDebug from "debug";
+import yaml from "js-yaml";
+import fs from "fs";
+var debug, Authorize, authorize_default;
+var init_authorize = __esm({
+  "lib/http/authorize.js"() {
+    init_esm_shims();
+    init_sessionToken();
+    debug = createDebug("visualvault:auth");
+    Authorize = class {
+      constructor() {
+        this.jsyaml = yaml;
+        this.fs = fs;
+      }
+      async acquireSecurityToken(clientId, clientSecret, userId, password, audience, baseUrl, apiUrl, customerAlias, databaseAlias, authenticationUrl) {
+        debug("acquireSecurityToken called for user: %s", userId);
+        try {
+          const sessionToken = await this.__getToken(
+            clientId,
+            clientSecret,
+            userId,
+            password,
+            audience,
+            baseUrl,
+            customerAlias,
+            databaseAlias,
+            authenticationUrl,
+            true
+          );
+          debug("acquireSecurityToken success");
+          if (typeof sessionToken != "undefined" && sessionToken != null) {
+            sessionToken.baseUrl = baseUrl;
+            sessionToken.apiUrl = apiUrl;
+            sessionToken.authenticationUrl = authenticationUrl;
+            sessionToken.customerAlias = customerAlias;
+            sessionToken.databaseAlias = databaseAlias;
+            sessionToken.clientId = clientId;
+            sessionToken.clientSecret = clientSecret;
+            sessionToken.userId = userId;
+            sessionToken.password = password;
+            sessionToken.audience = audience;
+            sessionToken.isAuthenticated = true;
+          }
+          return sessionToken;
+        } catch (error) {
+          debug("acquireSecurityToken failed: %s", error.message);
+          throw error;
+        }
+      }
+      async acquireJwt(jwt, baseUrl, apiUrl, authenticationUrl, customerAlias, databaseAlias) {
+        debug("acquireJwt called");
+        try {
+          const sessionToken = await this.__getJwt(
+            jwt,
+            baseUrl,
+            customerAlias,
+            databaseAlias,
+            authenticationUrl,
+            true
+          );
+          debug("acquireJwt success");
+          if (typeof sessionToken != "undefined" && sessionToken != null) {
+            sessionToken.baseUrl = baseUrl;
+            sessionToken.apiUrl = apiUrl;
+            sessionToken.authenticationUrl = authenticationUrl;
+            sessionToken.customerAlias = customerAlias;
+            sessionToken.databaseAlias = databaseAlias;
+            sessionToken.isAuthenticated = true;
+            sessionToken.isJwt = true;
+          }
+          return sessionToken;
+        } catch (error) {
+          debug("acquireJwt failed: %s", error.message);
+          throw error;
+        }
+      }
+      async reacquireSecurityToken(sessionToken) {
+        debug("reacquireSecurityToken called (isJwt: %s)", sessionToken.isJwt);
+        try {
+          if (sessionToken.isJwt) {
+            const newToken = await this.__getJwt(
+              sessionToken.accessToken,
+              sessionToken.baseUrl,
+              sessionToken.customerAlias,
+              sessionToken.databaseAlias,
+              sessionToken.authenticationUrl,
+              true
+            );
+            debug("reacquireSecurityToken success (JWT)");
+            return newToken;
+          } else {
+            const newToken = await this.__getToken(
+              sessionToken.clientId,
+              sessionToken.clientSecret,
+              sessionToken.userId,
+              sessionToken.password,
+              sessionToken.audience,
+              sessionToken.baseUrl,
+              sessionToken.customerAlias,
+              sessionToken.databaseAlias,
+              sessionToken.authenticationUrl,
+              true
+            );
+            debug("reacquireSecurityToken success (password grant)");
+            return newToken;
+          }
+        } catch (error) {
+          debug("reacquireSecurityToken failed: %s", error.message);
+          throw error;
+        }
+      }
+      async acquireRefreshToken(sessionToken) {
+        if (sessionToken.isJwt) {
+          return await this.reacquireSecurityToken(sessionToken);
+        }
+        const claim = {
+          grant_type: "refresh_token",
+          refresh_token: sessionToken.refreshToken,
+          client_id: sessionToken.clientId,
+          client_secret: sessionToken.clientSecret
+        };
+        if (sessionToken["audience"]) {
+          claim["audience"] = sessionToken["audience"];
+        }
+        const urlSecurity = sessionToken.baseUrl + sessionToken.authenticationUrl;
+        debug("acquireRefreshToken - URL: %s", urlSecurity);
+        try {
+          const response = await fetch(urlSecurity, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams(claim)
+          });
+          const body = await response.text();
+          if (response.status === 200) {
+            debug("acquireRefreshToken success");
+            const responseObject = JSON.parse(body);
+            sessionToken.accessToken = responseObject.access_token;
+            sessionToken.expiresIn = responseObject.expires_in;
+            sessionToken.refreshToken = responseObject.refresh_token;
+            sessionToken.tokenType = responseObject.token_type;
+            const expireDate = /* @__PURE__ */ new Date();
+            expireDate.setSeconds(expireDate.getSeconds() + sessionToken.expiresIn);
+            sessionToken.expirationDate = expireDate;
+            sessionToken.isAuthenticated = true;
+            return sessionToken;
+          } else if (response.status === 401 || response.status === 403 || response.status === 400) {
+            sessionToken.isAuthenticated = false;
+            throw new Error(`Authorization has been refused for current credentials (HTTP ${response.status}): ${body.substring(0, 200)}`);
+          } else {
+            sessionToken.isAuthenticated = false;
+            throw new Error(`Unknown response for access token: HTTP ${response.status}`);
+          }
+        } catch (error) {
+          sessionToken.isAuthenticated = false;
+          debug("acquireRefreshToken error: %s", error.message);
+          throw error;
+        }
+      }
+      async __getToken(clientId, clientSecret, userId, password, audience, baseUrl, customerAlias, databaseAlias, authenticationUrl) {
+        const sessionToken = new SessionToken();
+        const claim = {
+          grant_type: "password",
+          client_id: clientId,
+          client_secret: clientSecret,
+          username: userId,
+          password,
+          scope: "vault"
+        };
+        const urlSecurity = baseUrl + authenticationUrl;
+        debug("__getToken - URL: %s, user: %s, customer: %s/%s, audience: %s", urlSecurity, userId, customerAlias, databaseAlias, audience);
+        try {
+          const response = await fetch(urlSecurity, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams(claim)
+          });
+          const body = await response.text();
+          if (response.status === 200) {
+            const responseObject = JSON.parse(body);
+            sessionToken.accessToken = responseObject.access_token;
+            sessionToken.expiresIn = responseObject.expires_in;
+            sessionToken.refreshToken = responseObject.refresh_token;
+            sessionToken.tokenType = responseObject.token_type;
+            const expireDate = /* @__PURE__ */ new Date();
+            expireDate.setSeconds(expireDate.getSeconds() + sessionToken.expiresIn);
+            sessionToken.expirationDate = expireDate;
+            sessionToken.isAuthenticated = true;
+            debug("__getToken success");
+            return sessionToken;
+          } else if (response.status === 401 || response.status === 403 || response.status === 400) {
+            sessionToken.isAuthenticated = false;
+            throw new Error(`Authorization has been refused for current credentials (HTTP ${response.status}): ${body.substring(0, 200)}`);
+          } else {
+            sessionToken.isAuthenticated = false;
+            throw new Error(`Unknown response for access token: HTTP ${response.status}`);
+          }
+        } catch (error) {
+          sessionToken.isAuthenticated = false;
+          debug("__getToken error: %s", error.message);
+          throw error;
+        }
+      }
+      async __getJwt(jwt, baseUrl, customerAlias, databaseAlias, authenticationUrl) {
+        const sessionToken = new SessionToken();
+        const headers = {
+          Authorization: "Bearer " + jwt
+        };
+        const urlSecurity = baseUrl + authenticationUrl;
+        debug("__getJwt - URL: %s, customer: %s/%s", urlSecurity, customerAlias, databaseAlias);
+        try {
+          const response = await fetch(urlSecurity, {
+            method: "GET",
+            headers
+          });
+          const body = await response.text();
+          if (response.status === 200) {
+            const responseObject = JSON.parse(body);
+            sessionToken.accessToken = responseObject.data.token;
+            sessionToken.expirationDate = new Date(responseObject.data.expires);
+            sessionToken.isAuthenticated = true;
+            sessionToken.isJwt = true;
+            debug("__getJwt success");
+            return sessionToken;
+          } else if (response.status === 401 || response.status === 403 || response.status === 400) {
+            sessionToken.isAuthenticated = false;
+            throw new Error(`Authorization has been refused for current credentials (HTTP ${response.status}): ${body.substring(0, 200)}`);
+          } else {
+            sessionToken.isAuthenticated = false;
+            throw new Error(`Unknown response for JWT: HTTP ${response.status}`);
+          }
+        } catch (error) {
+          sessionToken.isAuthenticated = false;
+          debug("__getJwt error: %s", error.message);
+          throw error;
+        }
+      }
+      endsWith(source, suffix) {
+        return source.indexOf(suffix, source.length - suffix.length) !== -1;
+      }
+    };
+    authorize_default = Authorize;
+  }
+});
+
+// lib/index.js
+init_esm_shims();
+
+// lib/VVRestApi.js
+init_esm_shims();
+
+// lib/DocApi.js
+init_esm_shims();
+
+// lib/common.js
+init_esm_shims();
+
+// lib/http/httpHelper.js
+init_esm_shims();
+import createDebug2 from "debug";
+var debug2 = createDebug2("visualvault:http");
+var HttpHelper = class {
+  constructor(sessionToken, yamlConfig) {
+    this._sessionToken = sessionToken;
+    this._config = yamlConfig;
+    this._maxRetries = 3;
+  }
+  async doVvClientRequest(url, options, params, data, buffer) {
+    if (this._sessionToken.expirationDate < new Date((/* @__PURE__ */ new Date()).getTime() + 30 * 1e3)) {
+      debug2("accessToken has expired, calling __acquireRefreshToken");
+      try {
+        await this.__acquireRefreshToken();
+        debug2("return success from __acquireRefreshToken");
+        return await this.__doVvClientCallRequest(url, options, params, data, buffer);
+      } catch (error) {
+        debug2("return fail from __acquireRefreshToken: %s", error.message);
+        throw new Error("Unable to obtain Authorization, error: " + error);
+      }
+    } else {
+      return await this.__doVvClientCallRequest(url, options, params, data, buffer);
+    }
+  }
+  async __doVvClientCallRequest(url, options, params, data, buffer, retries = 0) {
+    try {
+      let responseData;
+      if (options.method === "GET") {
+        responseData = await this.httpGet(url, params);
+      } else if (options.method === "GETSTREAM") {
+        responseData = await this.httpGetStream(url, params);
+      } else if (options.method === "POST") {
+        responseData = await this.httpPost(url, params, data);
+      } else if (options.method === "POSTSTREAM") {
+        responseData = await this.httpPostStream(url, params, data, buffer);
+      } else if (options.method === "PUT") {
+        responseData = await this.httpPut(url, params, data);
+      } else if (options.method === "PUTSTREAM") {
+        responseData = await this.httpPutStream(url, params, data, buffer);
+      } else if (options.method === "DELETE") {
+        responseData = await this.httpDelete(url, params);
+      } else {
+        throw new Error("http request method name error");
+      }
+      return responseData;
+    } catch (error) {
+      if (error.status === 429 && retries < this._maxRetries) {
+        const timeout = this.__getRetryDelay(error.retryTime);
+        debug2("Timed Out: Retrying in %d ms. (%d retries left)", timeout, this._maxRetries - retries - 1);
+        await new Promise((resolve) => setTimeout(resolve, timeout));
+        return await this.__doVvClientCallRequest(url, options, params, data, buffer, retries + 1);
+      }
+      throw error;
+    }
+  }
+  async __makeRequest(url, options) {
+    const headers = {
+      "Authorization": "Bearer " + this._sessionToken.accessToken,
+      "Content-Type": "application/json"
+    };
+    debug2("Performing request to url: %s", url);
+    const fetchOptions = {
+      method: options.method,
+      headers: { ...headers, ...options.headers }
+    };
+    if (options.qs && Object.keys(options.qs).length > 0) {
+      const queryString = new URLSearchParams(options.qs).toString();
+      url = `${url}?${queryString}`;
+    }
+    if (options.json && (options.method === "POST" || options.method === "PUT")) {
+      fetchOptions.body = JSON.stringify(options.json);
+    }
+    const response = await fetch(url, fetchOptions);
+    const responseText = await response.text();
+    if (!response.ok) {
+      let parsedData;
+      try {
+        parsedData = JSON.parse(responseText);
+      } catch (e) {
+        parsedData = { meta: responseText };
+      }
+      if (response.status === 401 || response.status === 403) {
+        this._sessionToken.isAuthenticated = false;
+        throw new Error(JSON.stringify(parsedData.meta));
+      } else if (response.status === 429) {
+        const error = new Error(JSON.stringify(parsedData.meta));
+        error.status = 429;
+        error.retryTime = parsedData.meta?.retryTime;
+        throw error;
+      } else {
+        throw new Error(responseText);
+      }
+    }
+    return responseText;
+  }
+  async __makePostStreamRequest(url, options, buffer) {
+    debug2("Performing stream request to url: %s", url);
+    const formData = new FormData();
+    if (options.json) {
+      for (const key in options.json) {
+        if (options.json.hasOwnProperty(key)) {
+          formData.append(key, options.json[key]);
+        }
+      }
+    }
+    if (Buffer.isBuffer(buffer)) {
+      const filename = options.json?.fileName || "file";
+      const blob = new Blob([buffer]);
+      formData.append("fileUpload", blob, filename);
+    } else if (Array.isArray(buffer)) {
+      for (let i = 0; i < buffer.length; i++) {
+        const fileInfoObj = buffer[i];
+        if (Buffer.isBuffer(fileInfoObj.buffer)) {
+          const fileName = fileInfoObj.fileName || `file${i}`;
+          const blob = new Blob([fileInfoObj.buffer]);
+          formData.append("fileUpload", blob, fileName);
+        } else {
+          throw new Error(`Invalid 'buffer' property found on fileObj at index ${i}`);
+        }
+      }
+    } else {
+      throw new Error("Expecting Buffer");
+    }
+    const headers = {
+      "Authorization": "Bearer " + this._sessionToken.accessToken
+    };
+    const response = await fetch(url, {
+      method: options.method,
+      headers,
+      body: formData
+    });
+    const responseText = await response.text();
+    if (!response.ok) {
+      throw new Error(responseText);
+    }
+    return responseText;
+  }
+  async httpGet(url, params) {
+    const options = { method: "GET", qs: params || {}, headers: {}, json: null };
+    if (this._sessionToken.accessToken == null) {
+      throw new Error("Access token is null");
+    }
+    return await this.__makeRequest(url, options);
+  }
+  async httpGetStream(url, params) {
+    if (this._sessionToken.accessToken == null) {
+      throw new Error("Access token is null");
+    }
+    const headers = {
+      "Authorization": "Bearer " + this._sessionToken.accessToken,
+      "Content-Type": "application/json; charset=utf-8"
+    };
+    if (params && Object.keys(params).length > 0) {
+      const queryString = new URLSearchParams(params).toString();
+      url = `${url}?${queryString}`;
+    }
+    const response = await fetch(url, { method: "GET", headers });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return Buffer.from(buffer);
+  }
+  async httpPost(url, params, data) {
+    const options = { method: "POST", qs: params || {}, json: data, headers: {} };
+    if (this._sessionToken.accessToken == null) {
+      throw new Error("Access token is null");
+    }
+    return await this.__makeRequest(url, options);
+  }
+  async httpPostStream(url, params, data, buffer) {
+    const options = { method: "POST", qs: params || {}, json: data, headers: {} };
+    if (this._sessionToken.accessToken == null) {
+      throw new Error("Access token is null");
+    }
+    return await this.__makePostStreamRequest(url, options, buffer);
+  }
+  async httpPut(url, params, data) {
+    const options = { method: "PUT", qs: params || {}, json: data, headers: {} };
+    if (this._sessionToken.accessToken == null) {
+      throw new Error("Access token is null");
+    }
+    return await this.__makeRequest(url, options);
+  }
+  async httpPutStream(url, params, data, buffer) {
+    const options = { method: "PUT", qs: params || {}, json: data, headers: {} };
+    if (this._sessionToken.accessToken == null) {
+      throw new Error("Access token is null");
+    }
+    return await this.__makePostStreamRequest(url, options, buffer);
+  }
+  async httpDelete(url, params) {
+    const options = { method: "DELETE", qs: params || {}, json: null, headers: {} };
+    if (this._sessionToken.accessToken == null) {
+      throw new Error("Access token is null");
+    }
+    return await this.__makeRequest(url, options);
+  }
+  async __acquireRefreshToken() {
+    this._sessionToken.isAuthenticated = false;
+    const { Authorize: Authorize3 } = await Promise.resolve().then(() => (init_authorize(), authorize_exports));
+    const vvAuthorize = new Authorize3();
+    try {
+      await vvAuthorize.acquireRefreshToken(this._sessionToken);
+    } catch (error) {
+      await vvAuthorize.reacquireSecurityToken(this._sessionToken);
+    }
+  }
+  request(httpVerb, url, params, data) {
+    const options = { method: httpVerb.toUpperCase() };
+    debug2("Performing %s request to url: %s", httpVerb.toUpperCase(), url);
+    return this.doVvClientRequest(url, options, params, data);
+  }
+  getUrl(resourceUrl) {
+    return this._sessionToken.baseUrl + this._sessionToken.apiUrl + resourceUrl;
+  }
+  __getRetryDelay(retryTime) {
+    let delay = 10;
+    if (retryTime && !isNaN(Date.parse(retryTime))) {
+      const now = /* @__PURE__ */ new Date();
+      delay = Date.parse(retryTime) - now.getTime();
+      if (delay < 0) {
+        delay *= -1;
+      }
+    }
+    return delay;
+  }
+};
+
+// lib/common.js
+init_sessionToken();
+init_authorize();
+init_sessionToken();
+init_authorize();
+var common_default = {
+  httpHelper: HttpHelper,
+  sessionToken: SessionToken,
+  authorize: Authorize
+};
+
+// lib/docApi/documentInstanceManager.js
+init_esm_shims();
+var DocumentInstanceManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  async GetRevision(documentRevisionId) {
+    let resourceUri = this._httpHelper._config.ResourceUri.DocApi.GetRevision;
+    resourceUri = resourceUri.replace("{id}", documentRevisionId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  async getDocumentOcrStatus(documentRevisionId) {
+    let resourceUri = this._httpHelper._config.ResourceUri.DocApi.OcrStatus;
+    resourceUri = resourceUri.replace("{id}", documentRevisionId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  async updateDocumentOcrStatus(documentRevisionId, data) {
+    let resourceUri = this._httpHelper._config.ResourceUri.DocApi.OcrStatus;
+    resourceUri = resourceUri.replace("{id}", documentRevisionId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  async search(criteriaList, searchFolders, excludeFolders, sortBy, sortDirection = "desc", page = 0, take = 15, archiveType = 0, roleSecurity = false) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.DocApi.AdvancedSearch);
+    const data = {
+      criteriaList,
+      searchFolders,
+      excludeFolders,
+      sortBy,
+      sortDirection,
+      page,
+      take,
+      archiveType,
+      roleSecurity
+    };
+    const options = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, options, null, data);
+  }
+};
+
+// lib/DocApi.js
+import yaml2 from "js-yaml";
+import fs2 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path2 from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+var DocApi = class {
+  constructor(sessionToken, docApiConfig) {
+    if (!sessionToken["tokenType"] && sessionToken["tokenType"] != "jwt") {
+      return;
+    }
+    const yamlConfig = yaml2.load(fs2.readFileSync(__dirname2 + "/config.yml", "utf8"));
+    this._httpHelper = new common_default.httpHelper(sessionToken, yamlConfig);
+    this.isEnabled = docApiConfig["isEnabled"] || false;
+    this.baseUrl = docApiConfig["apiUrl"] || null;
+    this.roleSecurity = docApiConfig["roleSecurity"] || false;
+    if (this.isEnabled) {
+      this.documentInstances = new DocumentInstanceManager(this._httpHelper);
+    }
+  }
+};
+var DocApi_default = DocApi;
+
+// lib/FormsApi.js
+init_esm_shims();
+
+// lib/formsApi/formInstanceManager.js
+init_esm_shims();
+var FormInstanceManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  async postForm(params, data, formTemplateRevisionId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormsApi.FormInstance;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    data["formTemplateId"] = formTemplateRevisionId || data["formTemplateId"];
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  async postFormRevision(params, data, formTemplateRevisionId, formId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormsApi.FormInstance;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    data["formTemplateId"] = formTemplateRevisionId || data["formTemplateId"];
+    data["formId"] = formId || data["formId"];
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+};
+var formInstanceManager_default = FormInstanceManager;
+
+// lib/FormsApi.js
+import yaml3 from "js-yaml";
+import fs3 from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import path3 from "path";
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path3.dirname(__filename3);
+var FormsApi = class {
+  constructor(sessionToken, formsApiConfig) {
+    if (!sessionToken["tokenType"] && sessionToken["tokenType"] != "jwt") {
+      return;
+    }
+    const yamlConfig = yaml3.load(fs3.readFileSync(__dirname3 + "/config.yml", "utf8"));
+    this._httpHelper = new common_default.httpHelper(sessionToken, yamlConfig);
+    this.isEnabled = formsApiConfig["isEnabled"] || false;
+    this.baseUrl = formsApiConfig["formsApiUrl"] || null;
+    if (this.isEnabled) {
+      this.formInstances = new formInstanceManager_default(this._httpHelper);
+    }
+  }
+};
+var FormsApi_default = FormsApi;
+
+// lib/ObjectsApi.js
+init_esm_shims();
+
+// lib/objectsApi/modelsManager.js
+init_esm_shims();
+var ModelsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  /**
+   * Retrieves a list of available models
+   * @param {object} params - Optional URL parameters to include in the request
+   */
+  async getModels(params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.ObjectsApi.Models;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    params = params || {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  /**
+   * Retrieves a specific model by its ID
+   * @param {string} modelId - The ID (Guid) for the requested model
+   * @param {object} params - Optional URL parameters to include in the request
+   */
+  async getModelById(modelId, params) {
+    let resourceUri = this._httpHelper._config.ResourceUri.ObjectsApi.ModelById;
+    resourceUri = resourceUri.replace("{id}", modelId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    params = params || {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+var modelsManager_default = ModelsManager;
+
+// lib/objectsApi/objectsManager.js
+init_esm_shims();
+var ObjectsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  /**
+   * Retrieves a specific object by its ID
+   * @param {string} objectId - The ID (Guid) for the requested object
+   * @param {object} params - Optional URL parameters to include in the request
+   */
+  async getObject(objectId, params) {
+    let resourceUri = this._httpHelper._config.ResourceUri.ObjectsApi.ObjectById;
+    resourceUri = resourceUri.replace("{id}", objectId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    params = params || {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  /**
+   * Retrieves a paged list of objects associated with a given model
+   * @param {string} modelId - The ID (Guid) for the requested model to search
+   * @param {object} data - Data to send in the request body
+   * @param {object} params - Optional URL parameters to include in the request
+   */
+  async getObjectsByModelId(modelId, data, params) {
+    let resourceUri = this._httpHelper._config.ResourceUri.ObjectsApi.ObjectSearchByModelId;
+    resourceUri = resourceUri.replace("{modelId}", modelId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    data = data || {};
+    params = params || {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  /**
+   * Creates a new object adhering to a given model
+   * @param {string} modelId - The ID (Guid) used to create a new object for that model
+   * @param {object} data - Data to send in the request body
+   * @param {object} params - Optional URL parameters to include in the request
+   */
+  async createObject(modelId, data, params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.ObjectsApi.Object;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    data = data || {};
+    params = params || {};
+    data["modelId"] = modelId || data["modelId"];
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  /**
+   * Updates an existing object by its ID (Guid) and revision ID (Guid)
+   * @param {string} objectId - The ID (Guid) for the requested object to update
+   * @param {string} objectRevisionId - The revision ID (Guid) for the requested object to update
+   * @param {object} data - Data to send in the request body
+   * @param {object} params - Optional URL parameters to include in the request
+   */
+  async updateObject(objectId, objectRevisionId, data, params) {
+    let resourceUri = this._httpHelper._config.ResourceUri.ObjectsApi.ObjectById;
+    resourceUri = resourceUri.replace("{id}", objectId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    data = data || {};
+    params = params || {};
+    data["revisionId"] = objectRevisionId || data["revisionId"];
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  /**
+   * Deletes an existing object by its ID (Guid)
+   * @param {string} objectId - The ID (Guid) for the requested object to delete
+   * @param {object} params - Optional URL parameters to include in the request
+   */
+  async deleteObject(objectId, params) {
+    let resourceUri = this._httpHelper._config.ResourceUri.ObjectsApi.ObjectById;
+    resourceUri = resourceUri.replace("{id}", objectId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    params = params || {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+var objectsManager_default = ObjectsManager;
+
+// lib/ObjectsApi.js
+import yaml4 from "js-yaml";
+import fs4 from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import path4 from "path";
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = path4.dirname(__filename4);
+var ObjectsApi = class {
+  constructor(sessionToken, objectsApiConfig) {
+    if (!sessionToken["tokenType"] && sessionToken["tokenType"] != "jwt") {
+      return;
+    }
+    const yamlConfig = yaml4.load(fs4.readFileSync(__dirname4 + "/config.yml", "utf8"));
+    this._httpHelper = new common_default.httpHelper(sessionToken, yamlConfig);
+    this.isEnabled = objectsApiConfig["isEnabled"] || false;
+    this.baseUrl = objectsApiConfig["apiUrl"] || null;
+    if (this.isEnabled) {
+      this.models = new modelsManager_default(this._httpHelper);
+      this.objects = new objectsManager_default(this._httpHelper);
+    }
+  }
+};
+var ObjectsApi_default = ObjectsApi;
+
+// lib/StudioApi.js
+init_esm_shims();
+
+// lib/studioApi/workflowManager.js
+init_esm_shims();
+var WorkflowManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  async getWorkflow(workflowId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowLatestPublishedId.replace("{id}", workflowId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const data = {};
+    const params = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  async getWorkflowByName(workflowName) {
+    const resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowLatestPublished;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const data = {};
+    const params = { name: workflowName };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  async getWorkflowVariables(params, workflowId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowVariables.replace("{id}", workflowId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const data = {};
+    params = params || {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  /**
+   * Triggers workflow
+   * @param {string} workflowId
+   * @param {number} workflowRevision
+   * @param {string} objectId
+   * @param {object[]} workflowVariables - workflow values to be submitted to the workflow
+   * * @param {string} workflowVariables[].name = name of variable
+   * * @param {*} workflowVariables[].value - value to be passed
+   * * @param {number} workflowVariables[].dataType - Text: 1, Number: 2, Date: 3, Boolean: 4
+   */
+  async triggerWorkflow(workflowId, workflowRevision, objectId, workflowVariables) {
+    const resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowRun.replace("{id}", workflowId).replace("{revision}", workflowRevision);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const data = {
+      objectId,
+      reference: "API",
+      data: {
+        workflowVariables,
+        dataSetVariables: []
+      }
+    };
+    const params = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  /**
+   * Terminates the workflow instance
+   * @param {string} workflowId
+   * @param {string} instanceId
+   * @returns
+   */
+  async terminateWorkflow(workflowId, instanceId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowTerminate.replace("{workflowId}", workflowId).replace("{instanceId}", instanceId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const data = {};
+    const params = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  /**
+       * Returns workflow history for an object under the provided workflow
+       * @param {string} workflowId
+       * @param {string} objectId
+       * @returns
+       */
+  async GetWorkflowHistoryForObject(objectId, workflowId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowHistoryObject.replace("{workflowId}", workflowId).replace("{objectId}", objectId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const data = {};
+    const params = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  /**
+   * Returns the running workflow, if any, for an object under the provided workflow
+   * @param {string} workflowId
+   * @param {string} objectId
+   * @returns
+   */
+  async GetRunningWorkflowForObject(objectId, workflowId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowHistoryRunningObject.replace("{workflowId}", workflowId).replace("{objectId}", objectId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const data = {};
+    const params = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+};
+var workflowManager_default = WorkflowManager;
+
+// lib/StudioApi.js
+import yaml5 from "js-yaml";
+import fs5 from "fs";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import path5 from "path";
+var __filename5 = fileURLToPath5(import.meta.url);
+var __dirname5 = path5.dirname(__filename5);
+var StudioApi = class {
+  constructor(sessionToken, studioApiConfig) {
+    if (!sessionToken["tokenType"] && sessionToken["tokenType"] != "jwt") {
+      return;
+    }
+    const yamlConfig = yaml5.load(fs5.readFileSync(__dirname5 + "/config.yml", "utf8"));
+    this._httpHelper = new common_default.httpHelper(sessionToken, yamlConfig);
+    this.isEnabled = studioApiConfig["isEnabled"] || false;
+    this.baseUrl = studioApiConfig["studioApiUrl"] || null;
+    if (this.isEnabled) {
+      this.workflow = new workflowManager_default(this._httpHelper);
+    }
+  }
+};
+var StudioApi_default = StudioApi;
+
+// lib/NotificationsApi.js
+init_esm_shims();
+
+// lib/notificationsApi/userNotificationsManager.js
+init_esm_shims();
+var UserNotificationsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  async forceUIRefresh(userGuid) {
+    const resourceUri = this._httpHelper._config.ResourceUri.NotificationsApi.ForceUIRefresh.replace("{id}", userGuid);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const params = {};
+    const data = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+};
+var userNotificationsManager_default = UserNotificationsManager;
+
+// lib/NotificationsApi.js
+import yaml6 from "js-yaml";
+import fs6 from "fs";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import path6 from "path";
+var __filename6 = fileURLToPath6(import.meta.url);
+var __dirname6 = path6.dirname(__filename6);
+var NotificationsApi = class {
+  constructor(sessionToken, notificationsApiConfig) {
+    if (!sessionToken["tokenType"] && sessionToken["tokenType"] != "jwt") {
+      return;
+    }
+    const yamlConfig = yaml6.load(fs6.readFileSync(__dirname6 + "/config.yml", "utf8"));
+    this._httpHelper = new common_default.httpHelper(sessionToken, yamlConfig);
+    this.isEnabled = notificationsApiConfig["isEnabled"] || false;
+    this.baseUrl = notificationsApiConfig["apiUrl"] || null;
+    if (this.isEnabled) {
+      this.users = new userNotificationsManager_default(this._httpHelper);
+    }
+  }
+};
+var NotificationsApi_default = NotificationsApi;
+
+// lib/VVRestApi.js
+import yaml7 from "js-yaml";
+import fs7 from "fs";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import path7 from "path";
+import createDebug5 from "debug";
+
+// lib/vvRestApi/constants.js
+init_esm_shims();
+var Constants = class {
+  constructor() {
+  }
+  alertEventIds = {
+    // Folder Events
+    folderSecurityModified: "F06FD123-2C52-4F43-9122-34335A5BD8C6",
+    // "CategorySecurity"
+    childFolderSecurityModified: "30167D46-86CF-4E89-B1AE-FC00BB378F67",
+    // "CategorySecurityCascade"
+    folderDocumentAdded: "3702CFBF-555C-4032-BFB2-E25829788BAC",
+    // "NewCategoryDoc"
+    childFolderDocumentAdded: "28946E3C-AEAF-402B-BCE3-8DEAC3D19877",
+    // "NewCategoryDocCascade"
+    // Document Events
+    documentCheckedIn: "D47804AB-AEE9-4002-BAB5-9F1AC0366076",
+    // "CheckIn"
+    documentCheckedOut: "4BBA55C1-7AF6-48FF-BFBE-EC7A58EB7F01",
+    // "CheckOut"
+    documentDetailsModified: "3B9D493F-2B45-4877-ABC1-5CA74F92723D",
+    // "DocumentDetails"
+    documentSecurityModified: "BAC187DC-78A8-4A8B-B50F-DB5D5AEE11B9",
+    // "DocumentSecurity"
+    documentViewed: "140B9E97-8D93-48D0-837B-AB4FD419B6D6",
+    // "DocumentViewed"
+    // Project Events
+    projectDocumentAddedOrRemoved: "300DB724-5C51-4C38-B2E2-FFE19634A373",
+    // "NewProjectDoc"
+    projectViewed: "92F0C5F4-68DC-4309-9ABF-13B8E2198F79"
+    // "ProjectView"
+  };
+  securityRoles = {
+    // RoleType
+    Owner: "Owner",
+    Editor: "Editor",
+    Viewer: "Viewer"
+  };
+  securityMemberType = {
+    // MemberType
+    User: "User",
+    Group: "Group"
+  };
+  relationType = {
+    Parent: "Parent",
+    Child: "Child",
+    Peer: "Peer"
+  };
+};
+
+// lib/vvRestApi/configurationManager.js
+init_esm_shims();
+var ConfigurationManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getDocApiConfig() {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.ConfigurationDocApi);
+    const opts = { method: "GET" };
+    const params = {};
+    const data = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  getFormsApiConfig() {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.ConfigurationFormsApi);
+    const opts = { method: "GET" };
+    const params = {};
+    const data = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  getObjectsApiConfig() {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.ConfigurationObjectsApi);
+    const opts = { method: "GET" };
+    const params = {};
+    const data = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  getStudioApiConfig() {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.ConfigurationStudioApi);
+    const opts = { method: "GET" };
+    const params = {};
+    const data = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  getNotificationsApiConfig() {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.ConfigurationNotificationApi);
+    const opts = { method: "GET" };
+    const params = {};
+    const data = {};
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+};
+
+// lib/vvRestApi/emailManager.js
+init_esm_shims();
+var EmailManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  postEmails(params, data) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.Emails);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  postEmailsWithAttachments(params, data, fileObjs) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.Emails);
+    const opts = { method: "POSTSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data, fileObjs);
+  }
+};
+
+// lib/vvRestApi/formsManager.js
+init_esm_shims();
+import createDebug3 from "debug";
+var debug3 = createDebug3("visualvault:forms");
+var ReturnField = class {
+  /** @type {string} */
+  id;
+  /** @type {string} */
+  name;
+  /** @type {*} */
+  value;
+  /** @type {boolean} */
+  isError;
+  /** @type {string} */
+  errorMessage;
+  /**
+   * @param {string} id - Field ID
+   * @param {string} name - Field name
+   * @param {*} value - Field value
+   * @param {boolean} isError - Whether field has an error
+   * @param {string} errorMessage - Error message if any
+   */
+  constructor(id, name, value, isError, errorMessage) {
+    this.id = id;
+    this.name = name;
+    this.value = value;
+    this.isError = isError;
+    this.errorMessage = errorMessage;
+  }
+};
+var FormFieldCollection = class {
+  /**
+   * @param {Array<*>} ffColl - Array of form fields
+   */
+  constructor(ffColl) {
+    this._ffColl = ffColl;
+  }
+  /**
+   * Get a form field by name
+   * @param {string} name - Field name to search for
+   * @returns {*} The field or null if not found
+   */
+  getFormFieldByName(name) {
+    const fieldName = name.toLowerCase();
+    return this._ffColl.find(
+      (field) => field.name.toLowerCase() === fieldName
+    ) || null;
+  }
+  /**
+   * Get a form field by ID
+   * @param {string} id - Field ID to search for
+   * @returns {*} The field or null if not found
+   */
+  getFormFieldById(id) {
+    const fieldId = id.toLowerCase();
+    return this._ffColl.find(
+      (field) => field.id.toLowerCase() === fieldId
+    ) || null;
+  }
+  /**
+   * Get the array of all form fields
+   * @returns {Array<*>} Array of form fields
+   */
+  getFieldArray() {
+    return this._ffColl;
+  }
+};
+var FormsManager = class {
+  /**
+   * @param {*} httpHelper - HTTP helper instance
+   */
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  returnField(id, name, value, isError, errorMessage) {
+    return new ReturnField(id, name, value, isError, errorMessage);
+  }
+  getFormTemplates(params) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.FormTemplates);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  /**
+   * @param {string} templateName
+   * @returns {Promise<{formsManager: FormsManager, templateIdGuid: string, templateRevisionIdGuid: string, error?: string}>}
+   */
+  async getFormTemplateIdByName(templateName) {
+    const params = {
+      fields: "id, name, description, revision, revisionId",
+      q: `name eq '${templateName}'`
+    };
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.FormTemplates);
+    const opts = { method: "GET" };
+    try {
+      const resp = await this._httpHelper.doVvClientRequest(url, opts, params, null);
+      const templateResp = JSON.parse(resp);
+      let templateId;
+      let templateRevisionId;
+      if (templateResp.data && templateResp.data.length > 0) {
+        templateId = templateResp.data[0].id;
+        templateRevisionId = templateResp.data[0].revisionId;
+      }
+      return {
+        formsManager: this,
+        templateIdGuid: templateId,
+        templateRevisionIdGuid: templateRevisionId
+      };
+    } catch (error) {
+      debug3('Failed to get form template by name "%s": %s', templateName, error.message);
+      return {
+        formsManager: this,
+        templateIdGuid: "",
+        templateRevisionIdGuid: "",
+        error: error.message
+      };
+    }
+  }
+  async getForms(params, formTemplateId) {
+    if (!this.isGuid(formTemplateId)) {
+      const resp = await this.getFormTemplateIdByName(formTemplateId);
+      const templateIdGuid = resp.templateIdGuid;
+      const resourceUri = this._httpHelper._config.ResourceUri.Forms.replace("{id}", templateIdGuid);
+      const url = this._httpHelper.getUrl(resourceUri);
+      const opts = { method: "GET" };
+      return this._httpHelper.doVvClientRequest(url, opts, params, null);
+    } else {
+      const resourceUri = this._httpHelper._config.ResourceUri.Forms.replace("{id}", formTemplateId);
+      const url = this._httpHelper.getUrl(resourceUri);
+      const opts = { method: "GET" };
+      return this._httpHelper.doVvClientRequest(url, opts, params, null);
+    }
+  }
+  setFieldImage(formId, fieldId, imageId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstanceImage.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const data = { fieldId, imageId };
+    const params = { fieldId, imageId };
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  importFormTemplate(data, formTemplateId, buffer) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormTemplatesImport.replace("{id}", formTemplateId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUTSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data, buffer);
+  }
+  async postForms(params, data, formTemplateId) {
+    if (!this.isGuid(formTemplateId)) {
+      const resp = await this.getFormTemplateIdByName(formTemplateId);
+      const templateIdGuid = resp.templateIdGuid;
+      const resourceUri = this._httpHelper._config.ResourceUri.Forms.replace("{id}", templateIdGuid);
+      const url = this._httpHelper.getUrl(resourceUri);
+      const opts = { method: "POST" };
+      return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    } else {
+      const resourceUri = this._httpHelper._config.ResourceUri.Forms.replace("{id}", formTemplateId);
+      const url = this._httpHelper.getUrl(resourceUri);
+      const opts = { method: "POST" };
+      return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+  }
+  async postFormRevision(params, data, formTemplateId, formId) {
+    if (!this.isGuid(formTemplateId)) {
+      const resp = await this.getFormTemplateIdByName(formTemplateId);
+      const templateIdGuid = resp.templateIdGuid;
+      const resourceUri = this._httpHelper._config.ResourceUri.Forms.replace("{id}", templateIdGuid);
+      const url = this._httpHelper.getUrl(resourceUri + "/" + formId);
+      const opts = { method: "POST" };
+      return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    } else {
+      const resourceUri = this._httpHelper._config.ResourceUri.Forms.replace("{id}", formTemplateId);
+      const url = this._httpHelper.getUrl(resourceUri + "/" + formId);
+      const opts = { method: "POST" };
+      return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+  }
+  postFormRevisionByFormId(params, data, formId) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.FormsId).replace("{id}", formId);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  updateFormInstanceOriginator(formInstanceId, newOriginatorUsID) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstanceUpdateOriginator.replace("{id}", formInstanceId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const params = { userId: newOriginatorUsID };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  relateForm(formId, relateToId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/relateForm");
+    const params = { relateToId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  relateFormByDocId(formId, relateToDocId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/relateForm");
+    const params = { relateToDocId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  relateDocument(formId, relateToId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/relateDocument");
+    const params = { relateToId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  relateDocumentByDocId(formId, relateToDocId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/relateDocument");
+    const params = { relateToDocId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  relateProject(formId, relateToId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/relateProject");
+    const params = { relateToId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  relateProjectByName(formId, relateToProjectName) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/relateProject");
+    const params = { relateToProjectName };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  unrelateForm(formId, relateToId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/unrelateForm");
+    const params = { relateToId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  unrelateFormByDocId(formId, relateToDocId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/unrelateForm");
+    const params = { relateToDocId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  unrelateDocument(formId, relateToId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/unrelateDocument");
+    const params = { relateToId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  unrelateDocumentByDocId(formId, relateToDocId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/unrelateDocument");
+    const params = { relateToDocId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  unrelateProject(formId, relateToId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/unrelateProject");
+    const params = { relateToId };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  unrelateProjectByName(formId, relateToProjectName) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri + "/unrelateProject");
+    const params = { relateToProjectName };
+    const data = null;
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  getFormRelatedDocs(formId, params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstanceRelatedDocs.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    if (params === void 0) {
+      params = null;
+    }
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getFormRelatedForms(formId, params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstanceRelatedForms.replace("{id}", formId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    if (params === void 0) {
+      params = null;
+    }
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  isGuid(stringToTest) {
+    let testString = stringToTest;
+    if (testString[0] === "{") {
+      testString = testString.substring(1, testString.length - 1);
+    }
+    const regexGuid = /^(\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1}$/gi;
+    return regexGuid.test(testString);
+  }
+  getFormInstanceById(templateId, instanceId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormId.replace("{id}", templateId).replace("{formId}", instanceId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  getFormInstancePDF(templateId, instanceId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormIdPdf.replace("{id}", templateId).replace("{formId}", instanceId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GETSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  getFormTemplateFields(templateId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormDesignerFormsTemplatesIdFields.replace("{id}", templateId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  deleteFormInstance(instanceId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormInstance.replace("{id}", instanceId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  releaseFormTemplate(formTemplateId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FormTemplatesRelease.replace("{id}", formTemplateId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+};
+
+// lib/vvRestApi/groupsManager.js
+init_esm_shims();
+var GroupsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getGroups(params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.GetGroups;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getGroupsUsers(params, groupId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.GroupsUsers.replace("{id}", groupId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getGroupUser(params, groupId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.GroupsAddUser.replace("{groupId}", groupId).replace("{userId}", userId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  addUserToGroup(params, groupId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.GroupsAddUser.replace("{groupId}", groupId).replace("{userId}", userId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  removeUserFromGroup(params, groupId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.GroupsAddUser.replace("{groupId}", groupId).replace("{userId}", userId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/libraryManager.js
+init_esm_shims();
+var LibraryManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getFolders(params) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.Folders);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  postFolderByPath(params, data, folderPath) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.Folders);
+    data.folderpath = folderPath;
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  // Valid fields to be defined on the "data" parameter to be updated on the folder: name, description
+  putFolder(params, data, folderId) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.FoldersId.replace("{id}", folderId));
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  deleteFolder(folderId) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.FoldersId.replace("{id}", folderId));
+    const opts = { method: "DELETE" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  copyFolder(params, data) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.FoldersCopy);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  moveFolder(params, data) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.FoldersMove);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  getDocuments(params, folderId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Documents.replace("{id}", folderId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  updateFolderIndexFieldOverrideSettings(folderId, fieldId, queryId, displayField, valueField, dropDownListId, required, defaultValue) {
+    const data = {
+      queryId,
+      queryValueField: valueField,
+      queryDisplayField: displayField,
+      dropDownListId,
+      required,
+      defaultValue
+    };
+    const resourceUri = this._httpHelper._config.ResourceUri.FoldersIdIndexFieldsId.replace("{id}", folderId).replace("{indexFieldId}", fieldId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  getFolderIndexFields(params, folderId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FolderIndexFields.replace("{id}", folderId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  postFolderAlertSubscription(folderId, eventId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FolderAlertsId.replace("{folderId}", folderId).replace("{eventId}", eventId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const params = {
+      usId: userId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  deleteFolderAlertSubscription(folderId, eventId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FolderAlertsId.replace("{folderId}", folderId).replace("{eventId}", eventId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    const params = {
+      usId: userId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getFolderSecurityMembers(params, folderId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FolderSecurity.replace("{folderId}", folderId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  putFolderSecurityMember(folderId, memberId, memberType, securityRole, cascadeSecurityChanges) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FolderSecurityId.replace("{folderId}", folderId).replace("{memberId}", memberId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    const data = {
+      memberType,
+      securityRole,
+      cascadeSecurityChanges
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  deleteFolderSecurityMember(folderId, memberId, cascadeSecurityChanges) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FolderSecurityId.replace("{folderId}", folderId).replace("{memberId}", memberId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    const params = {
+      cascadeSecurityChanges
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/sitesManager.js
+init_esm_shims();
+var SitesManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getSites(params) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.Sites);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  postSites(params, data) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Sites;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  putSites(params, data, siteId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Sites;
+    const url = this._httpHelper.getUrl(resourceUri + "/" + siteId);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  getGroups(params, siteId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Groups.replace("{id}", siteId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  postGroups(params, data, siteId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Groups.replace("{id}", siteId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  putGroups(params, data, siteId, grId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Groups.replace("{id}", siteId);
+    const url = this._httpHelper.getUrl(resourceUri + "/" + grId);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  changeUserSite(userId, newSiteId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.ChangeUserSite;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    const data = {
+      UserId: userId,
+      NewSiteId: newSiteId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+};
+
+// lib/vvRestApi/usersManager.js
+init_esm_shims();
+var UsersManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getUsers(params, siteId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Users.replace("{id}", siteId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  postUsers(params, data, siteId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Users.replace("{id}", siteId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  putUsers(params, data, siteId, usId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Users.replace("{id}", siteId);
+    const url = this._httpHelper.getUrl(resourceUri + "/" + usId);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  putUsersEndpoint(params, data, usId) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.User + "/" + usId);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  getUser(params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.User;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getUserById(params, usId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UserById.replace("{id}", usId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getUserGroups(params, usId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UserGroups.replace("{id}", usId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getUserSupervisors(params, usId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UserSupervisors.replace("{id}", usId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getUserSupervisees(params, usId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UserSupervisees.replace("{id}", usId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getUserLoginToken(usId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UserWebToken.replace("{id}", usId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const params = [];
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getUserJwt(audience) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UsersGetJwt;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const params = {};
+    if (audience) {
+      params["audience"] = audience;
+    }
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getCurrentUser() {
+    const resourceUri = this._httpHelper._config.ResourceUri.UsersWhoAmI;
+    const baseUrl = this._httpHelper._sessionToken.baseUrl;
+    const url = baseUrl + "/api/v1" + resourceUri;
+    const opts = { method: "GET" };
+    const params = [];
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  resetPassword(usId, sendEmail = true) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UsersPassword.replace("{id}", usId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    const params = [];
+    const data = {
+      resetPassword: true,
+      sendEmail
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  updateUserId(usId, newUserId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.UsersIdUserId.replace("{id}", usId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    const params = [];
+    const data = {
+      userId: newUserId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+};
+
+// lib/vvRestApi/currentUserManager.js
+init_esm_shims();
+var CurrentUserManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  /**
+   * Gets the currently authenticated user's information.
+   * @param {Object} [params] - Optional query parameters.
+   * @returns {Promise<string>} A promise that resolves with the current user's information as a JSON string.
+   */
+  async getCurrentUser(params) {
+    var resourceUri = this._httpHelper._config.ResourceUri.UsersMe;
+    var url = this._httpHelper.getUrl(resourceUri);
+    var opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/scheduledProcessManager.js
+init_esm_shims();
+var ScheduledProcessManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  postCompletion(id, action, result, message) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.ScheduledProcess) + "/" + id;
+    const opts = { method: "POST" };
+    const params = {
+      action
+    };
+    if (result !== null && (typeof result === "boolean" || result.length > 0)) {
+      params.result = result.toString();
+    }
+    if (message && message.length > 0) {
+      params.message = message;
+    }
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  runAllScheduledProcesses() {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.ScheduledProcess) + "/Run";
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+};
+
+// lib/vvRestApi/customQueryManager.js
+init_esm_shims();
+var CustomQueryManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getCustomQueryResultsByName(queryName, params) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.CustomQuery);
+    const opts = { method: "GET" };
+    if (!params) {
+      params = {};
+    }
+    params.queryName = queryName;
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getCustomQueryResultsById(id, params) {
+    const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.CustomQuery + "/" + id);
+    const opts = { method: "GET" };
+    if (!params) {
+      params = {};
+    }
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/customerManager.js
+init_esm_shims();
+var CustomerManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  createCustomerInvite(data) {
+    const baseUrl = this._httpHelper._sessionToken.baseUrl;
+    let url = baseUrl + "/api/v1/" + this._httpHelper._config.ResourceUri.CustomerInvite;
+    url = url.replace(/\/api\/\//g, "/api/");
+    url = url.replace(/\/v1\/\//g, "/v1/");
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, "", data);
+  }
+  assignUser(customerId, data) {
+    const baseUrl = this._httpHelper._sessionToken.baseUrl;
+    const url = baseUrl + "/api/v1/" + this._httpHelper._config.ResourceUri.CustomerAssignUser.replace("{customerId}", customerId);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, "", data);
+  }
+};
+
+// lib/vvRestApi/customerDatabaseManager.js
+init_esm_shims();
+import createDebug4 from "debug";
+var debug4 = createDebug4("visualvault:customer-db");
+var CustomerDatabaseManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  assignUser(customerId, data) {
+    const baseUrl = this._httpHelper._sessionToken.baseUrl;
+    const url = baseUrl + "/api/v1/" + this._httpHelper._config.ResourceUri.CustomerDatabaseAssignUser.replace("{databaseId}", customerId);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, "", data);
+  }
+  removeUser(authenticationUserId, databaseId) {
+    const baseUrl = this._httpHelper._sessionToken.baseUrl;
+    let url = baseUrl + "/api/v1" + this._httpHelper._config.ResourceUri.UserDelete.replace("{databaseId}", databaseId);
+    url = url.replace("{authenticationUserId}", authenticationUserId);
+    debug4("Removing user %s from database %s: %s", authenticationUserId, databaseId, url);
+    const opts = { method: "DELETE" };
+    const params = [];
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/filesManager.js
+init_esm_shims();
+var FilesManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getFileBytesQuery(query) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FilesQuery + query;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GETSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  getFileBytesId(id) {
+    const resourceUri = this._httpHelper._config.ResourceUri.FilesId.replace("{id}", id);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GETSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, null);
+  }
+  postFile(data, buffer) {
+    const resourceUri = this._httpHelper._config.ResourceUri.Files;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POSTSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data, buffer);
+  }
+};
+
+// lib/vvRestApi/scriptsManager.js
+init_esm_shims();
+var ScriptsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  runWebService(serviceName, serviceData, usId) {
+    let resourceUri = this._httpHelper._config.ResourceUri.Scripts + "?name=" + serviceName;
+    if (typeof usId !== "undefined" && usId !== null) {
+      resourceUri += `&usId=${usId}`;
+    }
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, serviceData);
+  }
+  completeWorkflowWebService(executionId, workflowVariables) {
+    const resourceUri = this._httpHelper._config.ResourceUri.ScriptsCompleteWf;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const postData = {
+      executionId,
+      workflowVariables
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, null, postData);
+  }
+};
+
+// lib/vvRestApi/documentsManager.js
+init_esm_shims();
+var DocumentsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  postDoc(data) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsPost;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  postDocWithFile(data, fileData) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsPost;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POSTSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data, fileData);
+  }
+  copyDocument(params, data, documentId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsIdCopy.replace("{id}", documentId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  moveDocument(params, data, documentId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsIdMove.replace("{id}", documentId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, data);
+  }
+  deleteDocument(params, revisionId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsId.replace("{id}", revisionId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getDocumentRevision(params, revisionId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsId.replace("{id}", revisionId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getDocuments(params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsPost;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  putDocumentIndexFields(data, documentId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentIndexFields.replace("{id}", documentId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  postDocumentAlertSubscription(documentId, eventId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentAlertsId.replace("{documentId}", documentId).replace("{eventId}", eventId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const params = {
+      usId: userId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  deleteDocumentAlertSubscription(documentId, eventId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentAlertsId.replace("{documentId}", documentId).replace("{eventId}", eventId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    const params = {
+      usId: userId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  getDocumentRevisionOcrProperties(params, revisionId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsIdOcr.replace("{id}", revisionId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  relateDocuments(revisionId, relateToRevisionId, relateType) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsIdRelateDocument.replace("{id}", revisionId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    const data = {
+      relateToId: relateToRevisionId,
+      relateType
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+  updateDocumentExpiration(documentId, expirationDate) {
+    const resourceUri = this._httpHelper._config.ResourceUri.DocumentsIdExpiration.replace("{id}", documentId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    const data = {
+      expirationDate
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, null, data);
+  }
+};
+
+// lib/vvRestApi/projectsManager.js
+init_esm_shims();
+var ProjectsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  postProjectAlertSubscription(projectId, eventId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.ProjectAlertsId.replace("{projectId}", projectId).replace("{eventId}", eventId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const params = {
+      usId: userId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  deleteProjectAlertSubscription(projectId, eventId, userId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.ProjectAlertsId.replace("{projectId}", projectId).replace("{eventId}", eventId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    const params = {
+      usId: userId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/indexFieldsManager.js
+init_esm_shims();
+var IndexFieldsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getIndexFields(params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.IndexFields;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/outsideProcessesManager.js
+init_esm_shims();
+var OutsideProcessesManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getOutsideProcesses(params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.OutsideProcesses;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/vvRestApi/securityMembersManager.js
+init_esm_shims();
+var SecurityMembersManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  addSecurityMember(parentId, memberId, roleType, isGroup) {
+    const resourceUri = this._httpHelper._config.ResourceUri.SecurityMembers;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "POST" };
+    const postData = {
+      parentId,
+      memberId,
+      role: roleType,
+      isGroup
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, null, postData);
+  }
+  getSecurityMembersForParentId(parentId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.SecurityMembers;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    const params = {
+      parentId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  removeSecurityMember(parentId, memberId) {
+    const resourceUri = this._httpHelper._config.ResourceUri.SecurityMembers;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "DELETE" };
+    const params = {
+      parentId,
+      memberId
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+  updateSecurityMember(parentId, memberId, roleType) {
+    const resourceUri = this._httpHelper._config.ResourceUri.SecurityMembers;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "PUT" };
+    const postData = {
+      parentId,
+      memberId,
+      role: roleType
+    };
+    return this._httpHelper.doVvClientRequest(url, opts, null, postData);
+  }
+};
+
+// lib/vvRestApi/layoutsManager.js
+init_esm_shims();
+var LayoutsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getLayout() {
+    const resourceUri = this._httpHelper._config.ResourceUri.Layout;
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GET" };
+    return this._httpHelper.doVvClientRequest(url, opts, {}, null);
+  }
+};
+
+// lib/vvRestApi/reportsManager.js
+init_esm_shims();
+var ReportsManager = class {
+  constructor(httpHelper) {
+    this._httpHelper = httpHelper;
+  }
+  getReportPDF(reportId, params) {
+    const resourceUri = this._httpHelper._config.ResourceUri.ReportServerPDF.replace("{id}", reportId);
+    const url = this._httpHelper.getUrl(resourceUri);
+    const opts = { method: "GETSTREAM" };
+    return this._httpHelper.doVvClientRequest(url, opts, params, null);
+  }
+};
+
+// lib/VVRestApi.js
+var debug5 = createDebug5("visualvault:api");
+var __filename7 = fileURLToPath7(import.meta.url);
+var __dirname7 = path7.dirname(__filename7);
+var VVClient = class {
+  /** @type {*} */
+  constants;
+  /** @type {*} */
+  configuration;
+  /** @type {*} */
+  customQuery;
+  /** @type {*} */
+  documents;
+  /** @type {*} */
+  email;
+  /** @type {*} */
+  files;
+  /** @type {*} */
+  forms;
+  /** @type {*} */
+  groups;
+  /** @type {*} */
+  library;
+  /** @type {*} */
+  sites;
+  /** @type {*} */
+  users;
+  /** @type {*} */
+  scheduledProcess;
+  /** @type {*} */
+  scripts;
+  /** @type {*} */
+  projects;
+  /** @type {*} */
+  customer;
+  /** @type {*} */
+  customerDatabase;
+  /** @type {*} */
+  indexFields;
+  /** @type {*} */
+  outsideProcesses;
+  /** @type {*} */
+  securityMembers;
+  /** @type {*} */
+  layouts;
+  /** @type {*} */
+  reports;
+  /**
+   * @param {*} sessionToken - Session token from authentication
+   */
+  constructor(sessionToken) {
+    this.yamlConfig = yaml7.load(fs7.readFileSync(path7.join(__dirname7, "config.yml"), "utf8"));
+    this._httpHelper = new common_default.httpHelper(sessionToken, this.yamlConfig);
+    this.constants = new Constants();
+    this.configuration = new ConfigurationManager(this._httpHelper);
+    this.customQuery = new CustomQueryManager(this._httpHelper);
+    this.documents = new DocumentsManager(this._httpHelper);
+    this.email = new EmailManager(this._httpHelper);
+    this.files = new FilesManager(this._httpHelper);
+    this.forms = new FormsManager(this._httpHelper);
+    this.groups = new GroupsManager(this._httpHelper);
+    this.library = new LibraryManager(this._httpHelper);
+    this.sites = new SitesManager(this._httpHelper);
+    this.users = new UsersManager(this._httpHelper);
+    this.currentUser = new CurrentUserManager(this._httpHelper);
+    this.scheduledProcess = new ScheduledProcessManager(this._httpHelper);
+    this.scripts = new ScriptsManager(this._httpHelper);
+    this.projects = new ProjectsManager(this._httpHelper);
+    this.customer = new CustomerManager(this._httpHelper);
+    this.customerDatabase = new CustomerDatabaseManager(this._httpHelper);
+    this.indexFields = new IndexFieldsManager(this._httpHelper);
+    this.outsideProcesses = new OutsideProcessesManager(this._httpHelper);
+    this.securityMembers = new SecurityMembersManager(this._httpHelper);
+    this.layouts = new LayoutsManager(this._httpHelper);
+    this.reports = new ReportsManager(this._httpHelper);
+    this._docApi = null;
+    Object.defineProperties(this, {
+      docApi: {
+        get: function() {
+          if (this._docApi != null && this._docApi.isEnabled && this._docApi.baseUrl) {
+            return this._docApi;
+          } else {
+            throw new ReferenceError("Document Api not enabled");
+          }
+        }
+      }
+    });
+    this._formsApi = null;
+    Object.defineProperties(this, {
+      formsApi: {
+        get: function() {
+          if (this._formsApi != null && this._formsApi.isEnabled && this._formsApi.baseUrl) {
+            return this._formsApi;
+          } else {
+            throw new ReferenceError("Forms Api not enabled");
+          }
+        }
+      }
+    });
+    this._objectsApi = null;
+    Object.defineProperties(this, {
+      objectsApi: {
+        get: function() {
+          if (this._objectsApi != null && this._objectsApi.isEnabled && this._objectsApi.baseUrl) {
+            return this._objectsApi;
+          } else {
+            throw new ReferenceError("Objects Api not enabled");
+          }
+        }
+      }
+    });
+    this._studioApi = null;
+    Object.defineProperties(this, {
+      studioApi: {
+        get: function() {
+          if (this._studioApi != null && this._studioApi.isEnabled && this._studioApi.baseUrl) {
+            return this._studioApi;
+          } else {
+            throw new ReferenceError("Studio Api not enabled");
+          }
+        }
+      }
+    });
+    this._notificationsApi = null;
+    Object.defineProperties(this, {
+      notificationsApi: {
+        get: function() {
+          if (this._notificationsApi != null && this._notificationsApi.isEnabled && this._notificationsApi.baseUrl) {
+            return this._notificationsApi;
+          } else {
+            throw new ReferenceError("Notifications Api not enabled");
+          }
+        }
+      }
+    });
+  }
+  async createDocApi(sessionToken) {
+    const docApiConfigResponse = JSON.parse(await this.configuration.getDocApiConfig());
+    if (docApiConfigResponse && docApiConfigResponse["data"]) {
+      const docApiSession = sessionToken.createCopy();
+      docApiSession.baseUrl = docApiConfigResponse.data["apiUrl"];
+      docApiSession.apiUrl = this.yamlConfig.DocApiUri;
+      if (docApiSession["tokenType"] == "jwt") {
+        this._docApi = new DocApi_default(docApiSession, docApiConfigResponse.data);
+      } else if (this.users) {
+        const jwtResponse = JSON.parse(await this.users.getUserJwt(docApiSession.audience));
+        if (jwtResponse["data"] && jwtResponse["data"]["token"]) {
+          docApiSession.convertToJwt(jwtResponse["data"]);
+          this._docApi = new DocApi_default(docApiSession, docApiConfigResponse.data);
+        }
+      }
+    }
+  }
+  async createFormsApi(sessionToken) {
+    const formsApiConfigResponse = JSON.parse(await this.configuration.getFormsApiConfig());
+    if (formsApiConfigResponse && formsApiConfigResponse["data"]) {
+      const formsApiSession = sessionToken.createCopy();
+      formsApiSession.baseUrl = formsApiConfigResponse.data["formsApiUrl"];
+      formsApiSession.apiUrl = this.yamlConfig.FormsApiUri;
+      if (formsApiSession["tokenType"] == "jwt") {
+        this._formsApi = new FormsApi_default(formsApiSession, formsApiConfigResponse.data);
+      } else if (this.users) {
+        const jwtResponse = JSON.parse(await this.users.getUserJwt(formsApiSession.audience));
+        if (jwtResponse["data"] && jwtResponse["data"]["token"]) {
+          formsApiSession.convertToJwt(jwtResponse["data"]);
+          this._formsApi = new FormsApi_default(formsApiSession, formsApiConfigResponse.data);
+        }
+      }
+    }
+  }
+  async createObjectsApi(sessionToken) {
+    const objectsApiConfigResponse = JSON.parse(await this.configuration.getObjectsApiConfig());
+    if (objectsApiConfigResponse && objectsApiConfigResponse["data"]) {
+      const objectsApiSession = sessionToken.createCopy();
+      objectsApiSession.baseUrl = objectsApiConfigResponse.data["apiUrl"];
+      objectsApiSession.apiUrl = "";
+      if (objectsApiSession["tokenType"] == "jwt") {
+        this._objectsApi = new ObjectsApi_default(objectsApiSession, objectsApiConfigResponse.data);
+      } else if (this.users) {
+        const jwtResponse = JSON.parse(await this.users.getUserJwt(objectsApiSession.audience));
+        if (jwtResponse["data"] && jwtResponse["data"]["token"]) {
+          objectsApiSession.convertToJwt(jwtResponse["data"]);
+          this._objectsApi = new ObjectsApi_default(objectsApiSession, objectsApiConfigResponse.data);
+        }
+      }
+    }
+  }
+  async createStudioApi(sessionToken) {
+    const studioApiConfigResponse = JSON.parse(await this.configuration.getStudioApiConfig());
+    if (studioApiConfigResponse && studioApiConfigResponse["data"]) {
+      const studioApiSession = sessionToken.createCopy();
+      studioApiSession.baseUrl = studioApiConfigResponse.data["studioApiUrl"];
+      studioApiSession.apiUrl = "";
+      if (studioApiSession["tokenType"] == "jwt") {
+        this._studioApi = new StudioApi_default(studioApiSession, studioApiConfigResponse.data);
+      } else if (this.users) {
+        const jwtResponse = JSON.parse(await this.users.getUserJwt(studioApiSession.audience));
+        if (jwtResponse["data"] && jwtResponse["data"]["token"]) {
+          studioApiSession.convertToJwt(jwtResponse["data"]);
+          this._studioApi = new StudioApi_default(studioApiSession, studioApiConfigResponse.data);
+        }
+      }
+    }
+  }
+  async createNotificationsApi(sessionToken) {
+    const notificationsApiConfigResponse = JSON.parse(await this.configuration.getNotificationsApiConfig());
+    if (notificationsApiConfigResponse && notificationsApiConfigResponse["data"]) {
+      const notificationsApiSession = sessionToken.createCopy();
+      notificationsApiSession.baseUrl = notificationsApiConfigResponse.data["apiUrl"];
+      notificationsApiSession.apiUrl = this.yamlConfig.NotificationsApiUri;
+      if (notificationsApiSession["tokenType"] == "jwt") {
+        this._notificationsApi = new NotificationsApi_default(notificationsApiSession, notificationsApiConfigResponse.data);
+      } else if (this.users) {
+        const jwtResponse = JSON.parse(await this.users.getUserJwt(notificationsApiSession.audience));
+        if (jwtResponse["data"] && jwtResponse["data"]["token"]) {
+          notificationsApiSession.convertToJwt(jwtResponse["data"]);
+          this._notificationsApi = new NotificationsApi_default(notificationsApiSession, notificationsApiConfigResponse.data);
+        }
+      }
+    }
+  }
+  async _convertToJwt(sessionToken) {
+    const jwtResponse = JSON.parse(await this.users.getUserJwt(sessionToken.audience));
+    if (jwtResponse["data"] && jwtResponse["data"]["token"]) {
+      sessionToken.convertToJwt(jwtResponse["data"]);
+    } else {
+      throw new Error("Failed to get JWT: API response missing data.token property");
+    }
+  }
+  endsWith(source, suffix) {
+    return source.indexOf(suffix, source.length - suffix.length) !== -1;
+  }
+  /**
+   * Get the current security token
+   * @returns {string} The access token
+   */
+  getSecurityToken() {
+    return this._httpHelper._sessionToken.accessToken;
+  }
+  /**
+   * Check if the client is authenticated
+   * @returns {boolean} True if authenticated
+   */
+  isAuthenticated() {
+    return this._httpHelper._sessionToken.isAuthenticated;
+  }
+  /**
+   * Get the base URL
+   * @returns {string} The base URL
+   */
+  getBaseUrl() {
+    return this._httpHelper._sessionToken.baseUrl;
+  }
+};
+var Authorize2 = class extends common_default.authorize {
+  /**
+   * Authenticate and get a VaultApi client instance
+   * @param {string} clientId - OAuth client ID
+   * @param {string} clientSecret - OAuth client secret
+   * @param {string} userId - User username
+   * @param {string} password - User password
+   * @param {string} audience - OAuth audience
+   * @param {string} baseVaultUrl - VisualVault base URL
+   * @param {string} customerAlias - Customer alias
+   * @param {string} databaseAlias - Database alias
+   * @returns {Promise<VVClient>} Authenticated client instance
+   */
+  async getVaultApi(clientId, clientSecret, userId, password, audience, baseVaultUrl, customerAlias, databaseAlias) {
+    debug5("getVaultApi called for user: %s, customer: %s/%s", userId, customerAlias, databaseAlias);
+    const config = this.jsyaml.load(this.fs.readFileSync(__dirname7 + "/config.yml", "utf8"));
+    if (this.endsWith(baseVaultUrl, "/")) {
+      baseVaultUrl = baseVaultUrl.substring(0, baseVaultUrl.length - 1);
+    }
+    const apiUrl = config.ApiUri.replace("{custalias}", customerAlias).replace("{custdbalias}", databaseAlias);
+    const authenticationUrl = config.AutheticateUri;
+    const sessionToken = await this.acquireSecurityToken(clientId, clientSecret, userId, password, audience, baseVaultUrl, apiUrl, customerAlias, databaseAlias, authenticationUrl);
+    const client = new VVClient(sessionToken);
+    try {
+      await client._convertToJwt(sessionToken);
+      await Promise.all([
+        client.createDocApi(sessionToken),
+        client.createFormsApi(sessionToken),
+        client.createObjectsApi(sessionToken),
+        client.createStudioApi(sessionToken),
+        client.createNotificationsApi(sessionToken)
+      ]);
+      return client;
+    } catch (error) {
+      debug5("Failed to convert to JWT or create specialized APIs: %s", error.message);
+      return client;
+    }
+  }
+  /**
+   * Get a VaultApi client from an existing JWT token
+   * @param {string} jwt - JWT authentication token
+   * @param {string} baseVaultUrl - VisualVault base URL
+   * @param {string} customerAlias - Customer alias
+   * @param {string} databaseAlias - Database alias
+   * @param {Date} expirationDate - Token expiration date
+   * @returns {Promise<VVClient>} Authenticated client instance
+   */
+  async getVaultApiFromJwt(jwt, baseVaultUrl, customerAlias, databaseAlias, expirationDate) {
+    debug5("getVaultApiFromJwt called for customer: %s/%s", customerAlias, databaseAlias);
+    const config = this.jsyaml.load(this.fs.readFileSync(__dirname7 + "/config.yml", "utf8"));
+    if (this.endsWith(baseVaultUrl, "/")) {
+      baseVaultUrl = baseVaultUrl.substring(0, baseVaultUrl.length - 1);
+    }
+    const apiUrl = config.ApiUri.replace("{custalias}", customerAlias).replace("{custdbalias}", databaseAlias);
+    const authenticationUrl = apiUrl + config.ResourceUri.UsersGetJwt;
+    if (expirationDate && expirationDate >= new Date((/* @__PURE__ */ new Date()).getTime() + 30 * 1e3)) {
+      const sessionToken = new common_default.sessionToken();
+      sessionToken.accessToken = jwt;
+      sessionToken.baseUrl = baseVaultUrl;
+      sessionToken.apiUrl = apiUrl;
+      sessionToken.authenticationUrl = authenticationUrl;
+      sessionToken.customerAlias = customerAlias;
+      sessionToken.databaseAlias = databaseAlias;
+      sessionToken.expirationDate = expirationDate;
+      sessionToken.isAuthenticated = true;
+      sessionToken.isJwt = true;
+      const client = new VVClient(sessionToken);
+      return Promise.all([
+        client.createDocApi(sessionToken),
+        client.createFormsApi(sessionToken),
+        client.createObjectsApi(sessionToken),
+        client.createStudioApi(sessionToken)
+      ]).then(() => client).catch((error) => {
+        debug5("Failed to create specialized APIs: %s", error.message);
+        return client;
+      });
+    } else {
+      const token = await this.acquireJwt(jwt, baseVaultUrl, apiUrl, authenticationUrl, customerAlias, databaseAlias);
+      const client = new VVClient(token);
+      try {
+        await Promise.all([
+          client.createDocApi(token),
+          client.createFormsApi(token),
+          client.createObjectsApi(token),
+          client.createStudioApi(token)
+        ]);
+        return client;
+      } catch (error) {
+        debug5("Failed to create specialized APIs: %s", error.message);
+        return client;
+      }
+    }
+  }
+  endsWith(source, suffix) {
+    return source.indexOf(suffix, source.length - suffix.length) !== -1;
+  }
+};
+var forms = {
+  returnField: ReturnField,
+  formFieldCollection: FormFieldCollection
+};
+var VVRestApi_default = {
+  vvClient: VVClient,
+  authorize: Authorize2,
+  forms
+};
+
+// lib/constants.js
+init_esm_shims();
+var RoleType = Object.freeze({
+  None: 0,
+  Owner: 1,
+  Editor: 2,
+  Publisher: 3,
+  Viewer: 4,
+  Member: 5
+});
+var MemberType = Object.freeze({
+  User: 0,
+  Group: 1
+});
+export {
+  Authorize2 as Authorize,
+  MemberType,
+  RoleType,
+  VVClient,
+  VVRestApi_default as default
+};
+//# sourceMappingURL=index.js.map