@lifeready/core 0.6.0-beta.1

package/lib/trusted-parties/trusted-party.service.d.ts

@@ -0,0 +1,44 @@
+import { HttpClient } from '@angular/common/http';
+import { KeyExchangeService } from '../api/key-exchange.service';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { SharedContactCardService } from '../api/shared-contact-card.service';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { AccessLevel } from '../category/category.types';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { UserService } from '../users/user.service';
+import { AcceptTrustedPartyInvite, ConfirmTrustedPartyInvite, FoundTrustedParty, InviteTrustedParty, TrustedParties, TrustedParty, TrustedPartyInvite, TrustedPartyRole, TrustedPartyRoleType } from './trusted-party.types';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+export declare class TrustedPartyService {
+    private http;
+    private lrApollo;
+    private sharedContactCardService;
+    private userService;
+    private authService;
+    private keyExchangeService;
+    private keyGraphService;
+    private keyService;
+    private keyFactory;
+    private encryptionService;
+    private trustedPartyRoles;
+    constructor(http: HttpClient, lrApollo: LrApolloService, sharedContactCardService: SharedContactCardService, userService: UserService, authService: LifeReadyAuthService, keyExchangeService: KeyExchangeService, keyGraphService: KeyGraphService, keyService: KeyService, keyFactory: KeyFactoryService, encryptionService: EncryptionService);
+    getTrustedParties(): Promise<TrustedParty[]>;
+    getAllTrustedParties(): Promise<TrustedParties>;
+    getTrustedParty(partyId: string): Promise<TrustedParty>;
+    getTrustedPartyRoles(roleType?: TrustedPartyRoleType): Promise<TrustedPartyRole[]>;
+    findByEmail(email: string): Promise<FoundTrustedParty>;
+    inviteTrustedParty(invite: InviteTrustedParty): Promise<void>;
+    cancelInvitation(inviteId: string): Promise<void>;
+    getInvitation(inviteId: string, inviteToken: string, key: string): Promise<TrustedPartyInvite>;
+    acceptInvitation(invite: AcceptTrustedPartyInvite): Promise<string>;
+    declineInvitation(inviteId: string, inviteToken: string): Promise<void>;
+    confirmInvitation(confirm: ConfirmTrustedPartyInvite): Promise<string>;
+    removeTrustedParty(partyId: string): Promise<void>;
+    setCategoryAccessLevel(categoryId: string, keyId: string, trustedParty: TrustedParty, accessLevel?: AccessLevel): Promise<void>;
+    setRecordAccessLevel(recordId: string, keyId: string, trustedParty: TrustedParty, accessLevel: AccessLevel): Promise<void>;
+    private shareDirectory;
+    private unshareDirectory;
+    mapTrustedParty(tp: any): Promise<TrustedParty>;
+    private mapInvite;
+}

package/lib/trusted-parties/trusted-party.types.d.ts

@@ -0,0 +1,102 @@
+import { DecryptedOtk, PreparedPermissions, UserSharedKey } from '../api/key-exchange.types';
+import { KeyExchangeMessage } from './../api/key-exchange.types';
+import { AccessLevel } from './../category/category.types';
+import { TrustedPartyDetails } from './../users/profile.types';
+export declare class TrustedPartyRole {
+    id: string;
+    name: string;
+    roleType: TrustedPartyRoleType;
+    categories: {
+        category: string[];
+        accessLevel: AccessLevel;
+    }[];
+}
+export declare enum TrustedPartyRoleType {
+    General = "general",
+    Scenario = "scenario"
+}
+export declare enum TrustedPartyType {
+    User = "user",
+    Organisation = "organisation"
+}
+export declare enum TrustedPartyInviteStatus {
+    Invited = "IN_PROGRESS",
+    Cancelled = "CANCELLED",
+    Declined = "DECLINED",
+    Completed = "COMPLETED"
+}
+export declare class TrustedParties {
+    parties: TrustedParty[];
+    invites: TrustedPartyInvite[];
+    sentInvites: TrustedPartyInvite[];
+}
+export declare class SharedTrustedPartyDetails extends TrustedPartyDetails {
+    id: string;
+    ownedKeyId: string;
+    sharedKeyId: string;
+}
+export declare class TrustedPartyInvite {
+    id: string;
+    type: TrustedPartyType;
+    status: TrustedPartyInviteStatus;
+    token: string;
+    tokenExpiry: string | Date;
+    isExpired: boolean;
+    isSender: boolean;
+    actionRequired: boolean;
+    name: string;
+    email: string;
+    details?: TrustedPartyDetails;
+    message?: KeyExchangeMessage;
+    mySharedDetails?: TrustedPartyDetails;
+    mySharedMessage?: KeyExchangeMessage;
+    rootKeyCipher: string;
+    pbkCipher: string;
+    decryptedOtk: DecryptedOtk;
+}
+export declare class TPFeatures {
+    sharedVault: SharedVaultFeature;
+}
+export declare class SharedVaultFeature {
+    hasAccess: boolean;
+}
+export declare class TrustedParty {
+    id: string;
+    type: TrustedPartyType;
+    name: string;
+    hasScenarios: boolean;
+    hasSharedVault: boolean;
+    details: TrustedPartyDetails;
+    mySharedDetails: SharedTrustedPartyDetails;
+    userSharedKey: UserSharedKey;
+    username: string;
+    features: TPFeatures;
+}
+export declare class FoundTrustedParty {
+    id: string;
+    email: string;
+    username: string;
+    isTrustedParty: boolean;
+    isMe: boolean;
+}
+export declare class InviteTrustedParty {
+    party: {
+        username?: string;
+        email?: string;
+        name?: string;
+        message?: string;
+    };
+    permissions?: PreparedPermissions;
+    mySharedDetails: TrustedPartyDetails;
+}
+export declare class AcceptTrustedPartyInvite {
+    inviteId: string;
+    inviteToken: string;
+    decryptedOtk: DecryptedOtk;
+    mySharedDetails: TrustedPartyDetails;
+}
+export declare class ConfirmTrustedPartyInvite {
+    inviteId: string;
+    initiatorRootKeyCipher: string;
+    initiatorOneTimePbkCipher: string;
+}

package/lib/trusted-parties/trusted-party2.gql.d.ts

@@ -0,0 +1,79 @@
+import { ID } from '../api/types';
+export interface DeleteTpMutation {
+    deleteTp: {
+        id: ID;
+    };
+}
+export declare const DeleteTpMutation: import("../_common/ast").TypedDocumentNode<DeleteTpMutation>;
+export interface ShareDirectoryMutation {
+    shareDirectory: {
+        tpDirectory: {
+            id: ID;
+        };
+    };
+}
+export declare const ShareDirectoryMutation: import("../_common/ast").TypedDocumentNode<ShareDirectoryMutation>;
+export interface UnshareDirectoryMutation {
+    unshareDirectory: {
+        tpDirectory: {
+            id: ID;
+        };
+    };
+}
+export declare const UnshareDirectoryMutation: import("../_common/ast").TypedDocumentNode<UnshareDirectoryMutation>;
+export interface ShareFileMutation {
+    shareFile: {
+        tpFile: {
+            id: ID;
+        };
+    };
+}
+export declare const ShareFileMutation: import("../_common/ast").TypedDocumentNode<ShareFileMutation>;
+export interface UnshareFileMutation {
+    unshareFile: {
+        tpFile: {
+            id: ID;
+        };
+    };
+}
+export declare const UnshareFileMutation: import("../_common/ast").TypedDocumentNode<UnshareFileMutation>;
+export interface TpCurrentUserSharedKeyQuery {
+    tp: {
+        currentUserSharedKey: {
+            userSharedKey: {
+                sharedKey: {
+                    id: ID;
+                };
+                mkSharedKey: {
+                    id: ID;
+                };
+                mkPxk: {
+                    id: ID;
+                };
+                mkReshareRequestCipher: string;
+                mkReshareRequestSent: boolean;
+                mkReshareResponseCipher: string;
+                mkReshareResponseSent: boolean;
+            };
+        };
+    };
+}
+export declare const TpCurrentUserSharedKeyQuery: import("../_common/ast").TypedDocumentNode<TpCurrentUserSharedKeyQuery>;
+export interface RequestTpMkReshareMutation {
+    requestTpMkReshare: {
+        id: ID;
+    };
+}
+export declare const RequestTpMkReshareMutation: import("../_common/ast").TypedDocumentNode<RequestTpMkReshareMutation>;
+export interface RespondTpMkReshareMutation {
+    respondTpMkReshare: {
+        id: ID;
+    };
+}
+export declare const RespondTpMkReshareMutation: import("../_common/ast").TypedDocumentNode<RespondTpMkReshareMutation>;
+export interface CompleteTpMkReshareMutation {
+    completeTpMkReshare: {
+        id: ID;
+    };
+}
+export declare const CompleteTpMkReshareMutation: import("../_common/ast").TypedDocumentNode<CompleteTpMkReshareMutation>;

package/lib/trusted-parties/trusted-party2.service.d.ts

@@ -0,0 +1,114 @@
+import { NgZone } from '@angular/core';
+import { Item2Service } from '../api/item2.service';
+import { LrGraphQLService, LrMutation } from '../api/lr-graphql';
+import { AccessRoleChoice, LrRelayIdInput } from '../api/types';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { CompleteTpMkReshareMutation, DeleteTpMutation, RequestTpMkReshareMutation, RespondTpMkReshareMutation, ShareDirectoryMutation, UnshareDirectoryMutation } from './trusted-party2.gql';
+export interface ShareItemOptions {
+    itemId: LrRelayIdInput;
+    itemKeyId?: LrRelayIdInput;
+    tpId: LrRelayIdInput;
+    tpSharedKeyId?: LrRelayIdInput;
+    accessRole: AccessRoleChoice;
+}
+export interface UnshareItemOptions {
+    itemId: string;
+    tpId: string;
+}
+export declare class TrustedParty2Service {
+    private ngZone;
+    private keyGraph;
+    private lrGraphQL;
+    private item2Service;
+    private keyService;
+    private keyFactory;
+    private encryptionService;
+    constructor(ngZone: NgZone, keyGraph: KeyGraphService, lrGraphQL: LrGraphQLService, item2Service: Item2Service, keyService: KeyService, keyFactory: KeyFactoryService, encryptionService: EncryptionService);
+    deleteTp(tpId: LrRelayIdInput): LrMutation<DeleteTpMutation, {
+        input: {
+            id: string;
+        };
+    }>;
+    deleteTpMutation(tpId: LrRelayIdInput): LrMutation<DeleteTpMutation, {
+        input: {
+            id: string;
+        };
+    }>;
+    getTpCurrentUserSharedKey(tpId: LrRelayIdInput): Promise<{
+        sharedKey: {
+            id: string;
+        };
+        mkSharedKey: {
+            id: string;
+        };
+        mkPxk: {
+            id: string;
+        };
+        mkReshareRequestCipher: string;
+        mkReshareRequestSent: boolean;
+        mkReshareResponseCipher: string;
+        mkReshareResponseSent: boolean;
+    }>;
+    shareDirectory(options: ShareItemOptions): Promise<LrMutation<ShareDirectoryMutation, {
+        input: {
+            id: string;
+            tpId: string;
+            accessRole: AccessRoleChoice;
+            keyId: string;
+            wrappingKeyId: string;
+            wrappedKey: string;
+        };
+    }>>;
+    shareFile(options: ShareItemOptions): Promise<LrMutation<ShareDirectoryMutation, {
+        input: {
+            id: string;
+            tpId: string;
+            accessRole: AccessRoleChoice;
+            keyId: string;
+            wrappingKeyId: string;
+            wrappedKey: string;
+        };
+    }>>;
+    private shareItem;
+    unshareDirectory(options: UnshareItemOptions): Promise<LrMutation<UnshareDirectoryMutation, {
+        input: {
+            id: string;
+            tpId: string;
+        };
+    }>>;
+    unshareFile(options: UnshareItemOptions): Promise<LrMutation<UnshareDirectoryMutation, {
+        input: {
+            id: string;
+            tpId: string;
+        };
+    }>>;
+    private unshareItem;
+    requestMkReshare(tpId: LrRelayIdInput): Promise<LrMutation<RequestTpMkReshareMutation, {
+        input: {
+            tpId: string;
+            masterKeyId: string;
+            mkPbk: string;
+            mkWrappedMkPrk: string;
+            sharedKeyId: string;
+            mkReshareRequestCipher: string;
+        };
+    }>>;
+    respondMkReshare(tpId: LrRelayIdInput): Promise<LrMutation<RespondTpMkReshareMutation, {
+        input: {
+            tpId: string;
+            mkSharedKeyId: string;
+            mkReshareResponseCipher: string;
+        };
+    }>>;
+    completeMkReshare(tpId: LrRelayIdInput): Promise<LrMutation<CompleteTpMkReshareMutation, {
+        input: {
+            tpId: string;
+            masterKeyId: string;
+            mkSharedKeyId: string;
+            mkWrappedMkSharedKey: string;
+        };
+    }>>;
+}

package/lib/users/profile-details.service.d.ts

@@ -0,0 +1,21 @@
+import { SharedContactCardService } from '../api/shared-contact-card.service';
+import { CurrentUser } from '../auth/auth.types';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { TrustedPartyService } from '../trusted-parties/trusted-party.service';
+import { SharedTrustedPartyDetails } from '../trusted-parties/trusted-party.types';
+import { ProfileService } from './profile.service';
+import { MainContactCardFields, TrustedPartyDetails } from './profile.types';
+export declare class ProfileDetailsService {
+    private sharedContactCardService;
+    private trustedPartyService;
+    private profileService;
+    private authService;
+    constructor(sharedContactCardService: SharedContactCardService, trustedPartyService: TrustedPartyService, profileService: ProfileService, authService: LifeReadyAuthService);
+    updateDetails(fields: MainContactCardFields): Promise<CurrentUser>;
+    private synchronizeContactCards;
+    private getChanges;
+    private synchronizeSharedContactCard;
+    updateTrustedPartyDetails(details: SharedTrustedPartyDetails): Promise<void>;
+    synchronizeSharedDetails(details: TrustedPartyDetails): Promise<void>;
+    private checkField;
+}

package/lib/users/profile.gql.d.ts

@@ -0,0 +1,11 @@
+import { HasEdges } from './../_common/types';
+import { HasKeyGraph } from './../cryptography/cryptography.types';
+import { ApiCurrentUser, ApiContactCard } from './profile.types';
+export interface CurrentUserQueryType extends HasKeyGraph {
+    currentUser: ApiCurrentUser;
+    contactCards: HasEdges<ApiContactCard>;
+    userPlans: any[];
+}
+export declare const CurrentUserQuery: import("graphql").DocumentNode;
+export declare const CreateContactCardMutation: import("graphql").DocumentNode;
+export declare const UpdateContactCardMutation: import("graphql").DocumentNode;

package/lib/users/profile.service.d.ts

@@ -0,0 +1,35 @@
+import { HttpClient } from '@angular/common/http';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { LifeReadyConfig } from '../life-ready.config';
+import { ApiCurrentUser, PassIdpApiResult, MainContactCard, ApiContactCard, MainContactCardFields } from './profile.types';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { KeyService } from '../cryptography/key.service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { ContactCard } from '../api/contact-card.service';
+import { UserPlan } from '../plan/plan.types';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+export declare class ProfileService {
+    private config;
+    private http;
+    private lrApollo;
+    private keyService;
+    private keyMetaService;
+    private keyGraph;
+    private encryptionService;
+    constructor(config: LifeReadyConfig, http: HttpClient, lrApollo: LrApolloService, keyService: KeyService, keyMetaService: KeyMetaService, keyGraph: KeyGraphService, encryptionService: EncryptionService);
+    getPassIdpParams(emailOrPhone: string): Promise<PassIdpApiResult>;
+    getCurrentUser(): Promise<{
+        currentUser: ApiCurrentUser;
+        contactCard: ApiContactCard;
+        userPlans: UserPlan[];
+    }>;
+    decryptContactCard(contactCard: ApiContactCard): Promise<MainContactCard>;
+    updateDetails(id: string, keyId: string, fields: MainContactCardFields): Promise<void>;
+    private prepareContactCardInput;
+    private createContactCard;
+    private updateContactCard;
+    decryptContactCardEdges(edges: any): Promise<ContactCard[]>;
+    getContactCards(): Promise<ContactCard[]>;
+    deleteContactCard(id: string): Promise<string>;
+    signOut(): Promise<void>;
+}

package/lib/users/profile.types.d.ts

@@ -0,0 +1,96 @@
+import { PassIdpParams, PassKey } from '../cryptography/cryptography.types';
+import { UserDelete } from './user.types';
+export declare class CurrentUserKey {
+    passKey?: PassKey;
+    masterKey?: {
+        id: string;
+    };
+    rootKey?: {
+        id: string;
+    };
+    pxk?: {
+        id: string;
+    };
+    sigPxk?: {
+        id: string;
+    };
+}
+export declare class ApiCurrentUser {
+    id: string;
+    username: string;
+    currentUserKey: CurrentUserKey;
+    userDelete: UserDelete;
+    features: any;
+    sessionEncryptionKey: string;
+}
+export declare class ApiContactCard {
+    id: string;
+    cipherData: string;
+    key: {
+        id: string;
+    };
+}
+export declare class ContactCardName {
+    name: string;
+    title?: string;
+    firstName?: string;
+    lastName?: string;
+    constructor(input: any);
+}
+export declare class ContactCardAddress {
+    fullAddress: string;
+    streetAddress: string;
+    suburb: string;
+    state: string;
+    postcode: string;
+    country: string;
+}
+export declare class MainContactCardProperty<T> {
+    value: T;
+    hasMultiple: boolean;
+    values?: {
+        id: string;
+        label: string;
+        value: T;
+    }[];
+}
+export declare class MainContactCardFields {
+    name: MainContactCardProperty<ContactCardName>;
+    email: MainContactCardProperty<string>;
+    image: MainContactCardProperty<string>;
+    phone: MainContactCardProperty<string>;
+    address: MainContactCardProperty<ContactCardAddress>;
+}
+export declare class MainContactCard extends MainContactCardFields {
+    id: string;
+    keyId: string;
+}
+export declare class MainContactCardPlainFields {
+    name: ContactCardName;
+}
+export declare enum PasswordChangeStatus {
+    InProgress = "IN_PROGRESS",
+    Recovery = "RECOVERY"
+}
+export declare class PassIdpApiResult {
+    passwordChangeStatus?: PasswordChangeStatus;
+    currentPassIdpParams: PassIdpParams;
+    newPassIdpParams: PassIdpParams;
+    tpPasswordReset: {
+        passIdpParams: PassIdpParams;
+        resetUsername: string;
+    };
+}
+export declare class TrustedPartyDetails {
+    name: ContactCardName;
+    email?: string;
+    image?: string;
+    phones?: {
+        label: string;
+        value: string;
+    }[];
+    addresses?: {
+        label: string;
+        value: ContactCardAddress;
+    }[];
+}

package/lib/users/user.gql.d.ts

@@ -0,0 +1,9 @@
+import { User } from './user.types';
+import { HasKeyGraph } from '../cryptography/cryptography.types';
+export interface UserQueryType extends HasKeyGraph {
+    user: User;
+}
+export declare const UserQuery: import("graphql").DocumentNode;
+export declare const RequestUserDeleteMutation: import("graphql").DocumentNode;
+export declare const CancelUserDeleteMutation: import("graphql").DocumentNode;
+export declare const LoginHistoryQuery: import("graphql").DocumentNode;

package/lib/users/user.service.d.ts

@@ -0,0 +1,12 @@
+import { User, GetUserInput, UserDelete } from './user.types';
+import { LrApolloService } from '../api/lr-apollo.service';
+export declare class UserService {
+    private lrApollo;
+    constructor(lrApollo: LrApolloService);
+    getUserByEmail(email: string): Promise<User>;
+    getUserByUsername(username: string): Promise<User>;
+    getUser({ email, username }: GetUserInput): Promise<User>;
+    requestUserDelete(): Promise<UserDelete>;
+    cancelUserDelete(): Promise<string>;
+    loginHistory(first?: number, after?: string): Promise<any>;
+}

package/lib/users/user.types.d.ts

@@ -0,0 +1,23 @@
+import { Key } from '../cryptography/cryptography.types';
+export interface GetUserInput {
+    email?: string;
+    username?: string;
+}
+export interface User {
+    id?: string;
+    username?: string;
+    haveTp: boolean;
+    isCurrentUser: boolean;
+    contactCards?: any;
+    currentUserKey: {
+        sigPxk?: Key;
+        pxk?: Key;
+    };
+}
+export declare enum UserDeleteState {
+    REQUESTED = "REQUESTED"
+}
+export interface UserDelete {
+    created?: string;
+    state: UserDeleteState;
+}

package/lifeready-core.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+export { RunOutsideAngular as ɵd } from './lib/_common/run-outside-angular';
+export { LrGraphQLService as ɵb, LrService as ɵg } from './lib/api/lr-graphql';
+export { TpPasswordResetProcessorService as ɵc } from './lib/api/query-processor/tp-password-reset-processor.service';
+export { SharedContactCardFields as ɵe, SharedContactCardService as ɵf } from './lib/api/shared-contact-card.service';
+export { TimeService as ɵa } from './lib/api/time.service';