@keeper-security/keeperapi 16.0.0 → 16.0.3

package/src/restMessages.ts

@@ -0,0 +1,311 @@
+import {Writer} from 'protobufjs'
+import {AccountSummary, Authentication, BreachWatch, Automator, Enterprise, Records, ServiceLogger, SsoCloud} from './proto'
+
+export interface RestMessage<TIn, TOut> {
+    path: string
+    toBytes(): Uint8Array
+    fromBytes(data: Uint8Array): TOut
+}
+
+type encoderClass<T> = {
+    encode: (message: T, writer?: Writer) => Writer;
+}
+
+type decoderClass<T> = {
+    decode: (reader: Uint8Array, length?: number) => T;
+}
+
+function createMessage<TIn, TOut>(data: TIn, path: string, encoder: encoderClass<TIn>, decoder: decoderClass<TOut>): RestMessage<TIn, TOut> {
+    return {
+        path: path,
+        toBytes(): Uint8Array {
+            return encoder ? encoder.encode(data).finish() : null
+        },
+        fromBytes(data: Uint8Array): TOut {
+            return decoder.decode(data)
+        }
+    }
+}
+
+// new login
+
+export const registerDeviceMessage = (data: Authentication.IDeviceRegistrationRequest): RestMessage<Authentication.IDeviceRegistrationRequest, Authentication.IDevice> =>
+    createMessage(data, 'authentication/register_device', Authentication.DeviceRegistrationRequest, Authentication.Device)
+
+export const registerDeviceInRegionMessage = (data: Authentication.IRegisterDeviceInRegionRequest): RestMessage<Authentication.IRegisterDeviceInRegionRequest, {}> =>
+    createMessage(data, 'authentication/register_device_in_region', Authentication.RegisterDeviceInRegionRequest, null)
+
+export const updateDeviceMessage = (data: Authentication.IDeviceUpdateRequest): RestMessage<Authentication.IDeviceUpdateRequest, {}> =>
+    createMessage(data, 'authentication/update_device', Authentication.DeviceUpdateRequest, null)
+
+export const requestDeviceVerificationMessage = (data: Authentication.IDeviceVerificationRequest): RestMessage<Authentication.IDeviceVerificationRequest, {}> =>
+    createMessage(data, 'authentication/request_device_verification', Authentication.DeviceVerificationRequest, null)
+
+export const requestCreateUserMessage = (data: Authentication.ICreateUserRequest, isSso: boolean): RestMessage<Authentication.ICreateUserRequest, {}> =>
+    createMessage(data, isSso ? 'authentication/create_user_sso' : 'authentication/request_create_user', Authentication.CreateUserRequest, null)
+
+export const startLoginMessage = (data: Authentication.IStartLoginRequest): RestMessage<Authentication.IStartLoginRequest, Authentication.ILoginResponse> =>
+    createMessage(data, 'authentication/start_login', Authentication.StartLoginRequest, Authentication.LoginResponse)
+
+export const validateAuthHashMessage = (data: Authentication.IValidateAuthHashRequest): RestMessage<Authentication.IValidateAuthHashRequest, Authentication.ILoginResponse> =>
+    createMessage(data, 'authentication/validate_auth_hash', Authentication.ValidateAuthHashRequest, Authentication.LoginResponse)
+
+export const twoFactorValidateMessage = (data: Authentication.ITwoFactorValidateRequest): RestMessage<Authentication.ITwoFactorValidateRequest, Authentication.ITwoFactorValidateResponse> =>
+    createMessage(data, 'authentication/2fa_validate', Authentication.TwoFactorValidateRequest, Authentication.TwoFactorValidateResponse)
+
+export const twoFactorSend2FAPushMessage = (data: Authentication.ITwoFactorSendPushRequest): RestMessage<Authentication.ITwoFactorSendPushRequest, {}> =>
+    createMessage(data, 'authentication/2fa_send_push', Authentication.TwoFactorSendPushRequest, null)
+
+export const twoFactorAdd = (data: Authentication.ITwoFactorAddRequest): RestMessage<Authentication.ITwoFactorAddRequest, Authentication.ITwoFactorAddResponse> =>
+    createMessage(data, 'authentication/2fa_add', Authentication.TwoFactorAddRequest, Authentication.TwoFactorAddResponse)
+
+export const twoFactorAddValidate = (data: Authentication.ITwoFactorValidateRequest): RestMessage<Authentication.ITwoFactorValidateRequest, Authentication.ITwoFactorAddResponse> =>
+    createMessage(data, 'authentication/2fa_add_validate', Authentication.TwoFactorValidateRequest, Authentication.TwoFactorAddResponse)
+
+export const twoFactorList = (data: Authentication.ITwoFactorChannelInfo): RestMessage<Authentication.ITwoFactorChannelInfo, Authentication.ITwoFactorListResponse> =>
+    createMessage(data, 'authentication/2fa_list', Authentication.TwoFactorChannelInfo, Authentication.TwoFactorListResponse)
+
+export const twoFactorRename = (data: Authentication.ITwoFactorRenameRequest): RestMessage<Authentication.ITwoFactorRenameRequest, {}> =>
+    createMessage(data, 'authentication/2fa_rename', Authentication.TwoFactorRenameRequest, null)
+
+export const twoFactorDelete = (data: Authentication.ITwoFactorDeleteRequest): RestMessage<Authentication.ITwoFactorDeleteRequest, {}> =>
+    createMessage(data, 'authentication/2fa_delete', Authentication.TwoFactorDeleteRequest, null)
+
+export const twoFactorDuoStatus = (data: Authentication.ITwoFactorDuoStatus): RestMessage<Authentication.ITwoFactorDuoStatus, {}> =>
+    createMessage(data, 'authentication/2fa_duo_status', Authentication.TwoFactorDuoStatus, null)
+
+export const approveDeviceMessage = (data: Authentication.IApproveDeviceRequest): RestMessage<Authentication.IApproveDeviceRequest, {}> =>
+    createMessage(data, 'authentication/approve_device', Authentication.ApproveDeviceRequest, null)
+
+export const approveDeviceInstantMessage = (data: Authentication.IApproveDeviceRequest): RestMessage<Authentication.IApproveDeviceRequest, {}> =>
+    createMessage(data, 'authentication/approve_device_instant', Authentication.ApproveDeviceRequest, null)
+
+export const validateDeviceVerificationCodeMessage = (data: Authentication.IValidateDeviceVerificationCodeRequest): RestMessage<Authentication.IValidateDeviceVerificationCodeRequest, {}> =>
+    createMessage(data, 'authentication/validate_device_verification_code', Authentication.ValidateDeviceVerificationCodeRequest, null)
+
+export const validateCreateUserVerificationCodeMessage = (data: Authentication.IValidateCreateUserVerificationCodeRequest): RestMessage<Authentication.IValidateCreateUserVerificationCodeRequest, {}> =>
+    createMessage(data, 'authentication/validate_create_user_verification_code', Authentication.ValidateCreateUserVerificationCodeRequest, null)
+
+export const approveUserDevicesMessage = (data: Enterprise.IApproveUserDevicesRequest): RestMessage<Enterprise.IApproveUserDevicesRequest, Enterprise.IApproveUserDevicesResponse> =>
+    createMessage(data, 'enterprise/approve_user_devices', Enterprise.ApproveUserDevicesRequest, Enterprise.ApproveUserDevicesResponse)
+
+export const registerEncryptedDataKeyForDeviceMessage = (data: Authentication.IRegisterDeviceDataKeyRequest): RestMessage<Authentication.IRegisterDeviceDataKeyRequest, {}> =>
+    createMessage(data, 'authentication/register_encrypted_data_key_for_device', Authentication.RegisterDeviceDataKeyRequest, null)
+
+export const setUserSettingMessage = (data: Authentication.IUserSettingRequest): RestMessage<Authentication.IUserSettingRequest, {}> =>
+    createMessage(data, 'setting/set_user_setting', Authentication.UserSettingRequest, null)
+
+export const requestDeviceAdminApprovalMessage = (data: Authentication.IDeviceVerificationRequest): RestMessage<Authentication.IDeviceVerificationRequest, {}> =>
+    createMessage(data, 'authentication/request_device_admin_approval', Authentication.DeviceVerificationRequest, null)
+
+export const requestSaltAndIterations = (): RestMessage<{}, Authentication.Salt> =>
+    createMessage({}, 'authentication/get_salt_and_iterations', null, Authentication.Salt)
+
+export const validateMasterPasswordMessage = (data: Authentication.IMasterPasswordReentryRequest): RestMessage<Authentication.IMasterPasswordReentryRequest, {}> =>
+    createMessage(data, 'authentication/validate_master_password', Authentication.MasterPasswordReentryRequest, null)
+
+export const startLoginMessageFromSessionToken = (data: Authentication.IStartLoginRequest): RestMessage<Authentication.IStartLoginRequest, Authentication.ILoginResponse> =>
+    createMessage(data, 'authentication/login_from_existing_session_token', Authentication.StartLoginRequest, Authentication.LoginResponse)
+
+export const keepAliveMessage = (): RestMessage< {}, {}> => createMessage({}, 'keep_alive', null, null)
+
+export const logoutV3Message = (): RestMessage<{}, {}> => createMessage({}, 'vault/logout_v3', null, null)
+
+// end new login
+
+export const deviceMessage = (data: Authentication.IDeviceRequest): RestMessage<Authentication.IDeviceRequest, Authentication.IDeviceResponse> =>
+    createMessage(data, 'authentication/get_device_token', Authentication.DeviceRequest, Authentication.DeviceResponse)
+
+export const preLoginMessage = (data: Authentication.IPreLoginRequest): RestMessage<Authentication.IPreLoginRequest, Authentication.IPreLoginResponse> =>
+    createMessage(data, 'authentication/pre_login', Authentication.PreLoginRequest, Authentication.PreLoginResponse)
+
+export const securityReportMessage = (data: Authentication.ISecurityReportRequest): RestMessage<Authentication.ISecurityReportRequest, Authentication.ISecurityReportResponse> =>
+    createMessage(data, 'enterprise/get_security_report_data', Authentication.SecurityReportRequest, Authentication.SecurityReportResponse)
+
+export const enterpriseNodeToManagedCompanyMessage = (data: Enterprise.INodeToManagedCompanyRequest): RestMessage<Enterprise.INodeToManagedCompanyRequest, {}> =>
+    createMessage(data, 'enterprise/node_to_managed_company', Enterprise.NodeToManagedCompanyRequest, null)
+
+export const recordTypesGetMessage = (data: Records.IRecordTypesRequest): RestMessage<Records.IRecordTypesRequest, Records.IRecordTypesResponse> =>
+    createMessage(data, 'vault/get_record_types', Records.RecordTypesRequest, Records.RecordTypesResponse)
+
+export const recordTypeAddMessage = (data: Records.IRecordType): RestMessage<Records.IRecordType, Records.IRecordTypeModifyResponse> =>
+    createMessage(data, 'vault/record_type_add', Records.RecordType, Records.RecordTypeModifyResponse)
+
+export const recordTypeUpdateMessage = (data: Records.IRecordType): RestMessage<Records.IRecordType, Records.IRecordTypeModifyResponse> =>
+    createMessage(data, 'vault/record_type_update', Records.RecordType, Records.RecordTypeModifyResponse)
+
+export const recordTypeDeleteMessage = (data: Records.IRecordType): RestMessage<Records.IRecordType, Records.IRecordTypeModifyResponse> =>
+    createMessage(data, 'vault/record_type_delete', Records.RecordType, Records.RecordTypeModifyResponse)
+
+export const recordsGetMessage = (data: Records.IRecordsGetRequest): RestMessage<Records.IRecordsGetRequest, Records.IRecordsGetResponse> =>
+    createMessage(data, 'vault/records_get', Records.RecordsGetRequest, Records.RecordsGetResponse)
+
+export const recordsAddMessage = (data: Records.IRecordsAddRequest): RestMessage<Records.IRecordsAddRequest, Records.IRecordsModifyResponse> =>
+    createMessage(data, 'vault/records_add', Records.RecordsAddRequest, Records.RecordsModifyResponse)
+
+export const recordsUpdateMessage = (data: Records.IRecordsUpdateRequest): RestMessage<Records.IRecordsUpdateRequest, Records.IRecordsModifyResponse> =>
+    createMessage(data, 'vault/records_update', Records.RecordsUpdateRequest, Records.RecordsModifyResponse)
+
+export const fileDownloadMessage = (data: Records.IFilesGetRequest): RestMessage<Records.IFilesGetRequest, Records.IFilesGetResponse> =>
+    createMessage(data, 'vault/files_download', Records.FilesGetRequest, Records.FilesGetResponse)
+
+export const fileAddMessage = (data: Records.IFilesAddRequest): RestMessage<Records.IFilesAddRequest, Records.IFilesAddResponse> =>
+    createMessage(data, 'vault/files_add', Records.FilesAddRequest, Records.FilesAddResponse)
+
+export const recordsConvert3Message = (data: Records.RecordsConvertToV3Request): RestMessage<Records.IRecordsConvertToV3Request, Records.RecordsModifyResponse> =>
+    createMessage(data, 'vault/records_convert3', Records.RecordsConvertToV3Request, Records.RecordsModifyResponse)
+
+export const recordAddAuditData = (data: Records.AddAuditDataRequest): RestMessage<Records.IAddAuditDataRequest, {}> => createMessage(data, 'vault/record_add_audit_data', Records.AddAuditDataRequest, null)
+
+export const accountSummaryMessage = (data: AccountSummary.IAccountSummaryRequest): RestMessage<AccountSummary.IAccountSummaryRequest, AccountSummary.IAccountSummaryElements> =>
+    createMessage(data, 'login/account_summary', AccountSummary.AccountSummaryRequest, AccountSummary.AccountSummaryElements)
+
+export const sendSessionMessage = (data: Authentication.ISendSessionMessageRequest): RestMessage<Authentication.ISendSessionMessageRequest, {}> =>
+    createMessage(data, 'pushserver/send_session_message', Authentication.SendSessionMessageRequest, null)
+
+export const setEncryptedTeamKeyMessage = (data: Enterprise.IEncryptedTeamKeyRequest): RestMessage<Enterprise.IEncryptedTeamKeyRequest, {}> =>
+    createMessage(data, 'enterprise/set_encrypted_team_key', Enterprise.EncryptedTeamKeyRequest, null)
+
+export const getBackupMessage = (data: Enterprise.IBackupRequest): RestMessage<Enterprise.IBackupRequest, Enterprise.IBackupResponse> =>
+    createMessage(data, 'enterprise/get_backup', Enterprise.BackupRequest, Enterprise.BackupResponse)
+
+export const getEnterprisePublicKeyMessage = (): RestMessage<{}, BreachWatch.IEnterprisePublicKeyResponse> =>
+    createMessage({}, 'enterprise/get_enterprise_public_key', null, BreachWatch.EnterprisePublicKeyResponse)
+
+export const getEnterpriseDataForUserMessage = (data: Enterprise.IEnterpriseDataRequest): RestMessage<Enterprise.IEnterpriseDataRequest, Enterprise.IEnterpriseDataResponse> =>
+    createMessage(data, 'enterprise/get_enterprise_data_for_user', Enterprise.EnterpriseDataRequest, Enterprise.EnterpriseDataResponse)
+
+export const setEnterpriseDataKeyMessage = (data: Enterprise.IEnterpriseUserDataKey): RestMessage<Enterprise.IEnterpriseUserDataKey, {}> =>
+    createMessage(data, 'enterprise/set_enterprise_user_data_key', Enterprise.EnterpriseUserDataKey, null)
+
+export const setV2AlternatePasswordMessage = (data: Authentication.IUserAuthRequest): RestMessage<Authentication.IUserAuthRequest, {}> =>
+    createMessage(data, 'authentication/set_v2_alternate_password', Authentication.UserAuthRequest, null)
+
+export const getMasterPasswordSaltMessage = (): RestMessage<{}, Authentication.ISalt> =>
+    createMessage({}, 'setting/get_master_password_salt', null, Authentication.Salt)
+
+export const getPublicKeysMessage = (data: Authentication.IGetPublicKeysRequest): RestMessage<Authentication.IGetPublicKeysRequest, Authentication.IGetPublicKeysResponse> =>
+    createMessage(data, 'vault/get_public_keys', Authentication.GetPublicKeysRequest, Authentication.GetPublicKeysResponse)
+
+export const setEccKeyPairMessage = (data: Authentication.ISetEccKeyPairRequest): RestMessage<Authentication.ISetEccKeyPairRequest, {}> =>
+    createMessage(data, 'vault/set_ecc_key_pair', Authentication.SetEccKeyPairRequest, null)
+
+export const applicationAddMessage = (data: Records.IApplicationAddRequest): RestMessage<Records.IApplicationAddRequest, {}> =>
+    createMessage(data, 'vault/application_add', Records.ApplicationAddRequest, null)
+
+export const addAppShareMessage = (data: Authentication.IAddAppSharesRequest): RestMessage<Authentication.IAddAppSharesRequest, {}> =>
+    createMessage(data, 'vault/app_share_add', Authentication.AddAppSharesRequest, null)
+
+export const removeAppShareMessage = (data: Authentication.IRemoveAppSharesRequest): RestMessage<Authentication.IRemoveAppSharesRequest, {}> =>
+    createMessage(data, 'vault/app_share_remove', Authentication.RemoveAppSharesRequest, null)
+
+export const addAppClientMessage = (data: Authentication.IAddAppClientRequest): RestMessage<Authentication.IAddAppClientRequest, Authentication.IDevice> =>
+    createMessage(data, 'vault/app_client_add', Authentication.AddAppClientRequest, Authentication.Device)
+
+export const addExternalShareMessage = (data: Authentication.IAddExternalShareRequest): RestMessage<Authentication.IAddExternalShareRequest, Authentication.IDevice> =>
+    createMessage(data, 'vault/external_share_add', Authentication.AddExternalShareRequest, Authentication.Device)
+
+export const removeExternalShareMessage = (data: Authentication.IRemoveAppClientsRequest): RestMessage<Authentication.IRemoveAppClientsRequest, {}> =>
+    createMessage(data, 'vault/external_share_remove', Authentication.RemoveAppClientsRequest, null)
+
+export const removeAppClientMessage = (data: Authentication.IRemoveAppClientsRequest): RestMessage<Authentication.IRemoveAppClientsRequest, {}> =>
+    createMessage(data, 'vault/app_client_remove', Authentication.RemoveAppClientsRequest, null)
+
+export const getAppInfoMessage = (data: Authentication.IGetAppInfoRequest): RestMessage<Authentication.IGetAppInfoRequest, Authentication.IGetAppInfoResponse> =>
+    createMessage(data, 'vault/get_app_info', Authentication.GetAppInfoRequest, Authentication.GetAppInfoResponse)
+
+export const getApplicationsSummaryMessage = (): RestMessage<{}, Authentication.IGetApplicationsSummaryResponse> =>
+    createMessage({}, 'vault/get_applications_summary', null, Authentication.GetApplicationsSummaryResponse)
+
+export const sendShareInviteMessage = (data: Authentication.ISendShareInviteRequest): RestMessage<Authentication.ISendShareInviteRequest, {}> =>
+    createMessage(data, 'vault/send_share_invite', Authentication.SendShareInviteRequest, null)
+
+export const updateSecurityData = (data: Authentication.ISecurityDataRequest): RestMessage<Authentication.ISecurityDataRequest, Authentication.RevisionResponse> =>
+    createMessage(data, 'enterprise/update_security_data', Authentication.SecurityDataRequest, Authentication.RevisionResponse)
+
+export const setReusedPasswords = (data: Authentication.IReusedPasswordsRequest): RestMessage<Authentication.IReusedPasswordsRequest, {}> =>
+    createMessage(data, 'enterprise/set_reused_passwords', Authentication.ReusedPasswordsRequest, null)
+
+/* -- SERVICE LOGGER -- */
+
+export const serviceLoggerGetMessage = (data: ServiceLogger.IServiceLogGetRequest): RestMessage<ServiceLogger.IServiceLogGetRequest, ServiceLogger.IServiceLogResponse> =>
+    createMessage(data, 'logger/get', ServiceLogger.ServiceLogGetRequest, ServiceLogger.ServiceLogResponse);
+
+
+/* -- Cloud SSO Connect -- */
+
+export const ssoSamlMessage = (endpoint: string): RestMessage<null, null> =>
+    createMessage(null, 'sso/saml/' + endpoint, null, null);
+
+export const ssoConfigMessage = (endpoint: string): RestMessage<null, null> =>
+    createMessage(null, 'sso/config/' + endpoint, null, null);
+
+export const ssoLoginMessageWithUrl = (url): RestMessage<null, null> =>
+    createMessage(null, url, null, null);
+
+export const ssoLogoutMessage = (serviceProviderId, data): RestMessage<null, null> =>
+    createMessage(null, 'sso/saml/logout/' + serviceProviderId, null, null);
+
+export const ssoGetMetadataMessage = (serviceProviderId): RestMessage<null, null> =>
+    createMessage(null, 'sso/saml/metadata/' + serviceProviderId, null, null);
+
+export const ssoUploadIdpMetadataMessage = (data: SsoCloud.ISsoCloudIdpMetadataRequest): RestMessage<SsoCloud.ISsoCloudIdpMetadataRequest, SsoCloud.ISsoCloudConfigurationValidationResponse> =>
+    createMessage(data, 'sso/config/sso_cloud_upload_idp_metadata', SsoCloud.SsoCloudIdpMetadataRequest, SsoCloud.SsoCloudConfigurationValidationResponse);
+
+export const ssoCloudServiceProviderUpdateRequestMessage = (data: SsoCloud.ISsoCloudServiceProviderUpdateRequest): RestMessage<SsoCloud.ISsoCloudServiceProviderUpdateRequest, SsoCloud.ISsoCloudConfigurationResponse> =>
+    createMessage(data, 'sso/config/sso_cloud_sp_configuration_set', SsoCloud.SsoCloudServiceProviderUpdateRequest, SsoCloud.SsoCloudConfigurationResponse);
+
+export const ssoCloudConfigurationRequestMessage = (data: SsoCloud.ISsoCloudConfigurationRequest, url: string): RestMessage<SsoCloud.ISsoCloudConfigurationRequest, SsoCloud.ISsoCloudConfigurationResponse> =>
+    createMessage(data, url, SsoCloud.SsoCloudConfigurationRequest, SsoCloud.SsoCloudConfigurationResponse);
+
+export const ssoCloudLogRequestMessage = (data: SsoCloud.ISsoCloudLogRequest, url: string): RestMessage<SsoCloud.ISsoCloudLogRequest, ServiceLogger.IServiceLogResponse> =>
+    createMessage(data, url, SsoCloud.SsoCloudLogRequest, ServiceLogger.ServiceLogResponse);
+
+export const ssoCloudSAMLLogRequestMessage = (data: SsoCloud.ISsoCloudSAMLLogRequest, url: string): RestMessage<SsoCloud.ISsoCloudSAMLLogRequest, SsoCloud.ISsoCloudSAMLLogResponse> =>
+    createMessage(data, url, SsoCloud.SsoCloudSAMLLogRequest, SsoCloud.SsoCloudSAMLLogResponse);
+
+export const ssoCloudServiceProviderConfigurationListRequestMessage = (data: SsoCloud.ISsoCloudServiceProviderConfigurationListRequest): RestMessage<SsoCloud.ISsoCloudServiceProviderConfigurationListRequest, SsoCloud.ISsoCloudServiceProviderConfigurationListResponse> =>
+    createMessage(data, 'sso/config/sso_cloud_sp_configuration_get', SsoCloud.SsoCloudServiceProviderConfigurationListRequest, SsoCloud.SsoCloudServiceProviderConfigurationListResponse);
+
+export const ssoServiceProviderRequestMessage = (data: Authentication.ISsoServiceProviderRequest): RestMessage<Authentication.ISsoServiceProviderRequest, Authentication.ISsoServiceProviderResponse> =>
+    createMessage(data, 'enterprise/get_sso_service_provider', Authentication.SsoServiceProviderRequest, Authentication.SsoServiceProviderResponse);
+
+export const ssoCloudRequestMessage = (data: SsoCloud.ISsoCloudRequest): RestMessage<SsoCloud.ISsoCloudRequest, null> =>
+    createMessage(data, null, SsoCloud.SsoCloudRequest, null);
+
+export const ssoCloudValidationRequestMessage = (data: SsoCloud.ISsoCloudConfigurationValidationRequest, url:string): RestMessage<SsoCloud.ISsoCloudConfigurationValidationRequest, SsoCloud.ISsoCloudConfigurationValidationResponse> =>
+    createMessage(data, url, SsoCloud.SsoCloudConfigurationValidationRequest, SsoCloud.SsoCloudConfigurationValidationResponse);
+
+
+/* -- Keeper Automator -- */
+
+
+export const automatorApproveDeviceMessage = (data: Automator.ApproveDeviceRequest, url:string): RestMessage<Automator.IApproveDeviceRequest, Automator.IAutomatorResponse> =>
+    createMessage(data, url, Automator.ApproveDeviceRequest, Automator.AutomatorResponse);
+
+export const automatorAdminCreateMessage = (data: Automator.AdminCreateAutomatorRequest, url:string): RestMessage<Automator.IAdminCreateAutomatorRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminCreateAutomatorRequest, Automator.AdminResponse);
+
+export const automatorAdminDeleteMessage = (data: Automator.AdminDeleteAutomatorRequest, url:string): RestMessage<Automator.IAdminDeleteAutomatorRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminDeleteAutomatorRequest, Automator.AdminResponse);
+
+export const automatorAdminEditMessage = (data: Automator.AdminEditAutomatorRequest, url:string): RestMessage<Automator.IAdminEditAutomatorRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminEditAutomatorRequest, Automator.AdminResponse);
+
+export const automatorAdminEnableMessage = (data: Automator.AdminEnableAutomatorRequest, url:string): RestMessage<Automator.IAdminEnableAutomatorRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminEnableAutomatorRequest, Automator.AdminResponse);
+
+export const automatorAdminGetMessage = (data: Automator.AdminGetAutomatorRequest, url:string): RestMessage<Automator.IAdminGetAutomatorRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminGetAutomatorRequest, Automator.AdminResponse);
+
+export const automatorAdminGetAllOnNodeMessage = (data: Automator.AdminGetAutomatorsOnNodeRequest, url:string): RestMessage<Automator.IAdminGetAutomatorsOnNodeRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminGetAutomatorsOnNodeRequest, Automator.AdminResponse);
+
+export const automatorAdminGetAllForEnterpriseMessage = (data: Automator.AdminGetAutomatorsForEnterpriseRequest, url:string): RestMessage<Automator.IAdminGetAutomatorsForEnterpriseRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminGetAutomatorsForEnterpriseRequest, Automator.AdminResponse);
+
+export const automatorAdminInitializeMessage = (data: Automator.AdminInitializeAutomatorRequest, url:string): RestMessage<Automator.IAdminInitializeAutomatorRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminInitializeAutomatorRequest, Automator.AdminResponse);
+
+export const automatorAdminResetMessage = (data: Automator.AdminResetAutomatorRequest, url:string): RestMessage<Automator.IAdminResetAutomatorRequest, Automator.IAdminResponse> =>
+    createMessage(data, url, Automator.AdminResetAutomatorRequest, Automator.AdminResponse);

package/src/utils.ts

@@ -0,0 +1,169 @@
+import {KeyWrapper, platform} from "./platform";
+import {KeeperHost, TransmissionKey} from './configuration';
+import { Authentication } from "./proto";
+
+export function getKeeperUrl(host: KeeperHost, forPath: string) {
+    return `https://${host}/api/rest/${forPath}`;
+}
+
+export function getKeeperSAMLUrl(host: KeeperHost, forPath: string, serviceProviderId: number = null) {
+    if (serviceProviderId) {
+        return getKeeperUrl(host, `sso/saml/${forPath}/${serviceProviderId}`);
+    } else {
+        return getKeeperUrl(host, `sso/saml/${forPath}`);
+    }
+}
+
+export function getKeeperSsoConfigUrl(host: KeeperHost, forPath: string, serviceProviderId: number = null) {
+    if (serviceProviderId) {
+        return getKeeperUrl(host, `sso/config/${forPath}/${serviceProviderId}`);
+    } else {
+        return getKeeperUrl(host, `sso/config/${forPath}`);
+    }
+}
+
+export function getKeeperAutomatorAdminUrl(host: KeeperHost, forPath: string, automatorId: number = null) {
+    if (automatorId) {
+        return getKeeperUrl(host, `automator/${forPath}/${automatorId}`);
+    } else {
+        return getKeeperUrl(host, `automator/${forPath}`);
+    }
+}
+
+export function generateTransmissionKey(keyNumber: number): TransmissionKey {
+    const transmissionKey = platform.getRandomBytes(32)
+    return {
+        publicKeyId: keyNumber,
+        key: transmissionKey,
+        encryptedKey: platform.publicEncrypt(transmissionKey, platform.keys[keyNumber - 1])
+    }
+}
+
+export function webSafe64(source: string): string {
+    return source.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+export function webSafe64FromBytes(source: Uint8Array): string {
+    return webSafe64(platform.bytesToBase64(source));
+}
+
+export function normal64(source: string): string {
+    return source.replace(/-/g, '+').replace(/_/g, '/') + '=='.substring(0, (3 * source.length) % 4);
+}
+
+export function normal64Bytes(source: string): Uint8Array {
+    return platform.base64ToBytes(normal64(source));
+}
+
+export function isTwoFactorResultCode(resultCode: string): boolean {
+    return ["need_totp", "invalid_device_token", "invalid_totp"].includes(resultCode);
+}
+
+export function generateEncryptionKey(): Uint8Array {
+    return platform.getRandomBytes(32);
+}
+
+export function generateUidBytes(): Uint8Array {
+    return platform.getRandomBytes(16);
+}
+
+export function generateUid(): string {
+    return webSafe64FromBytes(generateUidBytes());
+}
+
+export function wrapPassword(key: string | Uint8Array): KeyWrapper {
+    if (typeof key === 'string') {
+        return platform.wrapPassword(platform.stringToBytes(key))
+    }
+    if (key instanceof Uint8Array) {
+        return platform.wrapPassword(key)
+    }
+    throw new Error('Error wrapping the password')
+}
+
+export async function encryptKey(key: Uint8Array, withKey: Uint8Array): Promise<string> {
+    let encryptedKey = await platform.aesGcmEncrypt(key, withKey);
+    return webSafe64FromBytes(encryptedKey);
+}
+
+export function shareKey(key: Uint8Array, publicKey: string): string {
+    let encryptedKey = platform.publicEncrypt(key, publicKey);
+    return webSafe64FromBytes(encryptedKey);
+}
+
+export async function shareKeyEC(key: Uint8Array, publicKey: Uint8Array): Promise<string> {
+    let encryptedKey = await platform.publicEncryptEC(key, publicKey);
+    return webSafe64FromBytes(encryptedKey);
+}
+
+export async function decryptKey(encryptedKey: string, withKey: Uint8Array): Promise<Uint8Array> {
+    return platform.aesGcmDecrypt(normal64Bytes(encryptedKey), withKey);
+}
+
+export async function encryptForStorage(data: Uint8Array, key: Uint8Array): Promise<string> {
+    return webSafe64FromBytes(await platform.aesCbcEncrypt(data, key, true));
+}
+
+export async function decryptFromStorage(data: string, key: Uint8Array): Promise<Uint8Array> {
+    return await platform.aesCbcDecrypt(normal64Bytes(data), key, true);
+}
+
+export async function decryptFromStorageGcm(data: string, key: Uint8Array): Promise<Uint8Array> {
+    return platform.aesGcmDecrypt(normal64Bytes(data), key);
+}
+
+export async function encryptObjectForStorage<T>(obj: T, key: Uint8Array): Promise<string> {
+    let s = JSON.stringify(obj);
+    let bytes = platform.stringToBytes(s);
+    return encryptForStorage(bytes, key);
+}
+
+export async function encryptObjectForStorageAsBytes<T>(obj: T, key: Uint8Array): Promise<Uint8Array> {
+    let s = JSON.stringify(obj);
+    let bytes = platform.stringToBytes(s);
+    return platform.aesCbcEncrypt(bytes, key, true)
+}
+
+export async function decryptObjectFromStorage<T>(data: string, key: Uint8Array): Promise<T> {
+    try {
+        let decrypted = await decryptFromStorage(data, key);
+        return JSON.parse(platform.bytesToString(decrypted));
+    }
+    catch (e) {
+        console.log(`Unable to decrypt ${data}`);
+        return {} as T
+    }
+}
+
+export async function encryptObjectForStorageGCM<T>(obj: T, key: Uint8Array, usePadding: boolean = true): Promise<Uint8Array> {
+    let bytes = platform.stringToBytes(JSON.stringify(obj));
+    if (usePadding) {
+        const paddedSize = Math.ceil(Math.max(384, bytes.length) / 16) * 16
+        bytes = Uint8Array.of(...bytes, ...Array(paddedSize - bytes.length).fill(0x20))
+    }
+    return platform.aesGcmEncrypt(bytes, key)
+}
+
+export function chooseErrorMessage(errorNumber:number){
+    switch (errorNumber){
+        case Authentication.LoginState.ACCOUNT_LOCKED:
+            return 'account_locked'
+        case Authentication.LoginState.DEVICE_ACCOUNT_LOCKED:
+            return 'device_account_locked'
+        case Authentication.LoginState.DEVICE_LOCKED:
+            return 'device_locked'
+        case Authentication.LoginState.INVALID_LOGINSTATE:
+            return 'invalid_loginstate'
+    }
+}
+
+export function resolvablePromise(): { promise: Promise<void>, resolve: () => void } {
+    let resolver
+    const promise = new Promise<void>((resolve) => {
+        resolver = resolve
+    })
+    return {
+        promise: promise,
+        resolve: resolver
+    }
+}