@verdocs/js-sdk 3.10.30 → 4.0.0

package/dist/index.mjs

@@ -0,0 +1,3036 @@
+import axios from 'axios';
+
+var Models = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+/* tslint:disable:no-bitwise */
+const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+// Regular expression to check formal correctness of base64 encoded strings
+const b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+/**
+ * Simplified, Node/Browser-safe alternative to atob() for base64 decoding.
+ * Modified from https://github.com/MaxArt2501/base64-js/blob/master/base64.js
+ */
+const AtoB = (str) => {
+    // atob can work with strings with whitespaces, even inside the encoded part,
+    // but only \t, \n, \f, \r and ' ', which can be stripped.
+    str = String(str).replace(/[\t\n\f\r ]+/g, '');
+    if (!b64re.test(str))
+        throw new TypeError("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
+    // Adding the padding if missing, for semplicity
+    str += '=='.slice(2 - (str.length & 3));
+    let bitmap;
+    let result = '';
+    let r1;
+    let r2;
+    let i = 0;
+    for (; i < str.length;) {
+        bitmap =
+            (b64.indexOf(str.charAt(i++)) << 18) |
+                (b64.indexOf(str.charAt(i++)) << 12) |
+                ((r1 = b64.indexOf(str.charAt(i++))) << 6) |
+                (r2 = b64.indexOf(str.charAt(i++)));
+        result +=
+            r1 === 64
+                ? String.fromCharCode((bitmap >> 16) & 255)
+                : r2 === 64
+                    ? String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255)
+                    : String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255, bitmap & 255);
+    }
+    return result;
+};
+/**
+ * Decode the body of a JWT. This helper may allow front-end applications to avoid a dependency on `jsonwebtoken` in
+ * many cases. Note that this should only be used for true JWTs. Opaque tokens will cause this to throw.
+ */
+const decodeJWTBody = (token) => JSON.parse(AtoB((token || '').split('.')[1] || ''));
+/**
+ * Decode the body of an Verdocs access token. Note that raw tokens contain namespaced fields, e.g.
+ * `https://verdocs.com/profile_id`. To make these tokens easier to use in front-end code, this name-spacing
+ * will be removed. Note that user and signing sessions have different access token formats. The calling
+ * application should distinguish between the two based on the context of the authenticated session, or by
+ * the presence of the `document_id` field, which will only be present for signing sessions.
+ */
+const decodeAccessTokenBody = (token) => {
+    let decoded;
+    try {
+        decoded = decodeJWTBody(token);
+        if (decoded === null) {
+            return null;
+        }
+    }
+    catch (e) {
+        return null;
+    }
+    Object.keys(decoded).forEach((key) => {
+        if (typeof key === 'string' && key.startsWith('https://verdocs.com/')) {
+            decoded[key.replace('https://verdocs.com/', '')] = decoded[key];
+            delete decoded[key];
+        }
+    });
+    return decoded;
+};
+
+var Token = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AtoB: AtoB,
+  decodeAccessTokenBody: decodeAccessTokenBody,
+  decodeJWTBody: decodeJWTBody
+});
+
+/**
+ * Create an envelope
+ *
+ * ```typescript
+ * import {Envelopes, ICreateEnvelopeRole, ICreateEnvelopeRequest} from '@verdocs/js-sdk/Envelopes';
+ *
+ * const role1: ICreateEnvelopeRole = {
+ *   type: 'signer',
+ *   name: 'Seller',
+ *   full_name: 'Paige Turner',
+ *   email: 'paige.turner@nomail.com',
+ *   phone: '',
+ *   sequence: 1,
+ *   delegator: false,
+ *   message: '',
+ * };
+ *
+ * const role2: ICreateEnvelopeRole = {
+ *   type: 'signer',
+ *   name: 'Buyer',
+ *   full_name: 'Will Power',
+ *   email: 'will.power@nomail.com',
+ *   phone: '',
+ *   sequence: 2,
+ *   delegator: false,
+ *   message: '',
+ * };
+ *
+ * const request: ICreateEnvelopeRequest = {template_id: 'd2338742-f3a1-465b-8592-806587413cc1', name: 'Bill of Sale', roles: [role1, role2]};
+ * const {id, recipients} = await Envelopes.createEnvelope(VerdocsEndpoint.getDefault(), request);
+ * ```
+ */
+const createEnvelope = async (endpoint, request) => endpoint.api //
+    .post('/envelopes', request)
+    .then((r) => r.data);
+/**
+ * Get a summary of currently active envelopes.
+ *
+ * ```typescript
+ * import {Envelopes} from '@verdocs/js-sdk/Envelopes';
+ *
+ * const {action_required, completed, waiting_on_others} = await Envelopes.getSummary(VerdocsEndpoint.getDefault());
+ * ```
+ */
+const getSummary$1 = async (endpoint, page) => endpoint.api //
+    .post('/envelopes/summary', { page })
+    .then((r) => r.data);
+/**
+ * Search for envelopes matching various criteria.
+ *
+ * ```typescript
+ * import {Envelopes} from '@verdocs/js-sdk/Envelopes';
+ *
+ * const {result, page, total} = await Envelopes.search(VerdocsEndpoint.getDefault(), { ... });
+ * ```
+ */
+const searchEnvelopes = async (endpoint, params) => endpoint.api //
+    .post('/envelopes/search', params)
+    .then((r) => r.data);
+/**
+ * Get a signing session for an Envelope.
+ */
+const getSigningSession = async (endpoint, params) => {
+    window.console.log('[JS_SDK] getSigningSession', params, endpoint.api);
+    return endpoint.api //
+        .get(`/envelopes/${params.envelopeId}/recipients/${encodeURIComponent(params.roleId)}/invitation/${params.inviteCode}`)
+        .then((r) => {
+        // Avoiding a jsonwebtoken dependency here - we don't actually need the whole library
+        const signerToken = r.headers?.signer_token || '';
+        const session = decodeAccessTokenBody(signerToken);
+        endpoint.setToken(signerToken);
+        return { recipient: r.data, session, signerToken };
+    });
+};
+/**
+ * Get the list of recipients for an Envelope.
+ */
+const getEnvelopeRecipients = async (endpoint, envelopeId) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/recipients`)
+    .then((r) => r.data);
+/**
+ * Get all metadata for an Envelope.
+ */
+const getEnvelope = async (endpoint, envelopeId) => endpoint.api //
+    .get(`/envelopes/${envelopeId}`)
+    .then((r) => r.data);
+/**
+ * Get an Envelope Document
+ */
+const getEnvelopeDocument = async (endpoint, envelopeId, documentId) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/envelope_documents/${documentId}`)
+    .then((r) => r.data);
+/**
+ * Get a pre-signed download link for an Envelope Document. This link expires quickly, so it should
+ * be accessed immediately and never shared. Content-Disposition will be set to "download".
+ */
+const getDocumentDownloadLink = async (endpoint, envelopeId, documentId) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/envelope_documents/${documentId}?download=true`)
+    .then((r) => r.data);
+/**
+ * Get a pre-signed preview link for an Envelope Document. This link expires quickly, so it should
+ * be accessed immediately and never shared. Content-Disposition will be set to "inline".
+ */
+const getDocumentPreviewLink = async (endpoint, envelopeId, documentId) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/envelope_documents/${documentId}?preview=true`)
+    .then((r) => r.data);
+/**
+ * Cancel an Envelope.
+ */
+const cancelEnvelope = async (endpoint, envelopeId) => endpoint.api //
+    .put(`/envelopes/${envelopeId}`, { action: 'cancel' })
+    .then((r) => r.data);
+/**
+ * Get (binary download) a file attached to an Envelope. It is important to use this method
+ * rather than a direct A HREF or similar link to set the authorization headers for the
+ * request.
+ */
+const getEnvelopeFile = async (endpoint, envelopeId, documentId) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/envelope_documents/${documentId}?file=true`, { responseType: 'blob' })
+    .then((r) => r.data);
+/**
+ * Update a Document field. Typically called during the signing process as a Recipient fills in fields.
+ */
+const updateEnvelopeField = async (endpoint, envelopeId, fieldName, value) => endpoint.api //
+    .put(`/envelopes/${envelopeId}/fields/${fieldName}`, value)
+    .then((r) => r.data);
+/**
+ * Update a Document signature field. Signature fields are ID-driven. Call `Document.createSignature()` first to create a
+ * signature for a Recipient, then call `Documents.updateDocumentFieldSignature()` to attach it to a field.
+ */
+const updateEnvelopeFieldSignature = async (endpoint, envelopeId, fieldName, signatureId) => endpoint.api //
+    .put(`/envelopes/${envelopeId}/fields/${fieldName}/signature/${signatureId}`)
+    .then((r) => r.data);
+/**
+ * Update a Document signature field. Signature fields are ID-driven. Call `Document.createSignature()` first to create a
+ * signature for a Recipient, then call `Documents.updateDocumentFieldSignature()` to attach it to a field.
+ */
+const updateEnvelopeFieldInitials = async (endpoint, envelopeId, fieldName, initialId) => endpoint.api //
+    .put(`/envelopes/${envelopeId}/fields/${fieldName}/initial/${initialId}`)
+    .then((r) => r.data);
+/**
+ * Upload an attachment.
+ */
+const uploadEnvelopeFieldAttachment = async (endpoint, envelopeId, fieldName, file, onUploadProgress) => {
+    const formData = new FormData();
+    formData.append('document', file, file.name);
+    return endpoint.api //
+        .put(`/envelopes/${envelopeId}/fields/${fieldName}`, formData, {
+        timeout: 120000,
+        onUploadProgress: (event) => {
+            const total = event.total || 1;
+            const loaded = event.loaded || 0;
+            onUploadProgress?.(Math.floor((loaded * 100) / (total || 1)), loaded, total || 1);
+        },
+    })
+        .then((r) => r.data);
+};
+/**
+ * Delete an attachment.
+ */
+const deleteEnvelopeFieldAttachment = async (endpoint, envelopeId, fieldName, file, onUploadProgress) => {
+    const formData = new FormData();
+    // Omitting file is the trigger here
+    return endpoint.api //
+        .put(`/envelopes/${envelopeId}/fields/${fieldName}`, formData, {
+        timeout: 120000,
+        onUploadProgress: (event) => {
+            const total = event.total || 1;
+            const loaded = event.loaded || 0;
+            onUploadProgress?.(Math.floor((loaded * 100) / (total || 1)), loaded, total || 1);
+        },
+    })
+        .then((r) => r.data);
+};
+/**
+ * Get the attached file for an attachment field (if any)
+ */
+const getFieldAttachment = async (endpoint, envelopeId, fieldName) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/fields/${fieldName}/document`, { responseType: 'blob' })
+    .then((r) => r.data);
+/**
+ * Get a display URI for a given page in a file attached to an envelope document. These pages are rendered server-side
+ * into PNG resources suitable for display in IMG tags although they may be used elsewhere. Note that these are intended
+ * for DISPLAY ONLY, are not legally binding documents, and do not contain any encoded metadata from participants.
+ */
+const getEnvelopeDocumentPageDisplayUri = async (endpoint, envelopeId, documentId, page, type = 'original') => endpoint.api
+    .get(`/envelopes/${envelopeId}/envelope_documents/${documentId}/pages/${page}/image?type=${type}`, { timeout: 20000 })
+    .then((r) => r.data);
+const cachedEnvelopes = {};
+/**
+ * Wrapper for `getEnvelope()` that limits queries to one every 2 seconds per template ID.
+ * This is intended for use in component hierarchies that all rely on the same template
+ * to avoid unnecessary repeat server calls.
+ */
+const throttledGetEnvelope = (endpoint, envelopeId) => {
+    if (cachedEnvelopes[envelopeId] && cachedEnvelopes[envelopeId].loaded + 2000 < new Date().getTime()) {
+        return cachedEnvelopes[envelopeId].envelope;
+    }
+    return getEnvelope(endpoint, envelopeId).then((envelope) => {
+        cachedEnvelopes[envelopeId] = { loaded: new Date().getTime(), envelope };
+        return envelope;
+    });
+};
+/**a
+ * Lists all envelopes accessible by the caller, with optional filters.
+ *
+ * ```typescript
+ * import {Envelopes} from '@verdocs/js-sdk/Envelopes';
+ *
+ * const {totals, envelopes} = await Envelopes.listEnvelopes((VerdocsEndpoint.getDefault(), { q: 'test', sort: 'created_at' });
+ * ```
+ */
+const listEnvelopes = (endpoint, params) => endpoint.api //
+    .post('/envelopes/list', params)
+    .then((r) => r.data);
+
+var Envelopes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  cancelEnvelope: cancelEnvelope,
+  createEnvelope: createEnvelope,
+  deleteEnvelopeFieldAttachment: deleteEnvelopeFieldAttachment,
+  getDocumentDownloadLink: getDocumentDownloadLink,
+  getDocumentPreviewLink: getDocumentPreviewLink,
+  getEnvelope: getEnvelope,
+  getEnvelopeDocument: getEnvelopeDocument,
+  getEnvelopeDocumentPageDisplayUri: getEnvelopeDocumentPageDisplayUri,
+  getEnvelopeFile: getEnvelopeFile,
+  getEnvelopeRecipients: getEnvelopeRecipients,
+  getFieldAttachment: getFieldAttachment,
+  getSigningSession: getSigningSession,
+  getSummary: getSummary$1,
+  listEnvelopes: listEnvelopes,
+  searchEnvelopes: searchEnvelopes,
+  throttledGetEnvelope: throttledGetEnvelope,
+  updateEnvelopeField: updateEnvelopeField,
+  updateEnvelopeFieldInitials: updateEnvelopeFieldInitials,
+  updateEnvelopeFieldSignature: updateEnvelopeFieldSignature,
+  uploadEnvelopeFieldAttachment: uploadEnvelopeFieldAttachment
+});
+
+/**
+ * Various helpers to identify available operations for an envelope by a user.
+ *
+ * @module
+ */
+/**
+ * Check to see if the user owns the envelope.
+ */
+const userIsEnvelopeOwner = (session, envelope) => envelope.profile_id === session?.profile_id;
+/**
+ * Check to see if the user owns the envelope.
+ */
+const userIsEnvelopeRecipient = (session, envelope) => envelope.profile_id === session?.profile_id;
+/**
+ * Check to see if the envelope has pending actions.
+ */
+const envelopeIsActive = (envelope) => envelope.status !== 'complete' && envelope.status !== 'declined' && envelope.status !== 'canceled';
+/**
+ * Check to see if the envelope has been completed.
+ */
+const envelopeIsComplete = (envelope) => envelope.status !== 'complete';
+/**
+ * Check to see if the user owns the envelope.
+ */
+const userCanCancelEnvelope = (session, envelope) => userIsEnvelopeOwner(session, envelope) &&
+    envelope.status !== 'complete' &&
+    envelope.status !== 'declined' &&
+    envelope.status !== 'canceled';
+/**
+ * Check to see if the user owns the envelope.
+ */
+const userCanFinishEnvelope = (session, envelope) => userIsEnvelopeOwner(session, envelope) &&
+    envelope.status !== 'complete' &&
+    envelope.status !== 'declined' &&
+    envelope.status !== 'canceled';
+/**
+ * Returns true if the recipient has a pending action. Note that this does not necessarily mean the recipient can act (yet).
+ */
+const recipientHasAction = (recipient) => !['submitted', 'canceled', 'declined'].includes(recipient.status);
+/**
+ * Returns the recipients who still have a pending action. Note that not all of these recipients may be able to act (yet).
+ */
+const getRecipientsWithActions = (envelope) => (envelope?.recipients || []).filter(recipientHasAction);
+/**
+ * Returns true if the recipient can act.
+ */
+const recipientCanAct = (recipient, recipientsWithActions) => recipient.sequence === recipientsWithActions?.[0]?.sequence;
+/**
+ * Returns true if the user can act.
+ */
+const userCanAct = (email, recipientsWithActions) => {
+    const recipient = recipientsWithActions.find((r) => r.email === email);
+    return recipient && recipient.sequence === recipientsWithActions?.[0]?.sequence;
+};
+/**
+ * Returns true if the user can act.
+ */
+const userCanSignNow = (session, envelope) => {
+    if (!session) {
+        return false;
+    }
+    const recipientsWithActions = getRecipientsWithActions(envelope);
+    const myRecipient = recipientsWithActions.find((r) => r.profile_id === session?.profile_id || r.email === session?.email);
+    return (myRecipient &&
+        envelopeIsActive(envelope) &&
+        userIsEnvelopeRecipient(session, envelope) &&
+        recipientCanAct(myRecipient, recipientsWithActions));
+};
+const getNextRecipient = (envelope) => {
+    const recipientsWithActions = getRecipientsWithActions(envelope);
+    return recipientsWithActions?.[0];
+};
+
+var Permissions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  envelopeIsActive: envelopeIsActive,
+  envelopeIsComplete: envelopeIsComplete,
+  getNextRecipient: getNextRecipient,
+  getRecipientsWithActions: getRecipientsWithActions,
+  recipientCanAct: recipientCanAct,
+  recipientHasAction: recipientHasAction,
+  userCanAct: userCanAct,
+  userCanCancelEnvelope: userCanCancelEnvelope,
+  userCanFinishEnvelope: userCanFinishEnvelope,
+  userCanSignNow: userCanSignNow,
+  userIsEnvelopeOwner: userIsEnvelopeOwner,
+  userIsEnvelopeRecipient: userIsEnvelopeRecipient
+});
+
+/**
+ * Update a recipient's status block
+ */
+const updateRecipient = async (endpoint, envelopeId, roleName, params) => endpoint.api //
+    .put(`/envelopes/${envelopeId}/recipients/${roleName}`, params)
+    .then((r) => r.data);
+/**
+ * Submit an envelope (signing is finished). Note that all fields must be valid/completed for this to succeed.
+ */
+const envelopeRecipientSubmit = (endpoint, envelopeId, roleName) => updateRecipient(endpoint, envelopeId, roleName, { action: 'submit' });
+/**
+ * Decline to complete an envelope (signing will not terminated).
+ */
+const envelopeRecipientDecline = (endpoint, envelopeId, roleName) => updateRecipient(endpoint, envelopeId, roleName, { action: 'decline' });
+/**
+ * Claim / change ownership of an envelope. This is a special-case operation only available in certain workflows.
+ */
+const envelopeRecipientChangeOwner = (endpoint, envelopeId, roleName, email, fullName) => updateRecipient(endpoint, envelopeId, roleName, { action: 'owner_update', email, full_name: fullName });
+/**
+ * Agree to electronic signing.
+ */
+const envelopeRecipientAgree = (endpoint, envelopeId, roleName, agreed) => updateRecipient(endpoint, envelopeId, roleName, { action: 'update', agreed });
+/**
+ * Change a recipient's name.
+ */
+const envelopeRecipientUpdateName = (endpoint, envelopeId, roleName, fullName) => updateRecipient(endpoint, envelopeId, roleName, { action: 'update', new_full_name: fullName });
+/**
+ * Change a recipient's name.
+ */
+const envelopeRecipientPrepare = (endpoint, envelopeId, roleName, recipients) => updateRecipient(endpoint, envelopeId, roleName, { action: 'prepare', recipients });
+/**
+ * Get a signing token.
+ */
+const getSignerToken = (endpoint, envelopeId, roleName) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/recipients/${encodeURIComponent(roleName)}/signer-token`)
+    .then((r) => r.data);
+/**
+ * Get an in-person signing link.
+ */
+const getInPersonLink = (endpoint, envelopeId, roleName) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/recipients/${encodeURIComponent(roleName)}?in_person_link=true`)
+    .then((r) => r.data);
+/**
+ * Send a delegation request.
+ */
+const sendDelegate = (endpoint, envelopeId, roleName) => endpoint.api //
+    .post(`/envelopes/${envelopeId}/recipients/${encodeURIComponent(roleName)}/delegate`)
+    .then((r) => r.data);
+/**
+ * Resend a recipient's invitation.
+ */
+const resendInvitation$1 = (endpoint, envelopeId, roleName) => endpoint.api //
+    .post(`/envelopes/${envelopeId}/recipients/${encodeURIComponent(roleName)}/resend_invitation`)
+    .then((r) => r.data);
+
+var Recipients = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  envelopeRecipientAgree: envelopeRecipientAgree,
+  envelopeRecipientChangeOwner: envelopeRecipientChangeOwner,
+  envelopeRecipientDecline: envelopeRecipientDecline,
+  envelopeRecipientPrepare: envelopeRecipientPrepare,
+  envelopeRecipientSubmit: envelopeRecipientSubmit,
+  envelopeRecipientUpdateName: envelopeRecipientUpdateName,
+  getInPersonLink: getInPersonLink,
+  getSignerToken: getSignerToken,
+  resendInvitation: resendInvitation$1,
+  sendDelegate: sendDelegate,
+  updateRecipient: updateRecipient
+});
+
+/**
+ * Enable automatic reminders. setup_time is the number of days after the envelope is sent that the first reminder
+ * should be sent. interval_time is the number of days between reminders.
+ */
+const createReminder$1 = (endpoint, envelopeId, params) => endpoint.api //
+    .post(`/envelopes/${envelopeId}/reminder/`, params)
+    .then((r) => r.data);
+/**
+ * Get the reminder configuration for an envelope.
+ */
+const getReminder$1 = (endpoint, envelopeId, reminderId) => endpoint.api //
+    .get(`/envelopes/${envelopeId}/reminder/${reminderId}`)
+    .then((r) => r.data);
+/**
+ * Update the reminder configuration for an envelope.
+ */
+const updateReminder$1 = (endpoint, envelopeId, reminderId, params) => endpoint.api //
+    .put(`/envelopes/${envelopeId}/reminder/${reminderId}`, params)
+    .then((r) => r.data);
+/**
+ * Delete the reminder configuration for an envelope.
+ */
+const deleteReminder$1 = (endpoint, envelopeId, reminderId) => endpoint.api //
+    .delete(`/envelopes/${envelopeId}/reminder/${reminderId}`)
+    .then((r) => r.data);
+
+var Reminders$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createReminder: createReminder$1,
+  deleteReminder: deleteReminder$1,
+  getReminder: getReminder$1,
+  updateReminder: updateReminder$1
+});
+
+/**
+ * Create a signature block. In a typical signing workflow, the user is asked at the beginning of the process to "adopt"
+ * a signature block to be used for all signature fields in the document. Thus, this is typically called one time to
+ * create and store a signature block. Thereafter, the ID of the signature block may be re-used for each signature field
+ * to be "stamped" by the user.
+ */
+const createSignature = (endpoint, name, signature) => {
+    const data = new FormData();
+    data.append('signature', signature, name);
+    return endpoint.api //
+        .post(`/signatures`, data)
+        .then((r) => r.data);
+};
+/**
+ * Get the availbable signatures for a user.
+ */
+const getSignatures = (endpoint) => endpoint.api //
+    .get('/signatures')
+    .then((r) => r.data);
+/**
+ * Get a user's signature by ID.
+ */
+const getSignature = (endpoint, signatureId) => endpoint.api //
+    .get(`/signatures/${signatureId}`)
+    .then((r) => r.data);
+/**
+ * Delete a user's signature.
+ */
+const deleteSignature = (endpoint, signatureId) => endpoint.api //
+    .delete(`/signatures/${signatureId}`)
+    .then((r) => r.data);
+
+var Signatures = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createSignature: createSignature,
+  deleteSignature: deleteSignature,
+  getSignature: getSignature,
+  getSignatures: getSignatures
+});
+
+/**
+ * Create an initials block. In a typical signing workflow, the user is asked at the beginning of the process to "adopt"
+ * an initials block to be used for all initials fields in the document. Thus, this is typically called one time to
+ * create and store an initials block. Thereafter, the ID of the initials block may be re-used for each initials field
+ * to be "stamped" by the user.
+ */
+const createInitials = (endpoint, name, initials) => {
+    const data = new FormData();
+    data.append('initial', initials, name);
+    return endpoint.api //
+        .post(`/initials`, data)
+        .then((r) => r.data);
+};
+
+var Initials = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createInitials: createInitials
+});
+
+var Types$5 = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var index$5 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Envelopes: Envelopes,
+  Initials: Initials,
+  Permissions: Permissions,
+  Recipients: Recipients,
+  Reminders: Reminders$1,
+  Signatures: Signatures,
+  Types: Types$5
+});
+
+/**
+ * API keys are used to authenticate server-to-server calls. (API keys should **never** be used for client-to-server operations!)
+ * To generate a key, either use the Verdocs admin interface and make note of the client_id and client_secret generated, or call
+ * createKey as shown below. Then call {@link Users.Auth.authenticateApp} to obtain an access token using the provided ID and
+ * secret. Note that server-to-server authentication requests return shorter-lived tokens, so it is important to check the `exp`
+ * field and re-authenticate as needed for subsequent calls.
+ *
+ * API keys may be updated or rotated at any time. Regular rotation is recommended. Rotation will not expire or invalidate
+ * existing server-to-server sessions, so it may be done at any time without disrupting your application.
+ *
+ * @module
+ */
+/**
+ * Get a list of keys for a given organization. The caller must have admin access to the organization.
+ *
+ * ```typescript
+ * import {ApiKeys} from '@verdocs/js-sdk/Organizations';
+ *
+ * const keys = await ApiKeys.getKeys(ORGID);
+ * ```
+ */
+const getKeys = (endpoint, organizationId) => endpoint.api //
+    .get(`/organizations/${organizationId}/api_key`)
+    .then((r) => r.data);
+/**
+ * Create an API key.
+ *
+ * ```typescript
+ * import {ApiKeys} from '@verdocs/js-sdk/Organizations';
+ *
+ * await ApiKeys.createKey(ORGID, {name: NEWNAME});
+ * ```
+ */
+const createKey = (endpoint, organizationId, params) => endpoint.api //
+    .post(`/organizations/${organizationId}/api_key`, params)
+    .then((r) => r.data);
+/**
+ * Rotate the secret for an API key. The caller must have admin access to the organization.
+ *
+ * ```typescript
+ * import {ApiKeys} from '@verdocs/js-sdk/Organizations';
+ *
+ * const {client_secret: newSecret} = await ApiKeys.rotateKey(ORGID, CLIENTID);
+ * ```
+ */
+const rotateKey = (endpoint, organizationId, clientId) => endpoint.api //
+    .put(`/organizations/${organizationId}/api_key/${clientId}/rotate`)
+    .then((r) => r.data);
+/**
+ * Update an API key to change its assigned Profile ID or Name.
+ *
+ * ```typescript
+ * import {ApiKeys} from '@verdocs/js-sdk/Organizations';
+ *
+ * await ApiKeys.updateKey(ORGID, CLIENTID, {name: NEWNAME});
+ * ```
+ */
+const updateKey = (endpoint, organizationId, clientId, params) => endpoint.api //
+    .patch(`/organizations/${organizationId}/api_key/${clientId}`, params)
+    .then((r) => r.data);
+/**
+ * Delete an API key.
+ *
+ * ```typescript
+ * import {ApiKeys} from '@verdocs/js-sdk/Organizations';
+ *
+ * await ApiKeys.deleteKey(ORGID, CLIENTID);
+ * ```
+ */
+const deleteKey = (endpoint, organizationId, clientId) => endpoint.api //
+    .delete(`/organizations/${organizationId}/api_key/${clientId}`)
+    .then((r) => r.data);
+
+var ApiKeys = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createKey: createKey,
+  deleteKey: deleteKey,
+  getKeys: getKeys,
+  rotateKey: rotateKey,
+  updateKey: updateKey
+});
+
+/**
+ * Organizations may contain "Groups" of user profiles, called Members. Groups may have permissions assigned that
+ * apply to all Members, making it easy to configure role-based access control (RBAC) within an Organization. Note
+ * that permissions are **additive**. A user may be a member of more than one group, and may also have permissions
+ * assigned directly. In that case, the user will have the combined set of all permissions inherited from all
+ * sources.
+ *
+ * @module
+ */
+/**
+ * Get a list of groups for a given organization. The caller must have admin access to the organization.
+ *
+ * ```typescript
+ * import {Groups} from '@verdocs/js-sdk/Organizations';
+ *
+ * const groups = await Groups.getGroups(ORGID);
+ * ```
+ */
+const getGroups = (endpoint, organizationId) => endpoint.api //
+    .get(`/organizations/${organizationId}/groups`)
+    .then((r) => r.data);
+/**
+ * Get a single group by name. Returns a detail record.
+ *
+ * ```typescript
+ * import {Groups} from '@verdocs/js-sdk/Organizations';
+ *
+ * const groups = await Groups.getGroups(ORGID);
+ * ```
+ */
+const getGroupByName = (endpoint, organizationId, name) => endpoint.api //
+    .get(`/organizations/${organizationId}/groups`, { params: { name } })
+    .then((r) => r.data);
+/**
+ * Get the details for a group.
+ *
+ * ```typescript
+ * import {Groups} from '@verdocs/js-sdk/Organizations';
+ *
+ * const groups = await Groups.getGroups(ORGID);
+ * ```
+ */
+const getGroup = (endpoint, organizationId, groupId) => endpoint.api //
+    .get(`/organizations/${organizationId}/groups/${groupId}`)
+    .then((r) => r.data);
+const getMembers$1 = (endpoint, organizationId, groupId) => endpoint.api //
+    .get(`/organizations/${organizationId}/groups/${groupId}/members`)
+    .then((r) => r.data);
+const addMembers = (endpoint, organizationId, groupId, params) => endpoint.api //
+    .post(`/organizations/${organizationId}/groups/${groupId}/members`, params)
+    .then((r) => r.data);
+const deleteMembers = (endpoint, organizationId, groupId, params) => endpoint.api //
+    .put(`/organizations/${organizationId}/groups/${groupId}/delete_members`, params)
+    .then((r) => r.data);
+const addPermission = (endpoint, organizationId, groupId, permissionId) => endpoint.api //
+    .post(`/organizations/${organizationId}/groups/${groupId}/permissions/${permissionId}`, {})
+    .then((r) => r.data);
+const deletePermission = (endpoint, organizationId, groupId, permissionId) => endpoint.api //
+    .delete(`/organizations/${organizationId}/groups/${groupId}/permissions/${permissionId}`)
+    .then((r) => r.data);
+
+var Groups = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  addMembers: addMembers,
+  addPermission: addPermission,
+  deleteMembers: deleteMembers,
+  deletePermission: deletePermission,
+  getGroup: getGroup,
+  getGroupByName: getGroupByName,
+  getGroups: getGroups,
+  getMembers: getMembers$1
+});
+
+/**
+ * An invitation represents an opportunity for a Member to join an Organization.
+ *
+ * @module
+ */
+const getInvitations = (endpoint, organizationId) => endpoint.api //
+    .get(`/organizations/${organizationId}/invitation`)
+    .then((r) => r.data);
+const createInvitation = (endpoint, organizationId, params) => endpoint.api //
+    .post(`/organizations/${organizationId}/invitation`, params)
+    .then((r) => r.data);
+const deleteInvitation = (endpoint, organizationId, email) => endpoint.api //
+    .delete(`/organizations/${organizationId}/invitation/${email}`)
+    .then((r) => r.data);
+const updateInvitation = (endpoint, organizationId, email, params) => endpoint.api //
+    .patch(`/organizations/${organizationId}/invitation/${email}`, params)
+    .then((r) => r.data);
+const resendInvitation = (endpoint, organizationId, email) => endpoint.api //
+    .post(`/organizations/${organizationId}/invitation/${email}/resend`)
+    .then((r) => r.data);
+const getInvitation = (endpoint, organizationId, email, token) => endpoint.api //
+    .get(`/organizations/${organizationId}/invitation/${email}/accept/${token}`)
+    .then((r) => r.data);
+const acceptInvitation = (endpoint, organizationId, email, token) => endpoint.api //
+    .post(`/organizations/${organizationId}/invitation/${email}/accept/${token}`)
+    .then((r) => r.data);
+const declineInvitation = (endpoint, organizationId, email, token) => endpoint.api //
+    .post(`/organizations/${organizationId}/invitation/${email}/decline/${token}`)
+    .then((r) => r.data);
+const claimNewUser = (endpoint, organizationId, email, token) => endpoint.api //
+    .put(`/organizations/${organizationId}/invitation/${email}/token/${token}/new_user`)
+    .then((r) => r.data);
+
+var Invitations = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  acceptInvitation: acceptInvitation,
+  claimNewUser: claimNewUser,
+  createInvitation: createInvitation,
+  declineInvitation: declineInvitation,
+  deleteInvitation: deleteInvitation,
+  getInvitation: getInvitation,
+  getInvitations: getInvitations,
+  resendInvitation: resendInvitation,
+  updateInvitation: updateInvitation
+});
+
+/**
+ * An Organization Member (aka Profile) is an individual user with access to an organization.
+ *
+ * @module
+ */
+const getMembers = (endpoint, organizationId) => endpoint.api //
+    .get(`/organizations/${organizationId}/profiles`)
+    .then((r) => r.data);
+const deleteMember = (endpoint, organizationId, profileId) => endpoint.api //
+    .delete(`/organizations/${organizationId}/profiles/${profileId}`)
+    .then((r) => r.data);
+const addMemberRole = (endpoint, organizationId, profileId, roleId) => endpoint.api //
+    .post(`/organizations/${organizationId}/profiles/${profileId}/role/${roleId}`)
+    .then((r) => r.data);
+const deleteMemberRole = (endpoint, organizationId, profileId, roleId) => endpoint.api //
+    .delete(`/organizations/${organizationId}/profiles/${profileId}/role/${roleId}`)
+    .then((r) => r.data);
+const getMemberPlans = (endpoint, organizationId, profileId) => endpoint.api //
+    .get(`/organizations/${organizationId}/profiles/${profileId}/plans`)
+    .then((r) => r.data);
+
+var Members = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  addMemberRole: addMemberRole,
+  deleteMember: deleteMember,
+  deleteMemberRole: deleteMemberRole,
+  getMemberPlans: getMemberPlans,
+  getMembers: getMembers
+});
+
+/**
+ * An Organization is the top level object for ownership for Members, Documents, and Templates.
+ *
+ * @module
+ */
+/**
+ * Get a list of organizations the user has access to.
+ */
+const getOrganizations = (endpoint) => endpoint.api //
+    .get('/organizations')
+    .then((r) => r.data);
+/**
+ * Create an organization.
+ */
+const createOrganization = (endpoint) => endpoint.api //
+    .post('/organizations')
+    .then((r) => r.data);
+/**
+ * Delete an organization.
+ */
+const deleteOrganization = (endpoint, organizationId) => endpoint.api //
+    .delete(`/organizations/${organizationId}`)
+    .then((r) => r.data);
+/**
+ * Get an organization by ID.
+ */
+const getOrganization = (endpoint, organizationId) => endpoint.api //
+    .get(`/organizations/${organizationId}`)
+    .then((r) => r.data);
+/**
+ * Update an organization.
+ */
+const updateOrganization = (endpoint, organizationId, params) => endpoint.api //
+    .patch(`/organizations/${organizationId}`, params)
+    .then((r) => r.data);
+
+var Organizations = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createOrganization: createOrganization,
+  deleteOrganization: deleteOrganization,
+  getOrganization: getOrganization,
+  getOrganizations: getOrganizations,
+  updateOrganization: updateOrganization
+});
+
+var Types$4 = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+const getWebhooks = (endpoint) => endpoint.api //
+    .get(`/v2/webhooks/organization`)
+    .then((r) => r.data);
+const setWebhooks = (endpoint, params) => endpoint.api //
+    .post(`/v2/webhooks/organization`, params)
+    .then((r) => r.data);
+
+var Webhooks = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getWebhooks: getWebhooks,
+  setWebhooks: setWebhooks
+});
+
+/**
+ * An Organization is a high-level container within Verdocs that groups together Templates, Documents, Profiles, Billing, and
+ * other settings. A User may be a member of more than one Organization. Each membership is tracked by a Profile representing
+ * that user's settings within that organization. It is important to select the correct Profile before performing operations
+ * against the Verdocs API, as this also sets the Organization that will be operated on, and the user's permissions within it.
+ *
+ * @module
+ */
+
+var index$4 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ApiKeys: ApiKeys,
+  Groups: Groups,
+  Invitations: Invitations,
+  Members: Members,
+  Organizations: Organizations,
+  Types: Types$4,
+  Webhooks: Webhooks
+});
+
+var Types$3 = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+/**
+ * Confirm whether the user has all of the specified permissions.
+ */
+const userHasPermissions = (session, permissions) => permissions.every((perm) => (session?.permissions || []).includes(perm));
+
+var index$3 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Types: Types$3,
+  userHasPermissions: userHasPermissions
+});
+
+const canPerformTemplateAction = (session, action, template) => {
+    if (!template && !action.includes('create')) {
+        return { canPerform: false, message: 'Missing required template object' };
+    }
+    // We use BOGUS here to force the option-chain in things like template?.profile_id to NOT match profile?.profile_id because if both
+    // were undefined, they would actually match.
+    const profile_id = session?.profile_id || 'BOGUS';
+    const organization_id = session?.organization_id || 'BOGUS';
+    if (!profile_id) {
+        return { canPerform: false, message: 'Active session required' };
+    }
+    const isCreator = template?.profile_id === profile_id;
+    const isSameOrg = template?.organization_id === organization_id;
+    const isPersonal = template?.is_personal ?? false;
+    const isPublic = template?.is_public ?? false;
+    const permissionsRequired = [];
+    switch (action) {
+        case 'create_personal':
+            permissionsRequired.push('template:creator:create:personal');
+            break;
+        case 'create_org':
+            permissionsRequired.push('template:creator:create:org');
+            break;
+        case 'create_public':
+            permissionsRequired.push('template:creator:create:public');
+            break;
+        case 'read':
+            if (!isCreator) {
+                if ((!isPersonal && isSameOrg) || !isPublic) {
+                    permissionsRequired.push('template:member:read');
+                }
+            }
+            break;
+        case 'write':
+            if (!isCreator) {
+                permissionsRequired.push('template:member:read');
+                permissionsRequired.push('template:member:write');
+            }
+            break;
+        case 'change_visibility_personal':
+            if (isCreator) {
+                permissionsRequired.push('template:creator:create:personal');
+            }
+            else {
+                permissionsRequired.push('template:member:visibility');
+            }
+            break;
+        case 'change_visibility_org':
+            if (isCreator) {
+                permissionsRequired.push('template:creator:create:org');
+            }
+            else {
+                permissionsRequired.push('template:member:visibility');
+            }
+            break;
+        case 'change_visibility_public':
+            if (isCreator) {
+                permissionsRequired.push('template:creator:create:public');
+                permissionsRequired.push('template:creator:visibility');
+            }
+            else {
+                permissionsRequired.push('template:member:visibility');
+            }
+            break;
+        case 'delete':
+            if (isCreator) {
+                permissionsRequired.push('template:creator:delete');
+            }
+            else {
+                permissionsRequired.push('template:member:delete');
+            }
+            break;
+        default:
+            return { canPerform: false, message: 'Action is not defined' };
+    }
+    if (hasRequiredPermissions(session, permissionsRequired)) {
+        return { canPerform: true, message: '' };
+    }
+    return { canPerform: false, message: `Insufficient access to perform '${action}'. Needed permissions: ${permissionsRequired.toString()}` };
+};
+const hasRequiredPermissions = (session, permissions) => permissions.every((perm) => (session?.permissions || []).includes(perm));
+
+var Actions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  canPerformTemplateAction: canPerformTemplateAction,
+  hasRequiredPermissions: hasRequiredPermissions
+});
+
+/**
+ * Add a field to a template.
+ */
+const createField = (endpoint, templateId, params) => endpoint.api //
+    .post(`/templates/${templateId}/fields`, params)
+    .then((r) => r.data);
+/**
+ * Update a template field.
+ */
+const updateField = (endpoint, templateId, fieldName, params) => endpoint.api //
+    .put(`/templates/${templateId}/fields/${fieldName}`, params)
+    .then((r) => r.data);
+/**
+ * REmove a field from a template.
+ */
+const deleteField = (endpoint, templateId, fieldName) => endpoint.api //
+    .delete(`/templates/${templateId}/fields/${fieldName}`)
+    .then((r) => r.data);
+
+var Fields$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createField: createField,
+  deleteField: deleteField,
+  updateField: updateField
+});
+
+/**
+ * Enable automatic reminders. setup_time is the number of days after the envelope is sent that the first reminder
+ * should be sent. interval_time is the number of days between reminders.
+ */
+const createReminder = (endpoint, templateId, params) => endpoint.api //
+    .post(`/templates/${templateId}/reminder/`, params)
+    .then((r) => r.data);
+/**
+ * Get the reminder configuration for a template.
+ */
+const getReminder = (endpoint, templateId, reminderId) => endpoint.api //
+    .get(`/templates/${templateId}/reminder/${reminderId}`)
+    .then((r) => r.data);
+/**
+ * Update the reminder configuration for a template.
+ */
+const updateReminder = (endpoint, templateId, reminderId, params) => endpoint.api //
+    .put(`/templates/${templateId}/reminder/${reminderId}`, params)
+    .then((r) => r.data);
+/**
+ * Delete the reminder configuration for a template.
+ */
+const deleteReminder = (endpoint, templateId, reminderId) => endpoint.api //
+    .delete(`/templates/${templateId}/reminder/${reminderId}`)
+    .then((r) => r.data);
+
+var Reminders = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createReminder: createReminder,
+  deleteReminder: deleteReminder,
+  getReminder: getReminder,
+  updateReminder: updateReminder
+});
+
+/**
+ * A "role" is an individual participant in a signing flow, such as a signer or CC contact. Roles are identified by
+ * their names, which must be unique (e.g. 'Recipient 1'). Template fields are assigned to roles for signing operations,
+ * so you may have 'Recipient 1 Signature 1' and so forth.
+ *
+ * @module
+ */
+const createRole = (endpoint, templateId, params) => endpoint.api //
+    .post(`/templates/${templateId}/roles`, params)
+    .then((r) => r.data);
+const getRoles$1 = (endpoint, templateId) => endpoint.api //
+    .get(`/templates/${templateId}/roles`)
+    .then((r) => r.data);
+const getRole = (endpoint, templateId, roleName) => endpoint.api //
+    .get(`/templates/${templateId}/roles/${roleName}`)
+    .then((r) => r.data);
+const updateRole = (endpoint, templateId, roleName, params) => endpoint.api //
+    .put(`/templates/${templateId}/roles/${roleName}`, params)
+    .then((r) => r.data);
+const deleteRole = (endpoint, templateId, roleName) => endpoint.api //
+    .delete(`/templates/${templateId}/roles/${roleName}`)
+    .then((r) => r.data);
+const getRoleFields = (endpoint, templateId, roleName) => endpoint.api //
+    .get(`/templates/${templateId}/roles/${roleName}/fields`)
+    .then((r) => r.data);
+const deleteSequence = (endpoint, templateId) => endpoint.api //
+    .delete(`/templates/${templateId}/roles`)
+    .then((r) => r.data);
+
+var Roles = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createRole: createRole,
+  deleteRole: deleteRole,
+  deleteSequence: deleteSequence,
+  getRole: getRole,
+  getRoleFields: getRoleFields,
+  getRoles: getRoles$1,
+  updateRole: updateRole
+});
+
+/**
+ * Get the template stars for a template.
+ */
+const getStars = (endpoint, templateId) => endpoint.api //
+    .get(`/templates/${templateId}/stars`)
+    .then((r) => r.data);
+/**
+ * Toggle the template star for a template.
+ */
+const toggleStar = (endpoint, templateId) => endpoint.api //
+    .post(`/templates/${templateId}/stars/toggle`)
+    .then((r) => r.data);
+
+var Stars = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getStars: getStars,
+  toggleStar: toggleStar
+});
+
+/**
+ * A Tag is a user-specified label applied to a template. Tags help users organize and find Templates.
+ * recipients. Every Organization has a set of tags "owned" by that Organization and only visible inside it.
+ * Verdocs also provides a set of system-wide "featured" tags available to all Organizations.
+ *
+ * @module
+ */
+/**
+ * Apply a tag to a template.
+ */
+const addTemplateTag = (endpoint, templateId, params) => endpoint.api //
+    .post(`/templates/${templateId}/tags/`, params)
+    .then((r) => r.data);
+/**
+ * Get all tags for a template.
+ */
+const getTemplateTags = (endpoint, templateId) => endpoint.api //
+    .get(`/templates/${templateId}/tags/`)
+    .then((r) => r.data);
+/**
+ * Remove a tag from a template.
+ */
+const deleteTemplateTag = (endpoint, templateId, tagName) => endpoint.api //
+    .post(`/templates/${templateId}/tags/${tagName}`)
+    .then((r) => r.data);
+/**
+ * Create an Organization-wide tag.
+ */
+const createTag = (endpoint, name) => endpoint.api //
+    .post('/tags', { tag_name: name })
+    .then((r) => r.data);
+/**
+ * Get an Organization-wide tag.
+ */
+const getTag = (endpoint, name) => endpoint.api //
+    .get(`/tags/${name}`)
+    .then((r) => r.data);
+/**
+ * Get all tags available for use by an Organization.
+ */
+const getAllTags = (endpoint) => endpoint.api //
+    .get('/tags')
+    .then((r) => r.data);
+
+var Tags = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  addTemplateTag: addTemplateTag,
+  createTag: createTag,
+  deleteTemplateTag: deleteTemplateTag,
+  getAllTags: getAllTags,
+  getTag: getTag,
+  getTemplateTags: getTemplateTags
+});
+
+/**
+ * A Template defines how a Verdocs signing flow will be performed, including attachments, signing fields, and
+ * recipients.
+ *
+ * @module
+ */
+/**
+ * Get all templates accessible by the caller, with optional filters.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * await Templates.getTemplates((VerdocsEndpoint.getDefault());
+ * await Templates.getTemplates((VerdocsEndpoint.getDefault(), { is_starred: true });
+ * await Templates.getTemplates((VerdocsEndpoint.getDefault(), { is_creator: true });
+ * await Templates.getTemplates((VerdocsEndpoint.getDefault(), { is_organization: true });
+ * ```
+ */
+const getTemplates = (endpoint, params) => endpoint.api //
+    .post('/templates', { params })
+    .then((r) => r.data);
+// export interface IListTemplatesParams {
+//   name?: string;
+//   sharing?: 'all' | 'personal' | 'shared' | 'public';
+//   starred?: 'all' | 'starred' | 'unstarred';
+//   sort?: 'name' | 'created_at' | 'updated_at' | 'last_used_at' | 'counter' | 'star_counter';
+//   direction?: 'asc' | 'desc';
+//   page?: number;
+//   rows?: number;
+// }
+/**
+ * Lists all templates accessible by the caller, with optional filters.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * await Templates.listTemplates((VerdocsEndpoint.getDefault(), { sharing: 'personal', sort: 'last_used_at' });
+ * ```
+ */
+// export const listTemplates = (endpoint: VerdocsEndpoint, params?: IListTemplatesParams) =>
+//   endpoint.api //
+//     .post<ITemplateSummaries>('/templates/list', params, {baseURL: endpoint.getBaseURLv2()})
+//     .then((r) => r.data);
+/**
+ * Get one template by its ID.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const template = await Templates.getTemplate((VerdocsEndpoint.getDefault(), '83da3d70-7857-4392-b876-c4592a304bc9');
+ * ```
+ */
+const getTemplate = (endpoint, templateId) => endpoint.api //
+    .get(`/templates/${templateId}`)
+    .then((r) => r.data);
+/**
+ * Get owner information for a template.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const template = await Templates.getTemplateOwnerInfo((VerdocsEndpoint.getDefault(), '83da3d70-7857-4392-b876-c4592a304bc9');
+ * ```
+ */
+const getTemplateOwnerInfo = (endpoint, templateId) => endpoint.api //
+    .get(`/templates/${templateId}`)
+    .then((r) => r.data);
+const ALLOWED_CREATE_FIELDS = [
+    'name',
+    'is_personal',
+    'is_public',
+    'sender',
+    'description',
+    'roles',
+    'fields',
+];
+/**
+ * Create a template.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const newTemplate = await Templates.createTemplate((VerdocsEndpoint.getDefault(), {...});
+ * ```
+ */
+const createTemplate = (endpoint, params, onUploadProgress) => {
+    const options = {
+        timeout: 120000,
+        onUploadProgress: (event) => {
+            const total = event.total || 1;
+            const loaded = event.loaded || 0;
+            onUploadProgress?.(Math.floor((loaded * 100) / (total || 1)), loaded, total || 1);
+        },
+    };
+    if (params.documents && params.documents[0] instanceof File) {
+        if (params.documents.length > 10) {
+            throw new Error('createTemplate() has a maximum of 10 documents that can be attached.');
+        }
+        const formData = new FormData();
+        ALLOWED_CREATE_FIELDS.forEach((allowedKey) => {
+            if (params[allowedKey] !== undefined) {
+                formData.append(allowedKey, params[allowedKey]);
+            }
+        });
+        params.documents.forEach((file) => {
+            formData.append('documents', file, file.name);
+        });
+        return endpoint.api.post('/templates', formData, options).then((r) => r.data);
+    }
+    else {
+        return endpoint.api.post('/templates', params, options).then((r) => r.data);
+    }
+};
+/**
+ * Create a template.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const newTemplate = await Templates.createTemplatev2((VerdocsEndpoint.getDefault(), {...});
+ * ```
+ */
+const createTemplatev2 = (endpoint, params, onUploadProgress) => {
+    const options = {
+        timeout: 120000,
+        onUploadProgress: (event) => {
+            const total = event.total || 1;
+            const loaded = event.loaded || 0;
+            onUploadProgress?.(Math.floor((loaded * 100) / (total || 1)), loaded, total || 1);
+        },
+    };
+    if (params.documents && params.documents[0] instanceof File) {
+        const formData = new FormData();
+        ALLOWED_CREATE_FIELDS.forEach((allowedKey) => {
+            if (params[allowedKey] !== undefined) {
+                formData.append(allowedKey, params[allowedKey]);
+            }
+        });
+        params.documents.forEach((file) => {
+            formData.append('documents', file, file.name);
+        });
+        return endpoint.api.post('/v2/templates', formData, options).then((r) => r.data);
+    }
+    else {
+        return endpoint.api.post('/v2/templates', params, options).then((r) => r.data);
+    }
+};
+/**
+ * Create a template from a Sharepoint asset.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const newTemplate = await Templates.createTemplateFromSharepoint((VerdocsEndpoint.getDefault(), {...});
+ * ```
+ */
+const createTemplateFromSharepoint = (endpoint, params) => {
+    const options = {
+        timeout: 120000,
+    };
+    return endpoint.api.post('/templates/from-sharepoint', params, options).then((r) => r.data);
+};
+/**
+ * Update a template.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const updatedTemplate = await Templates.updateTemplate((VerdocsEndpoint.getDefault(), '83da3d70-7857-4392-b876-c4592a304bc9', { name: 'New Name' });
+ * ```
+ */
+const updateTemplate = (endpoint, templateId, params) => endpoint.api //
+    .put(`/templates/${templateId}`, params)
+    .then((r) => r.data);
+/**
+ * Delete a template.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * await Templates.deleteTemplate((VerdocsEndpoint.getDefault(), '83da3d70-7857-4392-b876-c4592a304bc9');
+ * ```
+ */
+const deleteTemplate = (endpoint, templateId) => endpoint.api //
+    .delete(`/templates/${templateId}`)
+    .then((r) => r.data);
+/**
+ * Search for templates matching various criteria.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const {result, page, total} = await Templates.search((VerdocsEndpoint.getDefault(), { ... });
+ * ```
+ */
+const searchTemplates = async (endpoint, params) => endpoint.api //
+    .post('/templates/search', params)
+    .then((r) => r.data);
+/**
+ * Get a summary of template data, typically used to populate admin panel dashboard pages.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const summary = await Templates.getSummary((VerdocsEndpoint.getDefault(), 0);
+ * ```
+ */
+const getSummary = async (endpoint, params = {}) => endpoint.api //
+    .post('/templates/summary', params)
+    .then((r) => r.data);
+const cachedTemplates = {};
+/**
+ * Wrapper for `getTemplate()` that limits queries to one every 2 seconds per template ID.
+ * This is intended for use in component hierarchies that all rely on the same template
+ * to avoid unnecessary repeat server calls.
+ */
+const throttledGetTemplate = (endpoint, templateId) => {
+    if (cachedTemplates[templateId] && cachedTemplates[templateId].loaded + 2000 < new Date().getTime()) {
+        return cachedTemplates[templateId].template;
+    }
+    return getTemplate(endpoint, templateId).then((template) => {
+        cachedTemplates[templateId] = { loaded: new Date().getTime(), template };
+        return template;
+    });
+};
+/**
+ * List templates.
+ *
+ * ```typescript
+ * import {Templates} from '@verdocs/js-sdk/Templates';
+ *
+ * const {totals, templates} = await Templates.listTemplates((VerdocsEndpoint.getDefault(), { q: 'test', sort: 'created_at' }); * ```
+ */
+const listTemplates = async (endpoint, params = {}) => endpoint.api //
+    .post('/templates/list', params)
+    .then((r) => r.data);
+
+var Templates = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createTemplate: createTemplate,
+  createTemplateFromSharepoint: createTemplateFromSharepoint,
+  createTemplatev2: createTemplatev2,
+  deleteTemplate: deleteTemplate,
+  getSummary: getSummary,
+  getTemplate: getTemplate,
+  getTemplateOwnerInfo: getTemplateOwnerInfo,
+  getTemplates: getTemplates,
+  listTemplates: listTemplates,
+  searchTemplates: searchTemplates,
+  throttledGetTemplate: throttledGetTemplate,
+  updateTemplate: updateTemplate
+});
+
+/**
+ * A TemplateDocument represents a PDF or other attachment in a Template.
+ *
+ * @module
+ */
+/**
+ * Get all the Template Documents associated to a particular Template.
+ *
+ * ```typescript
+ * import {TemplateDocument} from '@verdocs/js-sdk/Templates';
+ *
+ * await TemplateDocument.geTemplateDocuments((VerdocsEndpoint.getDefault(), templateId);
+ * ```
+ */
+const getTemplateDocuments = (endpoint, templateId) => endpoint.api //
+    .get(`/templates/${templateId}/documents/`)
+    .then((r) => r.data);
+/**
+ * Get a specific Document.
+ *
+ * ```typescript
+ * import {TemplateDocument} from '@verdocs/js-sdk/Templates';
+ *
+ * await TemplateDocument.geTemplateDocument((VerdocsEndpoint.getDefault(), templateId,documentId);
+ * ```
+ */
+const getTemplateDocument = (endpoint, templateId, documentId) => endpoint.api //
+    .get(`/templates/${templateId}/documents/${documentId}`)
+    .then((r) => r.data);
+/**
+ * Create a Document for a particular Template.
+ *
+ * ```typescript
+ * import {TemplateDocument} from '@verdocs/js-sdk/Templates';
+ *
+ * await TemplateDocument.createDocument((VerdocsEndpoint.getDefault(), templateID, params);
+ * ```
+ */
+const createTemplateDocument = (endpoint, templateId, file, onUploadProgress) => {
+    const formData = new FormData();
+    formData.append('document', file, file.name);
+    return endpoint.api //
+        .post(`/templates/${templateId}/documents`, formData, {
+        timeout: 120000,
+        onUploadProgress: (event) => {
+            const total = event.total || 1;
+            const loaded = event.loaded || 0;
+            onUploadProgress?.(Math.floor((loaded * 100) / (total || 1)), loaded, total || 1);
+        },
+    })
+        .then((r) => r.data);
+};
+/**
+ * Delete a specific Document.
+ *
+ * ```typescript
+ * import {TemplateDocument} from '@verdocs/js-sdk/Templates';
+ *
+ * await TemplateDocument.deleteDocument((VerdocsEndpoint.getDefault(), templateID, documentID);
+ * ```
+ */
+const deleteTemplateDocument = (endpoint, templateId, documentId) => endpoint.api //
+    .delete(`/templates/${templateId}/documents/${documentId}`)
+    .then((r) => r.data);
+/**
+ * Get (binary download) a file attached to a Template. It is important to use this method
+ * rather than a direct A HREF or similar link to set the authorization headers for the
+ * request.
+ */
+const getTemplateDocumentFile = async (endpoint, templateId, documentId) => endpoint.api //
+    .get(`/templates/${templateId}/documents/${documentId}?file=true`, { responseType: 'blob' })
+    .then((r) => r.data);
+/**
+ * Get (binary download) a file attached to a Template. It is important to use this method
+ * rather than a direct A HREF or similar link to set the authorization headers for the
+ * request.
+ */
+const getTemplateDocumentThumbnail = async (endpoint, templateId, documentId) => endpoint.api //
+    .get(`/templates/${templateId}/documents/${documentId}?thumbnail=true`, { responseType: 'blob' })
+    .then((r) => r.data);
+/**
+ * Get a display URI for a given page in a file attached to a template document. These pages are rendered server-side
+ * into PNG resources suitable for display in IMG tags although they may be used elsewhere. Note that these are intended
+ * for DISPLAY ONLY, are not legally binding documents, and do not contain any encoded metadata from participants. The
+ * original asset may be obtained by calling `getTemplateDocumentFile()` or similar.
+ */
+const getTemplateDocumentPageDisplayUri = async (endpoint, templateId, documentId, page) => endpoint.api.get(`/templates/${templateId}/documents/${documentId}/pages/${page}/image`).then((r) => r.data);
+
+var TemplateDocuments = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createTemplateDocument: createTemplateDocument,
+  deleteTemplateDocument: deleteTemplateDocument,
+  getTemplateDocument: getTemplateDocument,
+  getTemplateDocumentFile: getTemplateDocumentFile,
+  getTemplateDocumentPageDisplayUri: getTemplateDocumentPageDisplayUri,
+  getTemplateDocumentThumbnail: getTemplateDocumentThumbnail,
+  getTemplateDocuments: getTemplateDocuments
+});
+
+var Types$2 = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+/**
+ * Get all defined validators
+ *
+ * ```typescript
+ * import {Documents} from '@verdocs/js-sdk/Templates';
+ *
+ * await Documents.getDocuments(templateID);
+ * ```
+ */
+const getValidators = (endpoint) => endpoint.api //
+    .get('/validators')
+    .then((r) => r.data);
+const getValidator = (endpoint, validatorName) => endpoint.api //
+    .get(`/validators/${validatorName}`)
+    .then((r) => r.data);
+const EMAIL_REGEX = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+const isValidEmail = (email) => !!email && EMAIL_REGEX.test(email);
+// @see https://www.regextester.com/1978
+const PHONE_REGEX = /((?:\+|00)[17](?: |\-)?|(?:\+|00)[1-9]\d{0,2}(?: |\-)?|(?:\+|00)1\-\d{3}(?: |\-)?)?(0\d|\([0-9]{3}\)|[1-9]{0,3})(?:((?: |\-)[0-9]{2}){4}|((?:[0-9]{2}){4})|((?: |\-)[0-9]{3}(?: |\-)[0-9]{4})|([0-9]{7}))/;
+const isValidPhone = (phone) => !!phone && PHONE_REGEX.test(phone);
+const isValidRoleName = (value, roles) => roles.findIndex((role) => role.name === value) !== -1;
+const TagRegEx = /^[a-zA-Z0-9-]{0,32}$/;
+const isValidTag = (value, tags) => TagRegEx.test(value) || tags.findIndex((tag) => tag === value) !== -1;
+
+var Validators = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getValidator: getValidator,
+  getValidators: getValidators,
+  isValidEmail: isValidEmail,
+  isValidPhone: isValidPhone,
+  isValidRoleName: isValidRoleName,
+  isValidTag: isValidTag
+});
+
+var index$2 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Actions: Actions,
+  Fields: Fields$1,
+  Reminders: Reminders,
+  Roles: Roles,
+  Stars: Stars,
+  Tags: Tags,
+  TemplateDocuments: TemplateDocuments,
+  Templates: Templates,
+  Types: Types$2,
+  Validators: Validators
+});
+
+/**
+ * Authenticate to Verdocs via user/password authentication
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const {accessToken} = await Auth.authenticateUser({ username: 'test@test.com', password: 'PASSWORD' });
+ * Transport.setAuthToken(accessToken);
+ * ```
+ */
+const authenticateUser = (endpoint, params) => endpoint.api //
+    .post('/authentication/login', params)
+    .then((r) => r.data);
+/**
+ * Authenticate to Verdocs via client ID / Secret authentication. **NOTE: This is only suitable for
+ * NodeJS server-side applications. Never expose your Client Secret in a Web or Mobile app!** Also note
+ * that access tokens may be cached by server-side apps (and this is recommended) but do expire after 2
+ * hours. This expiration may change based on future security needs. Application developers are encouraged
+ * to check the `exp` expiration field in the response accessToken and renew tokens after they expire.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const {accessToken} = await Auth.authenticateApp({ client_id: 'CLIENTID', client_secret: 'SECRET' });
+ * Transport.setAuthToken(accessToken);
+ * ```
+ */
+const authenticateApp = (endpoint, params) => endpoint.api //
+    .post('/authentication/login_client', {}, { headers: params })
+    .then((r) => r.data);
+/**
+ * Validate a token. Only Verdocs tokens will be accepted. Most applications can decode tokens locally,
+ * because tokens will be validated when API calls are made anyway. However, high-security applications
+ * may use this endpoint to check if a token has been revoked.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const {valid} = await Auth.validateToken({ token });
+ * if (!valid) {
+ *   window.alert('Session invalid or expired. Please re-authenticate.');
+ * }
+ * ```
+ */
+const validateToken = (endpoint, params) => endpoint.api //
+    .post('/token/isValid', params)
+    .then((r) => r.data);
+/**
+ * If called before the session expires, this will refresh the caller's session and tokens.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const {accessToken} = await Auth.refreshTokens();
+ * Transport.setAuthToken(accessToken);
+ * ```
+ */
+const refreshTokens = (endpoint) => endpoint.api //
+    .get('/token')
+    .then((r) => r.data);
+/**
+ * Update the caller's password. To help prevent CSRF attack vectors, the user's old password and email address are required.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const {status, message} = await Auth.updatePassword({ email, oldPassword, newPassword });
+ * if (status !== 'OK') {
+ *   window.alert(`Password reset error: ${message}`);
+ * }
+ * ```
+ */
+const updatePassword = (endpoint, params) => endpoint.api //
+    .put('/user/update_password', params)
+    .then((r) => r.data);
+/**
+ * Reset the caller's password.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const {success} = await Auth.resetPassword({ email });
+ * if (status !== 'OK') {
+ *   window.alert(`Please check your email for instructions on how to reset your password.`);
+ * }
+ * ```
+ */
+const resetPassword = (endpoint, params) => endpoint.api //
+    .post('/user/reset_password', params)
+    .then((r) => r.data);
+/**
+ * Update the caller's email address.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const {profiles} = await Auth.updateEmail({ email: newEmail });
+ * ```
+ */
+const updateEmail = (endpoint, params) => endpoint.api //
+    .put('/user/update_email', params)
+    .then((r) => r.data);
+/**
+ * Resend the email verification request. Note that to prevent certain forms of abuse, the email address is not
+ * a parameter here. Instead, the caller must be authenticated as the (unverified) user. To simplify this process,
+ * the access token to be used may be passed directly as a parameter here. This avoids the need to set it as the
+ * active token on an endpoint, which may be inconvenient in workflows where it is preferable to keep the user in
+ * "anonymous" mode while verification is being performed.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const result = await Auth.resendVerification();
+ * ```
+ */
+const resendVerification = (endpoint, accessToken) => endpoint.api //
+    .post('/user/email_verification', {}, accessToken ? { headers: { Authorization: `Bearer ${accessToken}` } } : {})
+    .then((r) => r.data);
+const createUser = (endpoint, params) => endpoint.api //
+    .post('/user', params)
+    .then((r) => r.data);
+
+var Auth = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  authenticateApp: authenticateApp,
+  authenticateUser: authenticateUser,
+  createUser: createUser,
+  refreshTokens: refreshTokens,
+  resendVerification: resendVerification,
+  resetPassword: resetPassword,
+  updateEmail: updateEmail,
+  updatePassword: updatePassword,
+  validateToken: validateToken
+});
+
+// TODO
+const billingPlaceholder = {};
+
+var Billing = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  billingPlaceholder: billingPlaceholder
+});
+
+const getNotifications = async (endpoint) => endpoint.api //
+    .get('/notifications')
+    .then((r) => r.data);
+
+var Notifications = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getNotifications: getNotifications
+});
+
+/**
+ * Get the user's available profiles. The current profile will be marked with `current: true`.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const profiles = await Profiles.getProfiles()
+ * ```
+ */
+const getProfiles = (endpoint) => endpoint.api //
+    .get('/profiles')
+    .then((r) => r.data);
+/**
+ * Get the user's available profiles. The current profile will be marked with `current: true`.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const profiles = await Profiles.getCurrentProfile()
+ * ```
+ */
+const getCurrentProfile = (endpoint) => endpoint.api //
+    .get('/profiles')
+    .then((r) => (r.data || []).find((profile) => profile.current));
+/**
+ * Get a list of system roles.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const roles = await Profiles.getRoles();
+ * ```
+ */
+const getRoles = (endpoint) => endpoint.api //
+    .get('/roles')
+    .then((r) => r.data);
+/**
+ * Get a list of system roles.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const permissions = await Profiles.getPermissions();
+ * ```
+ */
+const getPermissions = (endpoint) => endpoint.api //
+    .get('/permissions')
+    .then((r) => r.data);
+/**
+ * Create a profile. If the caller does not have a "current" profile set, the new profile will be made current.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const newProfile = await Profiles.createProfile({ first_name: 'FIRST', last_name: 'LAST', email: 'EMAIL' });
+ * ```
+ */
+const createProfile = (endpoint, params) => endpoint.api //
+    .post('/profiles', params)
+    .then((r) => r.data);
+/**
+ * Get a profile. The caller must have admin access to the given profile.
+ * TODO: Add a "public" profile endpoint for public pages
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const profile = await Profiles.getProfile('PROFILEID');
+ * ```
+ */
+const getProfile = (endpoint, profileId) => endpoint.api //
+    .get(`/profiles/${profileId}`)
+    .then((r) => r.data);
+/**
+ * Get a profile's permissions. The caller must have admin access to the given profile.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const permissions = await Profiles.getProfilePermissions('PROFILEID');
+ * ```
+ */
+const getProfilePermissions = (endpoint, profileId) => endpoint.api //
+    .get(`/profiles/${profileId}/permissions`)
+    .then((r) => r.data);
+/**
+ * Get a profile's groups.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const groups = await Profiles.getProfileGroups('PROFILEID');
+ * ```
+ */
+const getProfileGroups = (endpoint, profileId) => endpoint.api //
+    .get(`/profiles/${profileId}/groups`)
+    .then((r) => r.data);
+/**
+ * Switch the caller's "current" profile. The current profile is used for permissions checking and profile_id field settings
+ * for most operations in Verdocs. It is important to select the appropropriate profile before calling other API functions.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const newProfile = await Profiles.switchProfile('PROFILEID');
+ * ```
+ */
+const switchProfile = (endpoint, profileId) => endpoint.api //
+    .post(`/profiles/${profileId}/switch`)
+    .then((r) => r.data);
+/**
+ * Update a profile. For future expansion, the profile ID to update is required, but currently this must also be the
+ * "current" profile for the caller.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const newProfile = await Profiles.updateProfile('PROFILEID');
+ * ```
+ */
+const updateProfile = (endpoint, profileId, params) => endpoint.api //
+    .put(`/profiles/${profileId}`, params)
+    .then((r) => r.data);
+/**
+ * Delete a profile. If the requested profile is the caller's curent profile, the next available profile will be selected.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * await Profiles.deleteProfile('PROFILEID');
+ * ```
+ */
+const deleteProfile = (endpoint, profileId) => endpoint.api //
+    .delete(`/profiles/${profileId}`)
+    .then((r) => r.data);
+/**
+ * Create a user account and parent organization. This endpoint is for creating a new organization. Users joining an
+ * existing organization should be invited, and follow their invitation links/instructions to create their accounts.
+ *
+ * ```typescript
+ * import {Profiles} from '@verdocs/js-sdk/Users';
+ *
+ * const newAccount = await Profiles.createBusinessAccount({
+ *   orgName: 'ORG', email: 'a@b.com', password: '12345678', firstName: 'FIRST', lastName: 'LAST'
+ * });
+ * ```
+ */
+const createBusinessAccount = (endpoint, params) => endpoint.api //
+    .post('/user/business', params)
+    .then((r) => r.data);
+const recordSignupSurvey = (endpoint, params) => endpoint.api //
+    .post('/user/signup', params)
+    .then((r) => r.data);
+
+var Profiles = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createBusinessAccount: createBusinessAccount,
+  createProfile: createProfile,
+  deleteProfile: deleteProfile,
+  getCurrentProfile: getCurrentProfile,
+  getPermissions: getPermissions,
+  getProfile: getProfile,
+  getProfileGroups: getProfileGroups,
+  getProfilePermissions: getProfilePermissions,
+  getProfiles: getProfiles,
+  getRoles: getRoles,
+  recordSignupSurvey: recordSignupSurvey,
+  switchProfile: switchProfile,
+  updateProfile: updateProfile
+});
+
+var Types$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Auth: Auth,
+  Billing: Billing,
+  Notifications: Notifications,
+  Profiles: Profiles,
+  Types: Types$1
+});
+
+/* tslint:disable:no-bitwise */
+/**
+ * Given a `rgba(r,g,b,a)` string value, returns the hex equivalent, dropping the alpha channel.
+ */
+function getRGB(rgba) {
+    const rgbNumbers = rgba.replace('rgba(', '').replace(')', '').split(',');
+    const rgbObject = {
+        red: +rgbNumbers[0],
+        green: +rgbNumbers[1],
+        blue: +rgbNumbers[2],
+        alpha: +rgbNumbers[3],
+    };
+    const alpha = 1 - rgbObject.alpha;
+    const red = Math.round((rgbObject.alpha * (rgbObject.red / 255) + alpha) * 255);
+    const green = Math.round((rgbObject.alpha * (rgbObject.green / 255) + alpha) * 255);
+    const blue = Math.round((rgbObject.alpha * (rgbObject.blue / 255) + alpha) * 255);
+    return '#' + rgbToHex(red) + rgbToHex(green) + rgbToHex(blue);
+}
+/**
+ * Given an RGB string value, returns the hex equivalent.
+ */
+function rgbToHex(rgb) {
+    const hex = rgb.toString(16);
+    if (hex.length < 2) {
+        return '0' + hex;
+    }
+    return hex;
+}
+/**
+ * Given a signer role index, return the color code for that signer.
+ */
+function getRGBA(roleIndex) {
+    switch (roleIndex % 10) {
+        case 0:
+            return roleIndex === 0 ? 'rgba(255, 193, 7, 0.4)' : 'rgba(134, 134, 134, 0.3)'; // #FFE69C
+        case 1:
+            return 'rgba(156, 39, 176, .4)'; // '#E3C3E9'
+        case 2:
+            return 'rgba(33, 150, 243, .4)'; // '#C1E1FB'
+        case 3:
+            return 'rgba(220, 231, 117, 0.3)';
+        case 4:
+            return 'rgba(121, 134, 203, 0.3)';
+        case 5:
+            return 'rgba(77, 182, 172, 0.3)';
+        case 6:
+            return 'rgba(255, 202, 165, 0.3)';
+        case 7:
+            return 'rgba(2, 247, 190, 0.3)';
+        case 8:
+            return 'rgba(255, 138, 101, 0.3)';
+        case 9:
+            return 'rgba(82, 255, 79, 0.3)';
+        default:
+            return 'rgba(229, 115, 155, 0.3)';
+    }
+}
+/**
+ * Given a role name, return a color code for it. This works by computing a hash code so the specific color returned
+ * is not specified explicitly, but will be the same for every call with the same input value.
+ */
+function nameToRGBA(str) {
+    if (!!str) {
+        const validNum = parseInt(str.slice(-1), 10);
+        if (!isNaN(validNum)) {
+            str += (validNum * 99).toString();
+        }
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            hash = str.charCodeAt(i) + ((hash << 5) - hash);
+        }
+        hash = Math.round(hash / 1.3);
+        const c = (hash & 0x00ffff08).toString(16).toUpperCase();
+        const hex = '#' + '00000'.substring(0, 6 - c.length) + c;
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        const color = {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        };
+        return `rgba(${color.r}, ${color.g}, ${color.b}, 0.2)`;
+    }
+}
+/**
+ * Helper function to obtain a color code given a role name given various possible inputs.
+ */
+function getRoleColor(name, roles, index) {
+    if (index) {
+        return getRGBA(index);
+    }
+    else if (roles && roles.length > 0) {
+        const roleIndex = roles.findIndex((role) => role === name);
+        if (roleIndex > -1) {
+            return getRGBA(roleIndex);
+        }
+        else {
+            return nameToRGBA(name);
+        }
+    }
+    else {
+        return nameToRGBA(name);
+    }
+}
+
+var Colors = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getRGB: getRGB,
+  getRGBA: getRGBA,
+  getRoleColor: getRoleColor,
+  nameToRGBA: nameToRGBA
+});
+
+const YEAR = 365 * 24 * 60 * 60;
+// const MONTH = 30 * 24 * 60 * 60;
+const WEEK = 7 * 24 * 60 * 60;
+const DAY = 24 * 60 * 60;
+const HOUR = 60 * 60;
+const MINUTE = 60;
+const formatShortTimeAgo = (val) => {
+    if (val === undefined || val === null) {
+        return '';
+    }
+    let dateInput;
+    if (typeof val === 'string' || typeof val === 'number') {
+        dateInput = new Date(val);
+    }
+    else if (typeof val === 'object') {
+        dateInput = val;
+    }
+    else {
+        return '';
+    }
+    const timeDiff = Math.floor((new Date().getTime() - dateInput.getTime()) / 1000);
+    if (timeDiff >= YEAR) {
+        return Math.floor(timeDiff / YEAR) + 'Y';
+    }
+    // if (timeDiff >= MONTH) {
+    //   return Math.floor(timeDiff / MONTH) + 'M';
+    // }
+    if (timeDiff >= WEEK) {
+        return Math.floor(timeDiff / WEEK) + 'W';
+    }
+    if (timeDiff >= DAY) {
+        return Math.floor(timeDiff / DAY) + 'D';
+    }
+    if (timeDiff >= HOUR) {
+        return Math.floor(timeDiff / HOUR) + 'H';
+    }
+    if (timeDiff >= MINUTE) {
+        return Math.floor(timeDiff / MINUTE) + 'M';
+    }
+    return `${timeDiff}S`;
+};
+function timePeriod(type) {
+    let endDate = new Date().getTime();
+    const today = new Date();
+    const month = today.getMonth();
+    const year = today.getFullYear();
+    let startDate = null;
+    switch (type) {
+        case '30d':
+            startDate = endDate - 60 * 60 * 24 * 30 * 1000;
+            break;
+        case '60d':
+            startDate = endDate - 60 * 60 * 24 * 60 * 1000;
+            break;
+        case '6m':
+            startDate = endDate - 60 * 60 * 24 * 30 * 6 * 1000;
+            break;
+        case 'this_month':
+            startDate = new Date(year, month, 1).getTime();
+            break;
+        case 'last_month':
+            startDate = new Date(year, month - 1, 1).getTime();
+            endDate = new Date(year, month, 0).getTime();
+            break;
+        case 'this_year':
+            startDate = new Date(year, 0, 1);
+            break;
+        case 'all_time':
+        default:
+            return null;
+    }
+    if (startDate === null && endDate === null) {
+        return null;
+    }
+    return {
+        start_time: new Date(startDate).toISOString(),
+        end_time: new Date(endDate).toISOString(),
+    };
+}
+
+var DateTime = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  formatShortTimeAgo: formatShortTimeAgo,
+  timePeriod: timePeriod
+});
+
+function getRTop(y, fieldHeight, iTextHeight, yRatio) {
+    return iTextHeight - (y + fieldHeight) * yRatio;
+}
+function getRLeft(x, ratio) {
+    return x * ratio;
+}
+function getRValue(y, ratio) {
+    return y * ratio;
+}
+function blobToBase64(image) {
+    const fileReader = new FileReader();
+    return new Promise((resolve, reject) => {
+        fileReader.onerror = () => {
+            reject(new DOMException('Problem reading blob.'));
+        };
+        fileReader.onload = () => {
+            resolve(fileReader.result);
+        };
+        fileReader.readAsDataURL(image);
+    });
+}
+function rescale(r, n) {
+    return r * n;
+}
+
+var Fields = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  blobToBase64: blobToBase64,
+  getRLeft: getRLeft,
+  getRTop: getRTop,
+  getRValue: getRValue,
+  rescale: rescale
+});
+
+/**
+ * Given a File, extract the file's content as a base64 encoded data URL. The response will have a prefix that
+ * includes the MIME type of the file, e.g. "data:image/jpeg;base64,iVBORw0K......"
+ */
+const fileToDataUrl = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve({
+        lastModified: file.lastModified,
+        size: file.size,
+        type: file.type,
+        name: file.name,
+        data: reader.result,
+    });
+    reader.onerror = reject;
+    if (file) {
+        reader.readAsDataURL(file);
+    }
+    else {
+        reject(new Error('Invalid file'));
+    }
+});
+/**
+ * Trigger a download dialog to save a blob as a file on disk.
+ */
+const downloadBlob = (blob, name = 'file.pdf') => {
+    const blobUrl = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = blobUrl;
+    link.download = name;
+    document.body.appendChild(link);
+    link.dispatchEvent(new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+        view: window,
+    }));
+    document.body.removeChild(link);
+};
+
+var Files = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  downloadBlob: downloadBlob,
+  fileToDataUrl: fileToDataUrl
+});
+
+const Countries = [
+    { code: '+7 840', name: 'Abkhazia', value: '+7' },
+    { code: '+93', name: 'Afghanistan', value: '+93' },
+    { code: '+355', name: 'Albania', value: '+355' },
+    { code: '+213', name: 'Algeria', value: '+213' },
+    { code: '+1', name: 'American Samoa', value: '+1' },
+    { code: '+376', name: 'Andorra', value: '+376' },
+    { code: '+244', name: 'Angola', value: '+244' },
+    { code: '+1', name: 'Anguilla', value: '+1' },
+    { code: '+1', name: 'Antigua and Barbuda', value: '+1' },
+    { code: '+54', name: 'Argentina', value: '+54' },
+    { code: '+374', name: 'Armenia', value: '+374' },
+    { code: '+297', name: 'Aruba', value: '+297' },
+    { code: '+247', name: 'Ascension', value: '+247' },
+    { code: '+61', name: 'Australia', value: '+61' },
+    { code: '+672', name: 'Australian External Territories', value: '+672' },
+    { code: '+43', name: 'Austria', value: '+43' },
+    { code: '+994', name: 'Azerbaijan', value: '+994' },
+    { code: '+1', name: 'Bahamas', value: '+1' },
+    { code: '+973', name: 'Bahrain', value: '+973' },
+    { code: '+880', name: 'Bangladesh', value: '+880' },
+    { code: '+1', name: 'Barbados', value: '+1' },
+    { code: '+1', name: 'Barbuda', value: '+1' },
+    { code: '+375', name: 'Belarus', value: '+375' },
+    { code: '+32', name: 'Belgium', value: '+32' },
+    { code: '+501', name: 'Belize', value: '+501' },
+    { code: '+229', name: 'Benin', value: '+229' },
+    { code: '+1', name: 'Bermuda', value: '+1' },
+    { code: '+975', name: 'Bhutan', value: '+975' },
+    { code: '+591', name: 'Bolivia', value: '+591' },
+    { code: '+387', name: 'Bosnia and Herzegovina', value: '+387' },
+    { code: '+267', name: 'Botswana', value: '+267' },
+    { code: '+55', name: 'Brazil', value: '+55' },
+    { code: '+246', name: 'British Indian Ocean Territory', value: '+246' },
+    { code: '+1', name: 'British Virgin Islands', value: '+1' },
+    { code: '+673', name: 'Brunei', value: '+673' },
+    { code: '+359', name: 'Bulgaria', value: '+359' },
+    { code: '+226', name: 'Burkina Faso', value: '+226' },
+    { code: '+257', name: 'Burundi', value: '+257' },
+    { code: '+855', name: 'Cambodia', value: '+855' },
+    { code: '+237', name: 'Cameroon', value: '+237' },
+    { code: '+1', name: 'Canada', value: '+1' },
+    { code: '+238', name: 'Cape Verde', value: '+238' },
+    { code: '+1', name: 'Cayman Islands', value: '+1' },
+    { code: '+236', name: 'Central African Republic', value: '+236' },
+    { code: '+235', name: 'Chad', value: '+235' },
+    { code: '+56', name: 'Chile', value: '+56' },
+    { code: '+86', name: 'China', value: '+86' },
+    { code: '+61', name: 'Christmas Island', value: '+61' },
+    { code: '+61', name: 'Cocos-Keeling Islands', value: '+61' },
+    { code: '+57', name: 'Colombia', value: '+57' },
+    { code: '+269', name: 'Comoros', value: '+269' },
+    { code: '+242', name: 'Congo', value: '+242' },
+    { code: '+243', name: 'Congo, Dem. Rep. of (Zaire)', value: '+243' },
+    { code: '+682', name: 'Cook Islands', value: '+682' },
+    { code: '+506', name: 'Costa Rica', value: '+506' },
+    { code: '+385', name: 'Croatia', value: '+385' },
+    { code: '+53', name: 'Cuba', value: '+53' },
+    { code: '+599', name: 'Curacao', value: '+599' },
+    { code: '+537', name: 'Cyprus', value: '+537' },
+    { code: '+420', name: 'Czech Republic', value: '+420' },
+    { code: '+45', name: 'Denmark', value: '+45' },
+    { code: '+246', name: 'Diego Garcia', value: '+246' },
+    { code: '+253', name: 'Djibouti', value: '+253' },
+    { code: '+1', name: 'Dominica', value: '+1' },
+    { code: '+1', name: 'Dominican Republic', value: '+1' },
+    { code: '+670', name: 'East Timor', value: '+670' },
+    { code: '+56', name: 'Easter Island', value: '+56' },
+    { code: '+593', name: 'Ecuador', value: '+593' },
+    { code: '+20', name: 'Egypt', value: '+20' },
+    { code: '+503', name: 'El Salvador', value: '+503' },
+    { code: '+240', name: 'Equatorial Guinea', value: '+240' },
+    { code: '+291', name: 'Eritrea', value: '+291' },
+    { code: '+372', name: 'Estonia', value: '+372' },
+    { code: '+251', name: 'Ethiopia', value: '+251' },
+    { code: '+500', name: 'Falkland Islands', value: '+500' },
+    { code: '+298', name: 'Faroe Islands', value: '+298' },
+    { code: '+679', name: 'Fiji', value: '+679' },
+    { code: '+358', name: 'Finland', value: '+358' },
+    { code: '+33', name: 'France', value: '+33' },
+    { code: '+596', name: 'Martinique', value: '+596' },
+    { code: '+594', name: 'French Guiana', value: '+594' },
+    { code: '+689', name: 'French Polynesia', value: '+689' },
+    { code: '+241', name: 'Gabon', value: '+241' },
+    { code: '+220', name: 'Gambia', value: '+220' },
+    { code: '+995', name: 'Georgia', value: '+995' },
+    { code: '+49', name: 'Germany', value: '+49' },
+    { code: '+233', name: 'Ghana', value: '+233' },
+    { code: '+350', name: 'Gibraltar', value: '+350' },
+    { code: '+30', name: 'Greece', value: '+30' },
+    { code: '+299', name: 'Greenland', value: '+299' },
+    { code: '+1', name: 'Grenada', value: '+1' },
+    { code: '+590', name: 'Guadeloupe', value: '+590' },
+    { code: '+1', name: 'Guam', value: '+1' },
+    { code: '+502', name: 'Guatemala', value: '+502' },
+    { code: '+224', name: 'Guinea', value: '+224' },
+    { code: '+245', name: 'Guinea-Bissau', value: '+245' },
+    { code: '+595', name: 'Guyana', value: '+595' },
+    { code: '+509', name: 'Haiti', value: '+509' },
+    { code: '+504', name: 'Honduras', value: '+504' },
+    { code: '+852', name: 'Hong Kong SAR China', value: '+852' },
+    { code: '+36', name: 'Hungary', value: '+36' },
+    { code: '+354', name: 'Iceland', value: '+354' },
+    { code: '+91', name: 'India', value: '+91' },
+    { code: '+62', name: 'Indonesia', value: '+62' },
+    { code: '+98', name: 'Iran', value: '+98' },
+    { code: '+964', name: 'Iraq', value: '+964' },
+    { code: '+353', name: 'Ireland', value: '+353' },
+    { code: '+972', name: 'Israel', value: '+972' },
+    { code: '+39', name: 'Italy', value: '+39' },
+    { code: '+225', name: 'Ivory Coast', value: '+225' },
+    { code: '+1', name: 'Jamaica', value: '+1' },
+    { code: '+81', name: 'Japan', value: '+81' },
+    { code: '+962', name: 'Jordan', value: '+962' },
+    { code: '+77', name: 'Kazakhstan', value: '+7' },
+    { code: '+254', name: 'Kenya', value: '+254' },
+    { code: '+686', name: 'Kiribati', value: '+686' },
+    { code: '+965', name: 'Kuwait', value: '+965' },
+    { code: '+996', name: 'Kyrgyzstan', value: '+996' },
+    { code: '+856', name: 'Laos', value: '+856' },
+    { code: '+371', name: 'Latvia', value: '+371' },
+    { code: '+961', name: 'Lebanon', value: '+961' },
+    { code: '+266', name: 'Lesotho', value: '+266' },
+    { code: '+231', name: 'Liberia', value: '+231' },
+    { code: '+218', name: 'Libya', value: '+218' },
+    { code: '+423', name: 'Liechtenstein', value: '+423' },
+    { code: '+370', name: 'Lithuania', value: '+370' },
+    { code: '+352', name: 'Luxembourg', value: '+352' },
+    { code: '+853', name: 'Macau SAR China', value: '+853' },
+    { code: '+389', name: 'Macedonia', value: '+389' },
+    { code: '+261', name: 'Madagascar', value: '+261' },
+    { code: '+265', name: 'Malawi', value: '+265' },
+    { code: '+60', name: 'Malaysia', value: '+60' },
+    { code: '+960', name: 'Maldives', value: '+960' },
+    { code: '+223', name: 'Mali', value: '+223' },
+    { code: '+356', name: 'Malta', value: '+356' },
+    { code: '+692', name: 'Marshall Islands', value: '+692' },
+    { code: '+596', name: 'Martinique', value: '+596' },
+    { code: '+222', name: 'Mauritania', value: '+222' },
+    { code: '+230', name: 'Mauritius', value: '+230' },
+    { code: '+262', name: 'Mayotte or Réunion', value: '+262' },
+    { code: '+52', name: 'Mexico', value: '+52' },
+    { code: '+691', name: 'Micronesia', value: '+691' },
+    { code: '+1', name: 'Midway Island', value: '+1' },
+    { code: '+373', name: 'Moldova', value: '+373' },
+    { code: '+377', name: 'Monaco', value: '+377' },
+    { code: '+976', name: 'Mongolia', value: '+976' },
+    { code: '+382', name: 'Montenegro', value: '+382' },
+    { code: '+1', name: 'Montserrat', value: '+1' },
+    { code: '+212', name: 'Morocco', value: '+212' },
+    { code: '+95', name: 'Myanmar', value: '+95' },
+    { code: '+264', name: 'Namibia', value: '+264' },
+    { code: '+674', name: 'Nauru', value: '+674' },
+    { code: '+977', name: 'Nepal', value: '+977' },
+    { code: '+31', name: 'Netherlands', value: '+31' },
+    { code: '+599', name: 'Netherlands Antilles', value: '+599' },
+    { code: '+1', name: 'Nevis', value: '+1' },
+    { code: '+687', name: 'New Caledonia', value: '+687' },
+    { code: '+64', name: 'New Zealand', value: '+64' },
+    { code: '+505', name: 'Nicaragua', value: '+505' },
+    { code: '+227', name: 'Niger', value: '+227' },
+    { code: '+234', name: 'Nigeria', value: '+234' },
+    { code: '+683', name: 'Niue', value: '+683' },
+    { code: '+672', name: 'Norfolk Island', value: '+672' },
+    { code: '+850', name: 'North Korea', value: '+850' },
+    { code: '+1', name: 'Northern Mariana Islands', value: '+1' },
+    { code: '+47', name: 'Norway', value: '+47' },
+    { code: '+968', name: 'Oman', value: '+968' },
+    { code: '+92', name: 'Pakistan', value: '+92' },
+    { code: '+680', name: 'Palau', value: '+680' },
+    { code: '+970', name: 'Palestinian Territory', value: '+970' },
+    { code: '+507', name: 'Panama', value: '+507' },
+    { code: '+675', name: 'Papua New Guinea', value: '+675' },
+    { code: '+595', name: 'Paraguay', value: '+595' },
+    { code: '+51', name: 'Peru', value: '+51' },
+    { code: '+63', name: 'Philippines', value: '+63' },
+    { code: '+48', name: 'Poland', value: '+48' },
+    { code: '+351', name: 'Portugal', value: '+351' },
+    { code: '+1', name: 'Puerto Rico', value: '+1' },
+    { code: '+974', name: 'Qatar', value: '+974' },
+    { code: '+40', name: 'Romania', value: '+40' },
+    { code: '+7', name: 'Russia', value: '+7' },
+    { code: '+250', name: 'Rwanda', value: '+250' },
+    { code: '508', name: 'Saint Pierre and Miquelon', value: '508' },
+    { code: '+685', name: 'Samoa', value: '+685' },
+    { code: '+378', name: 'San Marino', value: '+378' },
+    { code: '+966', name: 'Saudi Arabia', value: '+966' },
+    { code: '+221', name: 'Senegal', value: '+221' },
+    { code: '+381', name: 'Serbia', value: '+381' },
+    { code: '+248', name: 'Seychelles', value: '+248' },
+    { code: '+232', name: 'Sierra Leone', value: '+232' },
+    { code: '+65', name: 'Singapore', value: '+65' },
+    { code: '+421', name: 'Slovakia', value: '+421' },
+    { code: '+386', name: 'Slovenia', value: '+386' },
+    { code: '+677', name: 'Solomon Islands', value: '+677' },
+    { code: '+27', name: 'South Africa', value: '+27' },
+    { code: '+500', name: 'South Georgia and the South Sandwich Islands', value: '+500' },
+    { code: '+82', name: 'South Korea', value: '+82' },
+    { code: '+34', name: 'Spain', value: '+34' },
+    { code: '+94', name: 'Sri Lanka', value: '+94' },
+    { code: '+249', name: 'Sudan', value: '+249' },
+    { code: '+597', name: 'Suriname', value: '+597' },
+    { code: '+268', name: 'Swaziland', value: '+268' },
+    { code: '+46', name: 'Sweden', value: '+46' },
+    { code: '+41', name: 'Switzerland', value: '+41' },
+    { code: '+963', name: 'Syria', value: '+963' },
+    { code: '+886', name: 'Taiwan', value: '+886' },
+    { code: '+992', name: 'Tajikistan', value: '+992' },
+    { code: '+255', name: 'Tanzania', value: '+255' },
+    { code: '+66', name: 'Thailand', value: '+66' },
+    { code: '+670', name: 'Timor Leste', value: '+670' },
+    { code: '+228', name: 'Togo', value: '+228' },
+    { code: '+690', name: 'Tokelau', value: '+690' },
+    { code: '+676', name: 'Tonga', value: '+676' },
+    { code: '+1', name: 'Trinidad and Tobago', value: '+1' },
+    { code: '+216', name: 'Tunisia', value: '+216' },
+    { code: '+90', name: 'Turkey', value: '+90' },
+    { code: '+993', name: 'Turkmenistan', value: '+993' },
+    { code: '+1', name: 'Turks and Caicos Islands', value: '+1' },
+    { code: '+688', name: 'Tuvalu', value: '+688' },
+    { code: '+1', name: 'U.S. Virgin Islands', value: '+1' },
+    { code: '+256', name: 'Uganda', value: '+256' },
+    { code: '+380', name: 'Ukraine', value: '+380' },
+    { code: '+971', name: 'United Arab Emirates', value: '+971' },
+    { code: '+44', name: 'United Kingdom', value: '+44' },
+    { code: '+1', name: 'United States', value: '+1' },
+    { code: '+598', name: 'Uruguay', value: '+598' },
+    { code: '+998', name: 'Uzbekistan', value: '+998' },
+    { code: '+678', name: 'Vanuatu', value: '+678' },
+    { code: '+58', name: 'Venezuela', value: '+58' },
+    { code: '+84', name: 'Vietnam', value: '+84' },
+    { code: '+1', name: 'Wake Island', value: '+1' },
+    { code: '+681', name: 'Wallis and Futuna', value: '+681' },
+    { code: '+967', name: 'Yemen', value: '+967' },
+    { code: '+260', name: 'Zambia', value: '+260' },
+    { code: '+255', name: 'Zanzibar', value: '+255' },
+    { code: '+263', name: 'Zimbabwe', value: '+263' },
+];
+function getCountryByCode(code) {
+    const found = Countries.find((country) => country.code === code);
+    if (found)
+        return found;
+    if (isFrenchGuiana(code)) {
+        return { code: '+594', name: 'French Guiana', value: '+594' };
+    }
+    else if (isGuadeloupe(code)) {
+        return { code: '+590', name: 'Guadeloupe', value: '+590' };
+    }
+    else if (isMartinique(code)) {
+        return { code: '+596', name: 'Martinique', value: '+596' };
+    }
+    else if (isMayotte(code)) {
+        return { code: '+262', name: 'Mayotte or Réunion', value: '+262' };
+    }
+    return null;
+}
+function isFrenchGuiana(code) {
+    return '+594' === code.substring(0, 4);
+}
+function isGuadeloupe(code) {
+    return '+590' === code.substring(0, 4);
+}
+function isMartinique(code) {
+    return '+596' === code.substring(0, 4);
+}
+function isMayotte(code) {
+    return '+262' === code.substring(0, 4);
+}
+function getPlusOneCountry(code) {
+    let info = null;
+    switch (code.substring(0, 5)) {
+        case '+1684':
+            info = { code: '+1', name: 'American Samoa', value: '+1' };
+            break;
+        case '+1264':
+            info = { code: '+1', name: 'Anguilla', value: '+1' };
+            break;
+        case '+1268':
+            info = { code: '+1', name: 'Antigua and Barbuda', value: '+1' };
+            break;
+        case '+1242':
+            info = { code: '+1', name: 'Bahamas', value: '+1' };
+            break;
+        case '+1246':
+            info = { code: '+1', name: 'Barbados', value: '+1' };
+            break;
+        case '+1441':
+            info = { code: '+1', name: 'Bermuda', value: '+1' };
+            break;
+        case '+1284':
+            info = { code: '+1', name: 'British Virgin Islands', value: '+1' };
+            break;
+        case '+1':
+            info = { code: '+1', name: '', value: '+1' };
+            break;
+    }
+    return info;
+}
+function isCanada(code) {
+    const canadianAreaCodes = [
+        '403',
+        '587',
+        '780',
+        '825',
+        '604',
+        '250',
+        '778',
+        '236',
+        '204',
+        '431',
+        '506',
+        '709',
+        '867',
+        '782',
+        '902',
+        '867',
+        '548',
+        '705',
+        '365',
+        '613',
+        '807',
+        '226',
+        '289',
+        '437',
+        '519',
+        '647',
+        '905',
+        '249',
+        '343',
+        '416',
+        '902',
+        '782',
+        '450',
+        '418',
+        '579',
+        '873',
+        '367',
+        '514',
+        '581',
+        '819',
+        '438',
+        '639',
+        '306',
+        '867',
+    ];
+    const areaCode = code.substring(0, 5);
+    return canadianAreaCodes.findIndex((x) => '+1' + x === areaCode) > -1;
+}
+function isAmericanSamoa(code) {
+    return code.substring(0, 5) === '+1684';
+}
+function isDominicanRepublic(code) {
+    return '+1809' === code.substring(0, 5) || '+1829' === code.substring(0, 5) || '+1849' === code.substring(0, 5);
+}
+function isPuertoRico(code) {
+    return code.substring(0, 5) === '+' || code.substring(0, 5) === '+';
+}
+// need to finish
+function getMatchingCountry(code, substrings) {
+    const toMatch = code.substring(0, substrings);
+    return Countries.filter((c) => c.code === toMatch).length;
+}
+// const e164Regex = new RegExp(/\+[1-9]\d{6,14}/g);
+// export function simpleE164Validator(code: string) {
+//   return (code !== null && code.length < 16 && code.length > 6 && e164Regex.test(code)) || code === '' || code === null;
+// }
+
+var Locales = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Countries: Countries,
+  getCountryByCode: getCountryByCode,
+  getMatchingCountry: getMatchingCountry,
+  getPlusOneCountry: getPlusOneCountry,
+  isAmericanSamoa: isAmericanSamoa,
+  isCanada: isCanada,
+  isDominicanRepublic: isDominicanRepublic,
+  isFrenchGuiana: isFrenchGuiana,
+  isGuadeloupe: isGuadeloupe,
+  isMartinique: isMartinique,
+  isMayotte: isMayotte,
+  isPuertoRico: isPuertoRico
+});
+
+/**
+ * Capitalize the first letter of a string.
+ */
+const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+/**
+ * Convert a phone-number-like string to E164 format.
+ * @see https://46elks.com/kb/e164
+ */
+const convertToE164 = (input) => {
+    // "(212) 555-1212" => +12125551212
+    // "+46766861004" => "+46766861004"
+    // "212-555-1212" => +12125551212
+    // "212.555.1212" => +12125551212
+    // "212 555 1212" => +12125551212
+    let temp = (input || '').trim();
+    // If we are already prefixed, assume the user did it deliberately and attempt to use what they entered. We also short-circuit blanks.
+    if (!temp || temp.startsWith('+')) {
+        return temp;
+    }
+    // Remove any spaces, parenthesis or other punctuation.
+    temp = temp.replace(/[^0-9]/g, '');
+    // If the number begins with a zero, remove the leading zero. Do not combine this with the previous step because it needs to be removed
+    // whether it's the actual first character e.g. `0(5)` or just the first digit e.g. `(05`.
+    temp = temp.replace(/^0/g, '');
+    // Prepend the country code and +. We're assuming US in this case given the target demographic. Users in other countries would/should be
+    // already entering a prefix so they'd shortcut out of this routine via the + prefix check.
+    return `+1${temp}`;
+};
+
+var Strings = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  capitalize: capitalize,
+  convertToE164: convertToE164
+});
+
+/**
+ * Create an array containing a sequence of integers, e.g. [START, START+1, START+2, ...] This is frequently useful
+ * in rendering operations when there is no source array to .map() across.
+ */
+const integerSequence = (start, count) => Array(count)
+    .fill(1)
+    .map((_, index) => index + start);
+/**
+ * Format a profile's full name
+ */
+const formatFullName = (profile) => profile ? `${capitalize(profile.first_name)} ${capitalize(profile.last_name)}` : 'Invalid User';
+/**
+ * Format a profile's initials
+ */
+const formatInitials = (profile) => profile ? `${capitalize(profile.first_name).charAt(0)} ${capitalize(profile.last_name).charAt(0)}` : '--';
+/**
+ * Generate suggested initials for a full name, e.g. "John Doe" will yield "JD".
+ */
+const fullNameToInitials = (name) => name
+    .split(' ')
+    .map((word) => word[0])
+    .join('');
+
+var Primitives = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  formatFullName: formatFullName,
+  formatInitials: formatInitials,
+  fullNameToInitials: fullNameToInitials,
+  integerSequence: integerSequence
+});
+
+var Types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Colors: Colors,
+  DateTime: DateTime,
+  Fields: Fields,
+  Files: Files,
+  Locales: Locales,
+  Primitives: Primitives,
+  Strings: Strings,
+  Token: Token,
+  Types: Types
+});
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+// This file provides a polyfill for managing globals in both NodeJS and browser environments. This is
+// an anti-pattern we'd hoped to avoid, but we have several projects dependending on one common library
+// (this js-sdk) and we want that library to provide a common endpoint to all callers (so authentication
+// tokens only need to be tracked in one place). The trouble is, one of those libraries is based on
+// StencilJS and is compiling its modules into Web Components. Because of how module resolution works,
+// when those Components load js-sdk they get a separate instance. Without messy options like having to
+// pass raw data from the caller to each Component, or pass around references to a common Endpoint, they
+// have no way to access authenticated sessions unless we make the Endpoint a true global.
+//
+// @credit https://github.com/medikoo/es5-ext/blob/master/global.js
+// @credit https://mathiasbynens.be/notes/globalthis
+var naiveFallback = function () {
+    if (typeof self === 'object' && self)
+        return self;
+    if (typeof window === 'object' && window)
+        return window;
+    throw new Error('Unable to resolve global `this`');
+};
+var globalThis_1 = (function () {
+    if (this)
+        return this;
+    // Unexpected strict mode (may happen if e.g. bundled into ESM module)
+    // Fallback to standard globalThis if available
+    if (typeof globalThis === 'object' && globalThis)
+        return globalThis;
+    // Thanks @mathiasbynens -> https://mathiasbynens.be/notes/globalthis
+    // In all ES5+ engines global object inherits from Object.prototype
+    // (if you approached one that doesn't please report)
+    try {
+        Object.defineProperty(Object.prototype, '__global__', {
+            get: function () {
+                return this;
+            },
+            configurable: true,
+        });
+    }
+    catch (error) {
+        // Unfortunate case of updates to Object.prototype being restricted
+        // via preventExtensions, seal or freeze
+        return naiveFallback();
+    }
+    try {
+        // Safari case (window.__global__ works, but __global__ does not)
+        if (!__global__)
+            return naiveFallback();
+        return __global__;
+    }
+    finally {
+        delete Object.prototype.__global__;
+    }
+})();
+
+var globalThis$1 = /*@__PURE__*/getDefaultExportFromCjs(globalThis_1);
+
+// @credit https://derickbailey.com/2016/03/09/creating-a-true-singleton-in-node-js-with-es6-symbols/
+// Also see globalThis for comments about why we're doing this in the first place.
+const ENDPOINT_KEY = Symbol.for('verdocs-default-endpoint');
+const requestLogger = (r) => {
+    // tslint:disable-next-line
+    console.debug(`[JS-SDK] ${r.method.toUpperCase()} ${r.baseURL}${r.url}`, r.data ? JSON.stringify(r.data) : '');
+    return r;
+};
+/**
+ * VerdocsEndpoint is a class wrapper for a specific connection and authorization context for calling the Verdocs APIs.
+ * Endpoints can be used for isolated session tasks.
+ *
+ * For instance, ephemeral signing sessions may be created independently of a caller's status as an authenticated user.
+ * In that case, an Endpoint can be created and authenticated, used for calls related to signing operations, then
+ * discarded once signing is complete.
+ *
+ * Note that endpoint configuration functions return the instance, so they can be chained, e.g.
+ *
+ * ```typescript
+ * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+ *
+ * const endpoint = new VerdocsEndpoint();
+ * endpoint
+ *     .setSessionType('signing')
+ *     .logRequests(true)
+ *     .setClientID('1234)
+ *     .setTimeout(30000);
+ * ```
+ */
+class VerdocsEndpoint {
+    environment = 'verdocs';
+    sessionType = 'user';
+    baseURL = (window.location.origin === 'https://beta.verdocs.com' || window.location.origin === 'https://stage.verdocs.com'
+        ? 'https://stage-api.verdocs.com'
+        : 'https://api.verdocs.com');
+    clientID = 'not-set';
+    timeout = 60000;
+    token = null;
+    nextListenerId = 0;
+    sessionListeners = new Map();
+    requestLoggerId = null;
+    /**
+     * The current user session, or null if not authenticated. May be either a User or Signing session. If set, the
+     * presence of the `document_id` field can be used to differentiate the types. Only signing sessions are associated
+     * with Envelopes.
+     */
+    session = null;
+    api;
+    /**
+     * Create a new VerdocsEndpoint to call Verdocs platform services.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     * const endpoint = new VerdocsEndpoint();
+     * ```
+     */
+    constructor(options) {
+        this.baseURL = options?.baseURL || this.baseURL;
+        this.timeout = options?.timeout || this.timeout;
+        this.environment = options?.environment || this.environment;
+        this.sessionType = options?.sessionType || this.sessionType;
+        this.clientID = options?.clientID || this.clientID;
+        this.api = axios.create({ baseURL: this.baseURL, timeout: this.timeout });
+    }
+    setDefault() {
+        globalThis$1[ENDPOINT_KEY] = this;
+    }
+    static getDefault() {
+        if (!globalThis$1[ENDPOINT_KEY]) {
+            globalThis$1[ENDPOINT_KEY] = new VerdocsEndpoint();
+            window.console.debug('[JS_SDK] Created default endpoint', globalThis$1[ENDPOINT_KEY].baseURL);
+        }
+        return globalThis$1[ENDPOINT_KEY];
+    }
+    /**
+     * Get the current environment.
+     */
+    getEnvironment() {
+        return this.environment;
+    }
+    /**
+     * Get the current session type.
+     */
+    getSessionType() {
+        return this.sessionType;
+    }
+    /**
+     * Get the current base URL. This should rarely be anything other than 'https://api.verdocs.com'.
+     */
+    getBaseURL() {
+        return this.baseURL;
+    }
+    /**
+     * Get the current client ID, if set.
+     */
+    getClientID() {
+        return this.clientID;
+    }
+    /**
+     * Get the current timeout.
+     */
+    getTimeout() {
+        return this.timeout;
+    }
+    /**
+     * Get the current session, if any.
+     */
+    getSession() {
+        return this.session;
+    }
+    /**
+     * Set the operating environment. This should rarely be anything other than 'verdocs'.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setEnvironment('verdocs-stage');
+     * ```
+     */
+    setEnvironment(environment) {
+        this.environment = environment;
+        return this;
+    }
+    /**
+     * Set the session type. In general this should be done immediately when the endpoint is created. Changing the
+     * session type may be done at any time, but may have unintended consequences if the endpoint is shared between
+     * multiple widgets.
+     *
+     * Changing the session type will clear/reload the action session. This may trigger notifications to session state
+     * observers. Apps that use observers to trigger UI updates such as logging the user out should be prepared to
+     * handle this event.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setEnvironment('verdocs-stage');
+     * ```
+     */
+    setSessionType(sessionType) {
+        this.sessionType = sessionType;
+        return this;
+    }
+    /**
+     * Set the base URL for API calls. Should be called only upon direction from Verdocs Customer Solutions Engineering.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setBaseURL('https://api.verdocs.com');
+     * ```
+     */
+    setBaseURL(url) {
+        this.baseURL = url;
+        this.api.defaults.baseURL = url;
+        return this;
+    }
+    /**
+     * Set the Client ID for Verdocs API calls.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setClientID('1234);
+     * ```
+     */
+    setClientID(clientID) {
+        this.clientID = clientID;
+        this.api.defaults.headers.common['X-Client-ID'] = clientID;
+        return this;
+    }
+    /**
+     * Set the timeout for API calls in milliseconds. 5000-20000ms is recommended for most purposes. 15000ms is the default.
+     * Note that some calls may involve rendering operations that require some time to complete, so very short timeouts
+     * are not recommended.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setTimeout(3000);
+     * ```
+     */
+    setTimeout(timeout) {
+        this.timeout = timeout;
+        this.api.defaults.timeout = timeout;
+        return this;
+    }
+    /**
+     * Enable or disable request logging. This may expose sensitive data in the console log, so it should only be used for debugging.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.logRequests(true);
+     * ```
+     */
+    logRequests(enable) {
+        if (enable && this.requestLoggerId === null) {
+            this.requestLoggerId = this.api.interceptors.request.use(requestLogger);
+        }
+        else if (!enable && this.requestLoggerId !== null) {
+            this.api.interceptors.request.eject(this.requestLoggerId);
+        }
+        return this;
+    }
+    /**
+     * Set the authorization token that will be used for Verdocs API calls. This will also set the session metadata
+     * and notify any listeners of the new data.
+     *
+     * If this Endpoint will be used for non-default purposes (e.g. signing, or in an alternate environment) those
+     * settings should be made before calling this. Sessions are persisted to localStorage, and the environment and
+     * type become part of the storage key.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setToken(accessToken);
+     * ```
+     */
+    setToken(token) {
+        if (!token) {
+            return this.clearSession();
+        }
+        const session = decodeAccessTokenBody(token);
+        if (session === null || (session.exp && session.exp * 1000 < new Date().getTime())) {
+            window.console.warn('[JS_SDK] Ignoring attempt to use expired session token');
+            return this.clearSession();
+        }
+        this.token = token;
+        this.session = session;
+        if (this.sessionType === 'user') {
+            this.api.defaults.headers.common.Authorization = `Bearer ${token}`;
+        }
+        else {
+            this.api.defaults.headers.common.signer = `Bearer ${token}`;
+        }
+        localStorage.setItem(this.sessionStorageKey(), token);
+        this.notifySessionListeners();
+        return this;
+    }
+    /**
+     * Retrieves the current session token, if any. Tokens should rarely be used for direct actions, but this is
+     * required by the `<VerdocsView>` and other components to authorize requests to raw PDF files.
+     */
+    getToken() {
+        return this.token;
+    }
+    sessionStorageKey() {
+        return `verdocs-session-${this.getSessionType()}-${this.getEnvironment()}`;
+    }
+    /**
+     * Clear the active session.
+     */
+    clearSession() {
+        localStorage.removeItem(this.sessionStorageKey());
+        delete this.api.defaults.headers.common.Authorization;
+        delete this.api.defaults.headers.common.signer;
+        this.session = null;
+        this.token = null;
+        this.notifySessionListeners();
+        return this;
+    }
+    /**
+     * Clear the active signing session.
+     */
+    clearSignerSession() {
+        localStorage.removeItem(this.sessionStorageKey());
+        delete this.api.defaults.headers.common.Authorization;
+        this.session = null;
+        this.token = null;
+        this.notifySessionListeners();
+        return this;
+    }
+    notifySessionListeners() {
+        this.sessionListeners.forEach((listener) => {
+            try {
+                listener(this, this.session);
+            }
+            catch (e) {
+                // NOOP
+            }
+        });
+    }
+    /**
+     * Subscribe to session state change events.
+     */
+    onSessionChanged(listener) {
+        // There's no value in randomizing this, a simple counter is fine
+        this.nextListenerId++;
+        const listenerSymbol = Symbol.for('' + this.nextListenerId);
+        this.sessionListeners.set(listenerSymbol, listener);
+        return () => {
+            this.sessionListeners.delete(listenerSymbol);
+        };
+    }
+    /**
+     * Load a persisted session from localStorage. Typically called once after the endpoint is configured when the app
+     * or component starts.
+     */
+    loadSession() {
+        const token = localStorage.getItem(this.sessionStorageKey());
+        if (!token) {
+            return this.clearSession();
+        }
+        return this.setToken(token);
+    }
+}
+
+export { index$5 as Envelopes, Models, index$4 as Organizations, index$3 as Sessions, index$2 as Templates, index$1 as Users, index as Utils, VerdocsEndpoint };
+//# sourceMappingURL=index.mjs.map