@bitblit/ratchet-warden-common 4.0.84-alpha

package/dist/es/client/provider/warden-logged-in-user-wrapper.js

@@ -0,0 +1 @@
+export {};

package/dist/es/client/provider/warden-recent-login-descriptor.js

@@ -0,0 +1 @@
+export {};

package/dist/es/client/provider/warden-user-service-event-processing-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/es/client/provider/warden-user-service-options.js

@@ -0,0 +1 @@
+export {};

package/dist/es/client/warden-client.js

@@ -0,0 +1,129 @@
+import { ErrorRatchet, Logger, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+export class WardenClient {
+    constructor(commandSender, jwtProvider) {
+        this.commandSender = commandSender;
+        this.jwtProvider = jwtProvider;
+        RequireRatchet.notNullOrUndefined(commandSender, 'commandSender');
+        RequireRatchet.notNullOrUndefined(jwtProvider, 'jwtProvider');
+    }
+    async exchangeCommand(cmd, returnErrors) {
+        const asString = JSON.stringify(cmd);
+        const resp = await this.commandSender.sendCommand(asString, this.jwtProvider.fetchCurrentLoggedInJwtToken());
+        const parsed = JSON.parse(resp);
+        if (parsed?.error && !returnErrors) {
+            ErrorRatchet.throwFormattedErr('%s', parsed.error);
+        }
+        return parsed;
+    }
+    async createAccount(contact, sendCode, label, tags) {
+        const cmd = {
+            createAccount: {
+                contact: contact,
+                sendCode: sendCode,
+                label: label,
+                tags: tags,
+            },
+        };
+        const rval = await this.exchangeCommand(cmd);
+        return rval.createAccount;
+    }
+    async generateWebAuthnAuthenticationChallengeForUserId(userId) {
+        const cmd = {
+            generateWebAuthnAuthenticationChallengeForUserId: userId,
+        };
+        const rval = await this.exchangeCommand(cmd);
+        const parsed = JSON.parse(rval.generateWebAuthnAuthenticationChallengeForUserId.dataAsJson);
+        return parsed;
+    }
+    async generateWebAuthnRegistrationChallengeForLoggedInUser() {
+        const cmd = {
+            generateWebAuthnRegistrationChallengeForLoggedInUser: true,
+        };
+        const rval = await this.exchangeCommand(cmd);
+        const parsed = JSON.parse(rval.generateWebAuthnRegistrationChallengeForLoggedInUser.dataAsJson);
+        return parsed;
+    }
+    async removeWebAuthnRegistration(userId, credId) {
+        const cmd = {
+            removeWebAuthnRegistration: {
+                userId: userId,
+                credentialId: credId,
+            },
+        };
+        const rval = await this.exchangeCommand(cmd);
+        return rval.removeWebAuthnRegistration;
+    }
+    async removeWebAuthnRegistrationFromLoggedInUser(input) {
+        const cmd = {
+            removeWebAuthnRegistrationFromLoggedInUser: input,
+        };
+        const rval = await this.exchangeCommand(cmd);
+        return rval.removeWebAuthnRegistrationFromLoggedInUser;
+    }
+    async removeContactFromLoggedInUser(input) {
+        const cmd = {
+            removeContactFromLoggedInUser: input,
+        };
+        const rval = await this.exchangeCommand(cmd);
+        return rval.removeContactFromLoggedInUser;
+    }
+    async sendExpiringValidationToken(contact) {
+        const cmd = {
+            sendExpiringValidationToken: contact,
+        };
+        const rval = await this.exchangeCommand(cmd);
+        return rval.sendExpiringValidationToken;
+    }
+    async addContactToLoggedInUser(contact) {
+        const cmd = {
+            addContactToLoggedInUser: contact,
+        };
+        const rval = await this.exchangeCommand(cmd);
+        return rval.addContactToLoggedInUser;
+    }
+    async addWebAuthnRegistrationToLoggedInUser(data) {
+        const cmd = {
+            addWebAuthnRegistrationToLoggedInUser: {
+                dataAsJson: JSON.stringify(data),
+            },
+        };
+        const rval = await this.exchangeCommand(cmd);
+        return rval.addWebAuthnRegistrationToLoggedInUser;
+    }
+    async performLoginCmd(login) {
+        const loginCmd = {
+            performLogin: login,
+        };
+        const cmdResponse = await this.exchangeCommand(loginCmd);
+        return cmdResponse.performLogin;
+    }
+    async refreshJwtToken(oldJwtToken) {
+        let rval = null;
+        if (StringRatchet.trimToNull(oldJwtToken)) {
+            try {
+                const resp = await this.exchangeCommand({ refreshJwtToken: oldJwtToken });
+                rval = resp.refreshJwtToken;
+            }
+            catch (err) {
+                Logger.error('JwtRefresh Failed : %s', err);
+            }
+        }
+        return rval;
+    }
+    async executeExpiringTokenBasedLogin(contact, expiringToken) {
+        let rval = null;
+        try {
+            const loginCmd = {
+                contact: contact,
+                expiringToken: expiringToken,
+            };
+            rval = await this.performLoginCmd(loginCmd);
+            if (rval?.jwtToken) {
+            }
+        }
+        catch (err) {
+            Logger.error('ExpiringToken login Failed : %s', err);
+        }
+        return rval;
+    }
+}

package/dist/es/client/warden-delegating-current-user-providing-user-service-event-processing-provider.js

@@ -0,0 +1,40 @@
+import { BehaviorSubject } from 'rxjs';
+export class WardenDelegatingCurrentUserProvidingUserServiceEventProcessingProvider {
+    constructor(wrapped) {
+        this.wrapped = wrapped;
+        this._currentUserSubject = new BehaviorSubject(null);
+    }
+    fetchCurrentLoggedInJwtToken() {
+        return this?._currentUserSubject?.getValue()?.jwtToken;
+    }
+    get currentUserSubject() {
+        return this._currentUserSubject;
+    }
+    onAutomaticLogout() {
+        if (this.wrapped) {
+            this.wrapped.onAutomaticLogout();
+        }
+    }
+    onAutomaticTokenRefresh(refreshUser) {
+        if (this.wrapped) {
+            this.wrapped.onAutomaticTokenRefresh(refreshUser);
+        }
+    }
+    onLoginFailure(reason) {
+        if (this.wrapped) {
+            this.wrapped.onLoginFailure(reason);
+        }
+    }
+    onLogout() {
+        if (this.wrapped) {
+            this.wrapped.onLogout();
+        }
+        this.currentUserSubject.next(null);
+    }
+    onSuccessfulLogin(newUser) {
+        if (this.wrapped) {
+            this.wrapped.onSuccessfulLogin(newUser);
+        }
+        this.currentUserSubject.next(newUser);
+    }
+}

package/dist/es/client/warden-user-service.js

@@ -0,0 +1,245 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { timer } from 'rxjs';
+import jwt_decode from 'jwt-decode';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { startAuthentication, startRegistration } from '@simplewebauthn/browser';
+export class WardenUserService {
+    constructor(options) {
+        this.options = options;
+        this._autoRefreshEnabled = false;
+        Logger.info('Initializing user service');
+        const stored = this.options.loggedInUserProvider.fetchLoggedInUserWrapper();
+        if (WardenUserService.wrapperIsExpired(stored)) {
+            Logger.info('Stored token is expired, removing it');
+            this.options.loggedInUserProvider.logOutUser();
+        }
+        else {
+            this.options.eventProcessor.onSuccessfulLogin(stored);
+        }
+        const timerSeconds = this.options.loginCheckTimerPingSeconds || 2.5;
+        this.loggedInTimerSubscription = timer(0, timerSeconds * 1000).subscribe((t) => this.checkForAutoLogoutOrRefresh(t));
+    }
+    get serviceOptions() {
+        return this.options;
+    }
+    async createAccount(contact, sendCode, label, tags) {
+        const rval = await this.options.wardenClient.createAccount(contact, sendCode, label, tags);
+        if (this.options.recentLoginProvider && StringRatchet.trimToNull(rval)) {
+            this.options.recentLoginProvider.saveNewUser(rval, label, contact);
+        }
+        return rval;
+    }
+    async addContactToLoggedInUser(contact) {
+        return this.options.wardenClient.addContactToLoggedInUser(contact);
+    }
+    get autoRefreshEnabled() {
+        return this._autoRefreshEnabled;
+    }
+    set autoRefreshEnabled(newValue) {
+        if (newValue) {
+            if (this.options.allowAutoRefresh) {
+                this._autoRefreshEnabled = true;
+            }
+            else {
+                throw new Error('Cannot enable auto-refresh - this is disabled in the user service options');
+            }
+        }
+        else {
+            this._autoRefreshEnabled = false;
+        }
+    }
+    async checkForAutoLogoutOrRefresh(t) {
+        Logger.debug('Checking for auto-logout or refresh : %s', t);
+        const current = this.fetchLoggedInUserWrapper();
+        if (current) {
+            const thresholdSeconds = this.options.autoLoginHandlingThresholdSeconds || 10;
+            const secondsLeft = current.expirationEpochSeconds - Math.floor(Date.now() / 1000);
+            if (secondsLeft < thresholdSeconds) {
+                if (this.autoRefreshEnabled) {
+                    Logger.info('Under threshold, initiating auto-refresh');
+                    const result = await this.refreshToken();
+                    this.options.eventProcessor.onAutomaticTokenRefresh(result);
+                }
+                else {
+                    Logger.info('Under threshold, initiating auto-logout');
+                    this.logout();
+                }
+            }
+        }
+    }
+    logout() {
+        this.options.loggedInUserProvider.logOutUser();
+        this.options.eventProcessor.onLogout();
+    }
+    static wrapperIsExpired(value) {
+        const rval = value?.userObject?.exp && value.expirationEpochSeconds < Date.now() / 1000;
+        return rval;
+    }
+    fetchLoggedInUserWrapper() {
+        let tmp = this.options.loggedInUserProvider.fetchLoggedInUserWrapper();
+        if (tmp) {
+            if (WardenUserService.wrapperIsExpired(tmp)) {
+                Logger.info('Token is expired - auto logout triggered');
+                this.logout();
+                tmp = null;
+            }
+        }
+        return tmp;
+    }
+    loggedInUserHasRole(role) {
+        let rval = false;
+        if (StringRatchet.trimToNull(role)) {
+            const t = this.fetchLoggedInUserWrapper();
+            const testRole = role.toLowerCase();
+            rval = t?.userObject?.roles && !!t.userObject.roles.find((r) => r.toLowerCase() === testRole);
+        }
+        return rval;
+    }
+    isLoggedIn() {
+        const t = this.fetchLoggedInUserWrapper();
+        return !!t;
+    }
+    fetchLoggedInUserJwtObject() {
+        const t = this.fetchLoggedInUserWrapper();
+        return t ? t.userObject : null;
+    }
+    fetchLoggedInUserJwtToken() {
+        const t = this.fetchLoggedInUserWrapper();
+        return t ? t.jwtToken : null;
+    }
+    fetchLoggedInUserObject() {
+        const t = this.fetchLoggedInUserJwtObject();
+        return t ? t.user : null;
+    }
+    fetchLoggedInUserExpirationEpochSeconds() {
+        const t = this.fetchLoggedInUserJwtObject();
+        return t ? t.exp : null;
+    }
+    fetchLoggedInUserRemainingSeconds() {
+        const t = this.fetchLoggedInUserJwtObject();
+        return t ? t.exp - Math.floor(Date.now() / 1000) : null;
+    }
+    updateLoggedInUserFromTokenString(token) {
+        let rval = null;
+        if (!StringRatchet.trimToNull(token)) {
+            Logger.info('Called updateLoggedInUserFromTokenString with empty string - logging out');
+            this.logout();
+        }
+        else {
+            Logger.info('updateLoggedInUserFromTokenString : %s', token);
+            const parsed = jwt_decode(token);
+            if (parsed) {
+                rval = {
+                    userObject: parsed,
+                    jwtToken: token,
+                    expirationEpochSeconds: parsed.exp,
+                };
+                this.options.loggedInUserProvider.setLoggedInUserWrapper(rval);
+                this.updateRecentLoginsFromWardenEntrySummary(parsed.loginData);
+                this.options.eventProcessor.onSuccessfulLogin(rval);
+            }
+            else {
+                Logger.warn('Failed to parse token %s - ignoring login and triggering failure');
+                this.options.eventProcessor.onLoginFailure('Could not parse token string');
+            }
+        }
+        return rval;
+    }
+    async refreshToken() {
+        let rval = null;
+        const currentWrapper = this.fetchLoggedInUserWrapper();
+        if (!currentWrapper) {
+            Logger.info('Could not refresh - no token available');
+        }
+        else {
+            const newToken = await this.options.wardenClient.refreshJwtToken(currentWrapper.jwtToken);
+            rval = await this.updateLoggedInUserFromTokenString(newToken);
+        }
+        return rval;
+    }
+    async sendExpiringCode(contact) {
+        return this.options.wardenClient.sendExpiringValidationToken(contact);
+    }
+    async processWardenLoginResults(resp) {
+        let rval = null;
+        if (resp) {
+            Logger.info('Warden: response : %j ', resp);
+            if (resp.jwtToken) {
+                Logger.info('Applying login');
+                rval = await this.updateLoggedInUserFromTokenString(resp.jwtToken);
+            }
+            else if (resp.error) {
+                this.options.eventProcessor.onLoginFailure(resp.error);
+            }
+            else {
+                Logger.error('Response contained neither token nor error');
+                this.options.eventProcessor.onLoginFailure('Response contained neither token nor error');
+            }
+        }
+        else {
+            Logger.error('Login call failed');
+            this.options.eventProcessor.onLoginFailure('Login call returned null');
+        }
+        return rval;
+    }
+    updateRecentLoginsFromWardenEntrySummary(res) {
+        if (this.options.recentLoginProvider && res) {
+            Logger.info('UserService : Saving recent login %j', res);
+            this.options.recentLoginProvider.saveRecentLogin(res);
+        }
+        else {
+            Logger.info('Not saving recent login - no storage configured or no data passed');
+        }
+    }
+    updateRecentLoginsFromLoggedInUserWrapper(res) {
+        this.updateRecentLoginsFromWardenEntrySummary(res?.userObject?.loginData);
+    }
+    async executeWebAuthnBasedLogin(userId) {
+        const resp = await this.executeWebAuthnLoginToWardenLoginResults(userId);
+        const rval = await this.processWardenLoginResults(resp);
+        this.updateRecentLoginsFromLoggedInUserWrapper(rval);
+        return rval;
+    }
+    async removeWebAuthnRegistrationFromLoggedInUser(input) {
+        const rval = await this.options.wardenClient.removeWebAuthnRegistrationFromLoggedInUser(input);
+        return rval;
+    }
+    async removeContactFromLoggedInUser(input) {
+        const rval = await this.options.wardenClient.removeContactFromLoggedInUser(input);
+        return rval;
+    }
+    async executeValidationTokenBasedLogin(contact, token) {
+        Logger.info('Warden: executeValidationTokenBasedLogin : %j : %s ', contact, token);
+        const resp = await this.options.wardenClient.performLoginCmd({ contact: contact, expiringToken: token });
+        const rval = await this.processWardenLoginResults(resp);
+        this.updateRecentLoginsFromLoggedInUserWrapper(rval);
+        return rval;
+    }
+    async saveCurrentDeviceAsWebAuthnForCurrentUser() {
+        const input = await this.options.wardenClient.generateWebAuthnRegistrationChallengeForLoggedInUser();
+        const creds = await startRegistration(input);
+        const output = await this.options.wardenClient.addWebAuthnRegistrationToLoggedInUser(creds);
+        this.updateRecentLoginsFromWardenEntrySummary(output);
+        return output;
+    }
+    async executeWebAuthnLoginToWardenLoginResults(userId) {
+        let rval = null;
+        try {
+            const input = await this.options.wardenClient.generateWebAuthnAuthenticationChallengeForUserId(userId);
+            Logger.info('Got login challenge : %s', input);
+            const creds = await startAuthentication(input);
+            Logger.info('Got creds: %j', creds);
+            const loginCmd = {
+                userId: userId,
+                webAuthn: creds,
+            };
+            rval = await this.options.wardenClient.performLoginCmd(loginCmd);
+            if (rval?.jwtToken) {
+            }
+        }
+        catch (err) {
+            Logger.error('WebauthN Failed : %s', err);
+        }
+        return rval;
+    }
+}

package/dist/es/common/command/create-account.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/command/remove-web-authn-registration.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/command/warden-command-response.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/command/warden-command.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/command/web-authn-object-wrapper.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-contact-type.js

@@ -0,0 +1,5 @@
+export var WardenContactType;
+(function (WardenContactType) {
+    WardenContactType["TextCapablePhoneNumber"] = "TextCapablePhoneNumber";
+    WardenContactType["EmailAddress"] = "EmailAddress";
+})(WardenContactType || (WardenContactType = {}));

package/dist/es/common/model/warden-contact.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-customer-message-type.js

@@ -0,0 +1,4 @@
+export var WardenCustomerMessageType;
+(function (WardenCustomerMessageType) {
+    WardenCustomerMessageType["ExpiringCode"] = "ExpiringCode";
+})(WardenCustomerMessageType || (WardenCustomerMessageType = {}));

package/dist/es/common/model/warden-entry-summary.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-jwt-token.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-login-request.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-login-results.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-store-registration-response-type.js

@@ -0,0 +1,6 @@
+export var WardenStoreRegistrationResponseType;
+(function (WardenStoreRegistrationResponseType) {
+    WardenStoreRegistrationResponseType["Verified"] = "Verified";
+    WardenStoreRegistrationResponseType["Failed"] = "Failed";
+    WardenStoreRegistrationResponseType["Error"] = "Error";
+})(WardenStoreRegistrationResponseType || (WardenStoreRegistrationResponseType = {}));

package/dist/es/common/model/warden-store-registration-response.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-team-role.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-user-decoration.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-web-authn-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/es/common/model/warden-web-authn-transport-future-type.js

@@ -0,0 +1,9 @@
+export var WardenWebAuthnTransportFutureType;
+(function (WardenWebAuthnTransportFutureType) {
+    WardenWebAuthnTransportFutureType["ble"] = "ble";
+    WardenWebAuthnTransportFutureType["internal"] = "internal";
+    WardenWebAuthnTransportFutureType["nfc"] = "nfc";
+    WardenWebAuthnTransportFutureType["usb"] = "usb";
+    WardenWebAuthnTransportFutureType["cable"] = "cable";
+    WardenWebAuthnTransportFutureType["hybrid"] = "hybrid";
+})(WardenWebAuthnTransportFutureType || (WardenWebAuthnTransportFutureType = {}));

package/dist/es/common/util/warden-utils.js

@@ -0,0 +1,104 @@
+import { WardenContactType } from '../model/warden-contact-type';
+import { Logger, StringRatchet } from '@bitblit/ratchet-common';
+export class WardenUtils {
+    constructor() { }
+    static extractContactsOfType(req, type) {
+        let rval = null;
+        if (req?.contactMethods) {
+            rval = req.contactMethods.filter((s) => s.type === type).map((s) => s.value);
+        }
+        return rval;
+    }
+    static validLoginRequest(req) {
+        let rval = false;
+        if (req) {
+            if (StringRatchet.trimToNull(req.userId) || WardenUtils.validContact(req.contact)) {
+                if (StringRatchet.trimToNull(req.expiringToken) || StringRatchet.trimToNull(req.jwtTokenToRefresh) || req.webAuthn) {
+                    rval = true;
+                }
+            }
+        }
+        return rval;
+    }
+    static stringToWardenContact(input) {
+        let rval = null;
+        const type = WardenUtils.stringToContactType(input);
+        if (type) {
+            rval = {
+                type: type,
+                value: input,
+            };
+        }
+        else {
+            Logger.error('Failed to convert a string to a contact type', input);
+        }
+        return rval;
+    }
+    static teamRolesToRoles(teamRoles) {
+        const rval = teamRoles?.length ? teamRoles.map((t) => WardenUtils.teamRoleToRoleString(t)) : [];
+        return rval;
+    }
+    static roleStringsToTeamRoles(roles) {
+        const rval = roles?.length ? roles.map((t) => WardenUtils.roleStringToTeamRole(t)) : [];
+        return rval;
+    }
+    static roleStringToTeamRole(role) {
+        let rval = null;
+        if (role && role.indexOf('_/_') >= 0) {
+            const sp = role.split('_/_');
+            rval = {
+                team: sp[0],
+                role: sp[1],
+            };
+        }
+        return rval;
+    }
+    static teamRoleToRoleString(tr) {
+        let rval = null;
+        if (tr?.role && tr.team) {
+            rval = tr.team + '_/_' + tr.role;
+        }
+        return rval;
+    }
+    static stringToContactType(input) {
+        let rval = null;
+        if (!!StringRatchet.trimToNull(input)) {
+            rval = WardenUtils.stringIsEmailAddress(input) ? WardenContactType.EmailAddress : null;
+            rval = !rval && WardenUtils.stringIsPhoneNumber(input) ? WardenContactType.TextCapablePhoneNumber : rval;
+        }
+        return rval;
+    }
+    static validContact(contact) {
+        let rval = false;
+        if (contact?.type && StringRatchet.trimToNull(contact?.value)) {
+            switch (contact.type) {
+                case WardenContactType.EmailAddress:
+                    rval = WardenUtils.stringIsEmailAddress(contact.value);
+                    break;
+                case WardenContactType.TextCapablePhoneNumber:
+                    rval = WardenUtils.stringIsPhoneNumber(contact.value);
+                    break;
+                default:
+                    rval = false;
+            }
+        }
+        return rval;
+    }
+    static stringIsEmailAddress(value) {
+        return !!value.match(/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/);
+    }
+    static stringIsPhoneNumber(value) {
+        return !!value.match(/^[\\+]?[(]?[0-9]{3}[)]?[-\\s\\.]?[0-9]{3}[-\\s\\.]?[0-9]{4,6}$/im);
+    }
+    static stripWardenEntryToSummary(we) {
+        const rval = we
+            ? {
+                userId: we.userId,
+                userLabel: we.userLabel,
+                contactMethods: we.contactMethods,
+                webAuthnAuthenticatorIds: (we.webAuthnAuthenticators || []).map((s) => s.credentialIdBase64),
+            }
+            : null;
+        return rval;
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,37 @@
+export * from './build/ratchet-warden-common-info';
+export * from './client/warden-client';
+export * from './client/warden-delegating-current-user-providing-user-service-event-processing-provider';
+export * from './client/warden-user-service';
+export * from './client/provider/warden-client-abstract-recent-login-provider';
+export * from './client/provider/warden-client-current-logged-in-jwt-token-provider';
+export * from './client/provider/warden-client-local-storage-logged-in-user-provider';
+export * from './client/provider/warden-client-local-storage-recent-login-provider';
+export * from './client/provider/warden-client-recent-login-provider';
+export * from './client/provider/warden-client-transient-memory-logged-in-user-provider';
+export * from './client/provider/warden-client-transient-memory-recent-login-provider';
+export * from './client/provider/warden-command-exchange-provider';
+export * from './client/provider/warden-logged-in-user-provider';
+export * from './client/provider/warden-logged-in-user-wrapper';
+export * from './client/provider/warden-recent-login-descriptor';
+export * from './client/provider/warden-user-service-event-processing-provider';
+export * from './client/provider/warden-user-service-options';
+export * from './common/command/create-account';
+export * from './common/command/remove-web-authn-registration';
+export * from './common/command/warden-command-response';
+export * from './common/command/warden-command';
+export * from './common/command/web-authn-object-wrapper';
+export * from './common/model/warden-contact-type';
+export * from './common/model/warden-contact';
+export * from './common/model/warden-customer-message-type';
+export * from './common/model/warden-entry-summary';
+export * from './common/model/warden-entry';
+export * from './common/model/warden-jwt-token';
+export * from './common/model/warden-login-request';
+export * from './common/model/warden-login-results';
+export * from './common/model/warden-store-registration-response-type';
+export * from './common/model/warden-store-registration-response';
+export * from './common/model/warden-team-role';
+export * from './common/model/warden-user-decoration';
+export * from './common/model/warden-web-authn-entry';
+export * from './common/model/warden-web-authn-transport-future-type';
+export * from './common/util/warden-utils';