@verdocs/js-sdk 3.1.2 → 3.1.4

package/Envelopes/Envelopes.d.ts

@@ -1,6 +1,8 @@
-import { IEnvelope, IEnvelopesSummary, IRecipient, ISigningSession, TEnvelopeUpdateResult, IDocumentFieldSettings, IEnvelopeDocument, TEnvelopeStatus, TRecipientStatus } from './Types';
+import { IEnvelope, IEnvelopesSummary, IRecipient, IDocumentFieldSettings, IEnvelopeDocument } from './Types';
 import { ICreateEnvelopeRole, IEnvelopesSearchResult, ISigningSessionRequest } from './Types';
+import { TEnvelopeUpdateResult, TEnvelopeStatus, TRecipientStatus } from './Types';
 import { VerdocsEndpoint } from '../VerdocsEndpoint';
+import { ISigningSession } from '../Sessions/Types';
 export interface ICreateEnvelopeRequest {
     template_id: string;
     roles: ICreateEnvelopeRole[];

package/Envelopes/Permissions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Various helpers to identify available operations for an envelope by a user.
+ *
+ * @module
+ */
+import { IEnvelope } from './Types';
+import { TSession } from '../Sessions/Types';
+/**
+ * Check to see if the user owns the envelope.
+ */
+export declare const userIsEnvelopeOwner: (session: TSession, envelope: IEnvelope) => boolean;
+/**
+ * Check to see if the user owns the envelope.
+ */
+export declare const userIsEnvelopeRecipient: (session: TSession, envelope: IEnvelope) => boolean;
+/**
+ * Check to see if the user owns the envelope.
+ */
+export declare const userCanCancelEnvelope: (session: TSession, envelope: IEnvelope) => boolean;
+/**
+ * Check to see if the user owns the envelope.
+ */
+export declare const userCanFinishEnvelope: (session: TSession, envelope: IEnvelope) => boolean;

package/Envelopes/Permissions.js

@@ -0,0 +1,33 @@
+/**
+ * Various helpers to identify available operations for an envelope by a user.
+ *
+ * @module
+ */
+import { EnvelopeStates } from './Types';
+/**
+ * Check to see if the user owns the envelope.
+ */
+export var userIsEnvelopeOwner = function (session, envelope) { return envelope.profile_id === (session === null || session === void 0 ? void 0 : session.profile_id); };
+/**
+ * Check to see if the user owns the envelope.
+ */
+export var userIsEnvelopeRecipient = function (session, envelope) { return envelope.profile_id === (session === null || session === void 0 ? void 0 : session.profile_id); };
+/**
+ * Check to see if the user owns the envelope.
+ */
+export var userCanCancelEnvelope = function (session, envelope) {
+    return userIsEnvelopeOwner(session, envelope) &&
+        envelope.status !== EnvelopeStates.COMPLETE &&
+        envelope.status !== EnvelopeStates.DECLINED &&
+        envelope.status !== EnvelopeStates.CANCELED;
+};
+// export type TEnvelopeStatus = 'complete' | 'pending' | 'in progress' | 'declined' | 'canceled';
+/**
+ * Check to see if the user owns the envelope.
+ */
+export var userCanFinishEnvelope = function (session, envelope) {
+    return userIsEnvelopeOwner(session, envelope) &&
+        envelope.status !== EnvelopeStates.COMPLETE &&
+        envelope.status !== EnvelopeStates.DECLINED &&
+        envelope.status !== EnvelopeStates.CANCELED;
+};

package/Envelopes/Types.d.ts

@@ -1,25 +1,10 @@
 import { IProfile } from '../Users/Types';
 import { IPage } from '../Templates/Types';
-export type TRecipientAction = 'submit' | 'decline' | 'prepare' | 'update';
 export interface ISigningSessionRequest {
     envelopeId: string;
     roleId: string;
     inviteCode: string;
 }
-export interface ISigningSession {
-    profile_id: string;
-    envelope_id: string;
-    role: string;
-    email: string;
-    access_key: {
-        id: string;
-        type: string;
-    };
-    iss: string;
-    aud: string;
-    exp: number;
-    iat: number;
-}
 export interface IInPersonAccessKey {
     id: string;
     created_at: string;
@@ -31,9 +16,37 @@ export interface IInPersonAccessKey {
     first_used: string | null;
     last_used: string | null;
 }
-export type TEnvelopeStatus = 'complete' | 'pending' | 'in progress' | 'declined' | 'canceled';
-export type TRecipientStatus = 'invited' | 'opened' | 'signed' | 'submitted' | 'canceled' | 'pending' | 'declined';
-export type TRecipientType = 'signer' | 'cc' | 'approver';
+export declare enum RecipientActions {
+    SUBMIT = "submit",
+    DECLINE = "decline",
+    PREPARE = "prepare",
+    UPDATE = "update"
+}
+export type TRecipientAction = `${RecipientActions}`;
+export declare enum EnvelopeStates {
+    COMPLETE = "complete",
+    PENDING = "pending",
+    IN_PROGRESS = "in progress",
+    DECLINED = "declined",
+    CANCELED = "canceled"
+}
+export type TEnvelopeStatus = `${EnvelopeStates}`;
+export declare enum RecipientStates {
+    INVITED = "invited",
+    OPENED = "opened",
+    SIGNED = "signed",
+    SUBMITTED = "submitted",
+    CANCELED = "canceled",
+    PENDING = "pending",
+    DECLINED = "declined"
+}
+export type TRecipientStatus = `${RecipientStates}`;
+export declare enum RecipientTypes {
+    SIGNER = "signer",
+    CC = "cc",
+    APPROVER = "approver"
+}
+export type TRecipientType = `${RecipientTypes}`;
 /**
  * One entry in an envelope search result.
  * NOTE: Many of the fields here are undefined unless "summary=true" is included in the search terms
@@ -176,7 +189,20 @@ export interface IDocumentFieldSettings {
     maximum_checked?: number;
     [key: string]: any;
 }
-export type TDocumentFieldType = 'signature' | 'initial' | 'checkbox_group' | 'radio_button_group' | 'textbox' | 'timestamp' | 'date' | 'dropdown' | 'textarea' | 'attachment' | 'payment';
+export declare enum DocumentFieldTypes {
+    SIGNATURE = "signature",
+    INITIAL = "initial",
+    CHECKBOX_GROUP = "checkbox_group",
+    RADIO_BUTTON_GROUP = "radio_button_group",
+    TEXTBOX = "textbox",
+    TIMESTAMP = "timestamp",
+    DATE = "date",
+    DROPDOWN = "dropdown",
+    TEXTAREA = "textarea",
+    ATTACHMENT = "attachment",
+    PAYMENT = "payment"
+}
+export type TDocumentFieldType = `${DocumentFieldTypes}`;
 export interface IDocumentField {
     /**
      * The ID of the document the field is for. For historical reasons, this is called `envelope_id` because documents

package/Envelopes/Types.js

@@ -1 +1,45 @@
-export {};
+export var RecipientActions;
+(function (RecipientActions) {
+    RecipientActions["SUBMIT"] = "submit";
+    RecipientActions["DECLINE"] = "decline";
+    RecipientActions["PREPARE"] = "prepare";
+    RecipientActions["UPDATE"] = "update";
+})(RecipientActions || (RecipientActions = {}));
+export var EnvelopeStates;
+(function (EnvelopeStates) {
+    EnvelopeStates["COMPLETE"] = "complete";
+    EnvelopeStates["PENDING"] = "pending";
+    EnvelopeStates["IN_PROGRESS"] = "in progress";
+    EnvelopeStates["DECLINED"] = "declined";
+    EnvelopeStates["CANCELED"] = "canceled";
+})(EnvelopeStates || (EnvelopeStates = {}));
+export var RecipientStates;
+(function (RecipientStates) {
+    RecipientStates["INVITED"] = "invited";
+    RecipientStates["OPENED"] = "opened";
+    RecipientStates["SIGNED"] = "signed";
+    RecipientStates["SUBMITTED"] = "submitted";
+    RecipientStates["CANCELED"] = "canceled";
+    RecipientStates["PENDING"] = "pending";
+    RecipientStates["DECLINED"] = "declined";
+})(RecipientStates || (RecipientStates = {}));
+export var RecipientTypes;
+(function (RecipientTypes) {
+    RecipientTypes["SIGNER"] = "signer";
+    RecipientTypes["CC"] = "cc";
+    RecipientTypes["APPROVER"] = "approver";
+})(RecipientTypes || (RecipientTypes = {}));
+export var DocumentFieldTypes;
+(function (DocumentFieldTypes) {
+    DocumentFieldTypes["SIGNATURE"] = "signature";
+    DocumentFieldTypes["INITIAL"] = "initial";
+    DocumentFieldTypes["CHECKBOX_GROUP"] = "checkbox_group";
+    DocumentFieldTypes["RADIO_BUTTON_GROUP"] = "radio_button_group";
+    DocumentFieldTypes["TEXTBOX"] = "textbox";
+    DocumentFieldTypes["TIMESTAMP"] = "timestamp";
+    DocumentFieldTypes["DATE"] = "date";
+    DocumentFieldTypes["DROPDOWN"] = "dropdown";
+    DocumentFieldTypes["TEXTAREA"] = "textarea";
+    DocumentFieldTypes["ATTACHMENT"] = "attachment";
+    DocumentFieldTypes["PAYMENT"] = "payment";
+})(DocumentFieldTypes || (DocumentFieldTypes = {}));

package/Envelopes/index.d.ts

@@ -1,4 +1,5 @@
 export * as Envelopes from './Envelopes';
+export * as Permissions from './Permissions';
 export * as Recipients from './Recipients';
 export * as Signatures from './Signatures';
 export * as Initials from './Initials';

package/Envelopes/index.js

@@ -1,4 +1,5 @@
 export * as Envelopes from './Envelopes';
+export * as Permissions from './Permissions';
 export * as Recipients from './Recipients';
 export * as Signatures from './Signatures';
 export * as Initials from './Initials';

package/Sessions/Types.d.ts

@@ -4,7 +4,9 @@ export interface ISigningSessionRequest {
     roleId: string;
     inviteCode: string;
 }
-/** A Signing Session connects a caller to a role within an envelope, and can be used only for calls related to signing that envelope. */
+/**
+ * A Signing Session connects a caller to a role within an envelope, and can be used only for calls related to signing that envelope.
+ */
 export interface ISigningSession {
     profile_id: string;
     envelope_id: string;
@@ -20,7 +22,9 @@ export interface ISigningSession {
     iat: number;
     [key: string]: any;
 }
-/** A User Session connects a caller to a Verdocs profile, and can be used for any operations that profile may perform. */
+/**
+ * A User Session connects a caller to a Verdocs profile, and can be used for any operations that profile may perform.
+ */
 export interface IUserSession {
     sub: string;
     email: string;
@@ -35,5 +39,12 @@ export interface IUserSession {
     plans?: TPlan[];
     [key: string]: any;
 }
+/**
+ * Verdocs supports two types of authenticated sessions: User and Signing. Both behave similarly and have similar
+ * properties, but signing sessions only have access to a small set of signing-related functions.
+ */
 export type TSessionType = 'user' | 'signing';
+/**
+ * An authenticated session within Verdocs, either for signing or regular user-based operations.
+ */
 export type TSession = IUserSession | ISigningSession | null;

package/Sessions/index.d.ts

@@ -1 +1,5 @@
-export * as Types from './Types';
+import { TSession } from './Types';
+/**
+ * Confirm whether the user has all of the specified permissions.
+ */
+export declare const userHasPermissions: (session: TSession, permissions: string[]) => boolean;

package/Sessions/index.js

@@ -1 +1,6 @@
-export * as Types from './Types';
+/**
+ * Confirm whether the user has all of the specified permissions.
+ */
+export var userHasPermissions = function (session, permissions) {
+    return permissions.every(function (perm) { return ((session === null || session === void 0 ? void 0 : session.permissions) || []).includes(perm); });
+};

package/Templates/Permissions.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Various helpers to identify available operations for a template by a user.
+ *
+ * @module
+ */
+import { ITemplate, ITemplateSummaryEntry } from './Types';
+import { TSession } from '../Sessions/Types';
+/**
+ * Check to see if the user created the template.
+ */
+export declare const userIsTemplateCreator: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean | null;
+/**
+ * Check to see if a template is "shared" with the user.
+ */
+export declare const userHasSharedTemplate: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean | null;
+/**
+ * Check to see if the user can create a personal/private template.
+ */
+export declare const userCanCreatePersonalTemplate: (session: TSession) => boolean;
+/**
+ * Check to see if the user can create an org-shared template.
+ */
+export declare const userCanCreateOrgTemplate: (session: TSession) => boolean;
+/**
+ * Check to see if the user can create a public template.
+ */
+export declare const userCanCreatePublicTemplate: (session: TSession) => boolean;
+/**
+ * Check to see if the user can read/view a template.
+ */
+export declare const userCanReadTemplate: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean | null;
+/**
+ * Check to see if the user can update a tempate.
+ */
+export declare const userCanUpdateTemplate: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean | null;
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export declare const userCanMakeTemplatePrivate: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean;
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export declare const userCanMakeTemplateShared: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean;
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export declare const userCanMakeTemplatePublic: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean;
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export declare const userCanChangeOrgVisibility: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean | null;
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export declare const userCanDeleteTemplate: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean;
+/**
+ * Confirm whether the user can create an envelope using the specified template.
+ */
+export declare const userCanSendTemplate: (session: TSession, template: ITemplate | ITemplateSummaryEntry) => boolean | null;
+/**
+ * Confirm whether the user can create a new template.
+ */
+export declare const userCanCreateTemplate: (session: TSession) => boolean;
+/**
+ * Check to see if the user can "build" the template (use the field builder). The user must have write access to the
+ * template, and the template must have at least one signer role.
+ */
+export declare const userCanBuildTemplate: (session: TSession, template: ITemplate) => boolean | null;
+/**
+ * Check to see if the user can preview the template. The user must have read access to the template, the template must
+ * have at least one signer, and every signer must have at least one field.
+ */
+export declare const userCanPreviewTemplate: (session: TSession, template: ITemplate) => boolean | null;

package/Templates/Permissions.js

@@ -0,0 +1,124 @@
+/**
+ * Various helpers to identify available operations for a template by a user.
+ *
+ * @module
+ */
+import { TemplateSenderTypes } from './Types';
+import { userHasPermissions } from '../Sessions';
+import { Permissions } from '../Users/Types';
+/**
+ * Check to see if the user created the template.
+ */
+export var userIsTemplateCreator = function (session, template) {
+    return session && template && session.profile_id === template.profile_id;
+};
+/**
+ * Check to see if a template is "shared" with the user.
+ */
+export var userHasSharedTemplate = function (session, template) {
+    return session && template && !template.is_personal && session.organization_id === template.organization_id;
+};
+/**
+ * Check to see if the user can create a personal/private template.
+ */
+export var userCanCreatePersonalTemplate = function (session) {
+    return userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_CREATE_PERSONAL]);
+};
+/**
+ * Check to see if the user can create an org-shared template.
+ */
+export var userCanCreateOrgTemplate = function (session) { return userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_CREATE_ORG]); };
+/**
+ * Check to see if the user can create a public template.
+ */
+export var userCanCreatePublicTemplate = function (session) { return userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_CREATE_PUBLIC]); };
+/**
+ * Check to see if the user can read/view a template.
+ */
+export var userCanReadTemplate = function (session, template) {
+    return template.is_public ||
+        userIsTemplateCreator(session, template) ||
+        (userHasSharedTemplate(session, template) && userHasPermissions(session, [Permissions.TEMPLATE_MEMBER_READ]));
+};
+/**
+ * Check to see if the user can update a tempate.
+ */
+export var userCanUpdateTemplate = function (session, template) {
+    return userIsTemplateCreator(session, template) ||
+        (userHasSharedTemplate(session, template) &&
+            userHasPermissions(session, [Permissions.TEMPLATE_MEMBER_READ, Permissions.TEMPLATE_MEMBER_WRITE]));
+};
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export var userCanMakeTemplatePrivate = function (session, template) {
+    return userIsTemplateCreator(session, template)
+        ? userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_CREATE_PERSONAL])
+        : userHasPermissions(session, [Permissions.TEMPLATE_MEMBER_VISIBILITY]);
+};
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export var userCanMakeTemplateShared = function (session, template) {
+    return userIsTemplateCreator(session, template)
+        ? userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_CREATE_ORG])
+        : userHasPermissions(session, [Permissions.TEMPLATE_MEMBER_VISIBILITY]);
+};
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export var userCanMakeTemplatePublic = function (session, template) {
+    return userIsTemplateCreator(session, template)
+        ? userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_CREATE_PUBLIC])
+        : userHasPermissions(session, [Permissions.TEMPLATE_MEMBER_VISIBILITY]);
+};
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export var userCanChangeOrgVisibility = function (session, template) {
+    return userIsTemplateCreator(session, template) && userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_CREATE_PERSONAL]);
+};
+/**
+ * Check to see if the user can change whether a template is personal vs org-shared.
+ */
+export var userCanDeleteTemplate = function (session, template) {
+    return userIsTemplateCreator(session, template)
+        ? userHasPermissions(session, [Permissions.TEMPLATE_CREATOR_DELETE])
+        : userHasPermissions(session, [Permissions.TEMPLATE_MEMBER_DELETE]);
+};
+/**
+ * Confirm whether the user can create an envelope using the specified template.
+ */
+export var userCanSendTemplate = function (session, template) {
+    switch (template.sender) {
+        case TemplateSenderTypes.CREATOR:
+            return userIsTemplateCreator(session, template);
+        case TemplateSenderTypes.ORGANIZATION_MEMBER:
+        case TemplateSenderTypes.ORGANIZATION_MEMBER_AS_CREATOR:
+            return userIsTemplateCreator(session, template) || template.organization_id === (session === null || session === void 0 ? void 0 : session.organization_id);
+        default:
+            return true;
+    }
+};
+/**
+ * Confirm whether the user can create a new template.
+ */
+export var userCanCreateTemplate = function (session) {
+    return userCanCreatePersonalTemplate(session) || userCanCreateOrgTemplate(session) || userCanCreatePublicTemplate(session);
+};
+/**
+ * Check to see if the user can "build" the template (use the field builder). The user must have write access to the
+ * template, and the template must have at least one signer role.
+ */
+export var userCanBuildTemplate = function (session, template) {
+    return userCanUpdateTemplate(session, template) && (template.roles || []).filter(function (role) { return role.type === 'signer'; }).length > 0;
+};
+/**
+ * Check to see if the user can preview the template. The user must have read access to the template, the template must
+ * have at least one signer, and every signer must have at least one field.
+ */
+export var userCanPreviewTemplate = function (session, template) {
+    var hasPermission = userCanReadTemplate(session, template);
+    var signers = (template.roles || []).filter(function (role) { return role.type === 'signer'; });
+    return hasPermission && signers.length > 0 && signers.every(function (signer) { return (signer.fields || []).length > 0; });
+};

package/Templates/Types.d.ts

@@ -124,18 +124,6 @@ export interface ITemplateSummaryEntry {
     tag_name: string | null;
     is_starred: boolean;
 }
-export type TTemplateSender = 'creator' | 'organization_member' | 'organization_member_as_creator' | 'everyone' | 'everyone_as_creator';
-export declare enum TemplatePermissions {
-    TEMPLATE_CREATOR_CREATE_PUBLIC = "template:creator:create:public",
-    TEMPLATE_CREATOR_CREATE_ORG = "template:creator:create:org",
-    TEMPLATE_CREATOR_CREATE_PERSONAL = "template:creator:create:personal",
-    TEMPLATE_CREATOR_DELETE = "template:creator:delete",
-    TEMPLATE_CREATOR_VISIBILITY = "template:creator:visibility",
-    TEMPLATE_MEMBER_READ = "template:member:read",
-    TEMPLATE_MEMBER_WRITE = "template:member:write",
-    TEMPLATE_MEMBER_DELETE = "template:member:delete",
-    TEMPLATE_MEMBER_VISIBILITY = "template:member:visibility"
-}
 export declare enum TemplateSenderTypes {
     CREATOR = "creator",
     ORGANIZATION_MEMBER = "organization_member",
@@ -143,6 +131,7 @@ export declare enum TemplateSenderTypes {
     EVERYONE = "everyone",
     EVERYONE_AS_CREATOR = "everyone_as_creator"
 }
+export type TTemplateSender = `${TemplateSenderTypes}`;
 export declare enum TemplateActions {
     CREATE_PERSONAL = "create_personal",
     CREATE_ORG = "create_org",
@@ -154,6 +143,7 @@ export declare enum TemplateActions {
     CHANGE_VISIBILITY_ORG = "change_visibility_org",
     CHANGE_VISIBILITY_PUBLIC = "change_visibility_public"
 }
+export type TTemplateAction = `${TemplateActions}`;
 export interface ITemplateSearchParams {
     id?: string;
     name?: string;

package/Templates/Types.js

@@ -1,15 +1,3 @@
-export var TemplatePermissions;
-(function (TemplatePermissions) {
-    TemplatePermissions["TEMPLATE_CREATOR_CREATE_PUBLIC"] = "template:creator:create:public";
-    TemplatePermissions["TEMPLATE_CREATOR_CREATE_ORG"] = "template:creator:create:org";
-    TemplatePermissions["TEMPLATE_CREATOR_CREATE_PERSONAL"] = "template:creator:create:personal";
-    TemplatePermissions["TEMPLATE_CREATOR_DELETE"] = "template:creator:delete";
-    TemplatePermissions["TEMPLATE_CREATOR_VISIBILITY"] = "template:creator:visibility";
-    TemplatePermissions["TEMPLATE_MEMBER_READ"] = "template:member:read";
-    TemplatePermissions["TEMPLATE_MEMBER_WRITE"] = "template:member:write";
-    TemplatePermissions["TEMPLATE_MEMBER_DELETE"] = "template:member:delete";
-    TemplatePermissions["TEMPLATE_MEMBER_VISIBILITY"] = "template:member:visibility";
-})(TemplatePermissions || (TemplatePermissions = {}));
 export var TemplateSenderTypes;
 (function (TemplateSenderTypes) {
     TemplateSenderTypes["CREATOR"] = "creator";

package/Users/Types.d.ts

@@ -1,17 +1,52 @@
 import { IGroup, IOrganization } from '../Organizations/Types';
 export type TRequestStatus = 'OK' | 'ERROR';
 /**
- * An operation within Verdocs the user may perform.
+ * Operation within Verdocs that users may perform.
  */
-export type TPermission = 'org:view' | 'member:view' | 'org:update' | 'member:add' | 'member:remove' | 'admin:add' | 'admin:remove' | 'org:delete' | 'org:transfer' | 'owner:add' | 'owner:remove' | 'template:creator:create:personal' | 'template:creator:visibility' | 'template:creator:create:org' | 'template:member:read' | 'template:member:write' | 'template:member:visibility' | 'template:creator:delete' | 'template:member:delete' | 'template:creator:create:public' | 'rform:access' | 'rcommon:access' | 'org:list' | 'org:create';
+export declare enum Permissions {
+    RCOMMON = "rcommon:access",
+    RFORM_ACCESS = "rform:access",
+    ORG_CREATE = "org:create",
+    ORG_VIEW = "org:view",
+    ORG_UPDATE = "org:update",
+    ORG_DELETE = "org:delete",
+    ORG_TRANSFER = "org:transfer",
+    ORG_LIST = "org:list",
+    OWNER_ADD = "owner:add",
+    OWNER_REMOVE = "owner:remove",
+    ADMIN_ADD = "admin:add",
+    ADMIN_REMOVE = "admin:remove",
+    MEMBER_VIEW = "member:view",
+    MEMBER_ADD = "member:add",
+    MEMBER_REMOVE = "member:remove",
+    TEMPLATE_CREATOR_DELETE = "template:creator:delete",
+    TEMPLATE_CREATOR_VISIBILITY = "template:creator:visibility",
+    TEMPLATE_CREATOR_CREATE_ORG = "template:creator:create:org",
+    TEMPLATE_CREATOR_CREATE_PUBLIC = "template:creator:create:public",
+    TEMPLATE_CREATOR_CREATE_PERSONAL = "template:creator:create:personal",
+    TEMPLATE_MEMBER_READ = "template:member:read",
+    TEMPLATE_MEMBER_WRITE = "template:member:write",
+    TEMPLATE_MEMBER_DELETE = "template:member:delete",
+    TEMPLATE_MEMBER_VISIBILITY = "template:member:visibility"
+}
+export type TPermission = `${Permissions}`;
 /**
  * Plans provide access to Verdocs product features.
  */
-export type TPlan = 'env:essential' | 'org:standard';
+export declare enum Plans {
+    ENV_ESSENTIAL = "env:essential",
+    ORG_STANDARD = "org:standard"
+}
+export type TPlan = `${Plans}`;
 /**
  * Roles provide access to groups of permissions.
  */
-export type TRole = 'owner' | 'basic_user' | 'member';
+export declare enum Roles {
+    OWNER = "owner",
+    BASIC_USER = "basic_user",
+    MEMBER = "member"
+}
+export type TRole = `${Roles}`;
 export interface IProfile {
     /** The unique ID of the profile */
     id: string;

package/Users/Types.js

@@ -1 +1,47 @@
-export {};
+/**
+ * Operation within Verdocs that users may perform.
+ */
+export var Permissions;
+(function (Permissions) {
+    Permissions["RCOMMON"] = "rcommon:access";
+    Permissions["RFORM_ACCESS"] = "rform:access";
+    Permissions["ORG_CREATE"] = "org:create";
+    Permissions["ORG_VIEW"] = "org:view";
+    Permissions["ORG_UPDATE"] = "org:update";
+    Permissions["ORG_DELETE"] = "org:delete";
+    Permissions["ORG_TRANSFER"] = "org:transfer";
+    Permissions["ORG_LIST"] = "org:list";
+    Permissions["OWNER_ADD"] = "owner:add";
+    Permissions["OWNER_REMOVE"] = "owner:remove";
+    Permissions["ADMIN_ADD"] = "admin:add";
+    Permissions["ADMIN_REMOVE"] = "admin:remove";
+    Permissions["MEMBER_VIEW"] = "member:view";
+    Permissions["MEMBER_ADD"] = "member:add";
+    Permissions["MEMBER_REMOVE"] = "member:remove";
+    Permissions["TEMPLATE_CREATOR_DELETE"] = "template:creator:delete";
+    Permissions["TEMPLATE_CREATOR_VISIBILITY"] = "template:creator:visibility";
+    Permissions["TEMPLATE_CREATOR_CREATE_ORG"] = "template:creator:create:org";
+    Permissions["TEMPLATE_CREATOR_CREATE_PUBLIC"] = "template:creator:create:public";
+    Permissions["TEMPLATE_CREATOR_CREATE_PERSONAL"] = "template:creator:create:personal";
+    Permissions["TEMPLATE_MEMBER_READ"] = "template:member:read";
+    Permissions["TEMPLATE_MEMBER_WRITE"] = "template:member:write";
+    Permissions["TEMPLATE_MEMBER_DELETE"] = "template:member:delete";
+    Permissions["TEMPLATE_MEMBER_VISIBILITY"] = "template:member:visibility";
+})(Permissions || (Permissions = {}));
+/**
+ * Plans provide access to Verdocs product features.
+ */
+export var Plans;
+(function (Plans) {
+    Plans["ENV_ESSENTIAL"] = "env:essential";
+    Plans["ORG_STANDARD"] = "org:standard";
+})(Plans || (Plans = {}));
+/**
+ * Roles provide access to groups of permissions.
+ */
+export var Roles;
+(function (Roles) {
+    Roles["OWNER"] = "owner";
+    Roles["BASIC_USER"] = "basic_user";
+    Roles["MEMBER"] = "member";
+})(Roles || (Roles = {}));

package/Utils/Strings.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Capitalize the first letter of a string.
+ */
+export declare const capitalize: (str: string) => string;

package/Utils/Strings.js

@@ -0,0 +1,4 @@
+/**
+ * Capitalize the first letter of a string.
+ */
+export var capitalize = function (str) { return str.charAt(0).toUpperCase() + str.slice(1); };

package/Utils/Token.d.ts

@@ -1,5 +1,4 @@
-import { ISigningSession } from '../Envelopes/Types';
-import { IUserSession } from '../Sessions/Types';
+import { TSession } from '../Sessions/Types';
 /**
  * Simplified, Node/Browser-safe alternative to atob() for base64 decoding.
  * Modified from https://github.com/MaxArt2501/base64-js/blob/master/base64.js
@@ -17,4 +16,4 @@ export declare const decodeJWTBody: (token: string) => any;
  * 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.
  */
-export declare const decodeAccessTokenBody: (token: string) => IUserSession | ISigningSession | null;
+export declare const decodeAccessTokenBody: (token: string) => TSession;

package/Utils/index.d.ts

@@ -4,4 +4,5 @@ export * as Fields from './Fields';
 export * as Files from './Files';
 export * as Locales from './Locales';
 export * as Primitives from './Primitives';
+export * as Strings from './Strings';
 export * as Token from './Token';

package/Utils/index.js

@@ -4,4 +4,5 @@ export * as Fields from './Fields';
 export * as Files from './Files';
 export * as Locales from './Locales';
 export * as Primitives from './Primitives';
+export * as Strings from './Strings';
 export * as Token from './Token';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdocs/js-sdk",
-  "version": "3.1.2",
+  "version": "3.1.4",
   "private": false,
   "homepage": "https://github.com/Verdocs/js-sdk",
   "description": "Verdocs JS SDK",