@lifeready/core 1.0.1 → 1.0.2

package/lib/api/key-exchange.service.d.ts

@@ -0,0 +1,39 @@
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyService } from '../cryptography/key.service';
+import { UserService } from './../users/user.service';
+import { CompleteOtk, DecryptedKeyExchange, GetKeyExchangeListOptions, GetKeyExchangeOptions, InitiateOtkInput, KeyExchange, RespondOtk, RespondOtkInput, UserSharedKey } from './key-exchange.types';
+import { LrApolloService } from './lr-apollo.service';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+export declare class KeyExchangeService {
+    private keyFactory;
+    private keyService;
+    private lrApollo;
+    private encryptionService;
+    private authService;
+    private userService;
+    private readonly CLIENT_NONCE_LENGTH;
+    constructor(keyFactory: KFS, keyService: KeyService, lrApollo: LrApolloService, encryptionService: EncryptionService, authService: LifeReadyAuthService, userService: UserService);
+    getKeyExchangeList(input?: GetKeyExchangeListOptions): Promise<any>;
+    /**
+     * @param id If the current user can responder the key exchange if they are either the initiator or the receiver.
+     * @param token If not signed in, or not the initiator or responder, 'token' must be given.
+     * @param otKeyK Is the raw one-time key (string). If the responder is explicitly specified at time of initiation, then
+     *   it's possible to have the otKey wrapped by the public key of the responder. In which case, the otKeyK is not needed.
+     */
+    getKeyExchange(id: string, { otKeyK, token }?: GetKeyExchangeOptions): Promise<DecryptedKeyExchange>;
+    private decryptResponseCipher;
+    decryptKeyExchange(keyExchange: KeyExchange, otKeyK?: string): Promise<DecryptedKeyExchange>;
+    private decryptOtk;
+    private getOtKey;
+    initiateOtk({ message, email, contactCard, upgrade, }: InitiateOtkInput): Promise<{
+        keyExchange: KeyExchange;
+        otKeyK: string;
+    }>;
+    respondOtk({ id, token, decryptedOtk, message, initiatorContactCard, responderContactCard: sentContactCard, }: RespondOtkInput): Promise<RespondOtk>;
+    completeOtk(keyExchangeId: string, initiatorRootKeyCipher: string, initiatorOneTimePbkCipher: string, responderContactCard?: string): Promise<CompleteOtk>;
+    currentUserSharedKey(input: {
+        username?: string;
+        userId?: string;
+    }): Promise<UserSharedKey>;
+}

package/lib/api/key-exchange.types.d.ts

@@ -0,0 +1,196 @@
+import { Key } from '../cryptography/cryptography.types';
+import { AccessLevel } from '../category/category.types';
+import { JWK } from 'node-jose';
+import { ContactCardName, TrustedPartyDetails } from '../users/profile.types';
+export interface PlainInitiatorRootKeyCipher {
+    nonce: string;
+    oneTimePrk: object;
+    otKey: object;
+    initiatorContactCard?: {
+        plainOwnerCipherDataJson: any;
+        plainSharedCipherDataJson: any;
+    };
+    initiator: {
+        message?: KeyExchangeMessage;
+        contactCard?: {
+            plainSharedCipherDataJson: TrustedPartyDetails;
+        };
+    };
+}
+export interface SharedContactCardInput {
+    plainCipherDataJson?: any;
+    plainSharedCipherDataJson?: any;
+    sharedCipherKey?: object;
+}
+export interface PreparedPermissions {
+    categories?: {
+        categoryId: string;
+        accessLevel: AccessLevel;
+    }[];
+    records?: {
+        recordId: string;
+        accessLevel: AccessLevel;
+    }[];
+}
+export interface KeyExchangeMessage {
+    name?: string;
+    email?: string;
+    message?: string;
+    permissions?: PreparedPermissions;
+}
+export interface PlainOtKeyCipher {
+    nonce: string;
+    initiator: {
+        oneTimePbk: object;
+        pbk: object;
+        sigPbk: object;
+        profile?: {
+            username?: string;
+        };
+        message?: KeyExchangeMessage;
+        contactCard?: {
+            plainSharedCipherDataJson: TrustedPartyDetails;
+        };
+    };
+}
+export interface DecryptedOtk {
+    plainOtKeyCipher: PlainOtKeyCipher;
+    otKey: JWK.Key;
+}
+export interface PlainInitiatorOneTimePbkCipher {
+    nonce: string;
+    sharedKey: object;
+    mkSharedKey: object;
+    responder: {
+        pbk: object;
+        sigPbk: object;
+        profile?: {
+            username?: string;
+        };
+        message?: KeyExchangeMessage;
+        contactCard?: {
+            plainSharedCipherDataJson: TrustedPartyDetails;
+            sharedCipherKey: object;
+        };
+    };
+}
+export declare enum OtkState {
+    OTK_INITIATED = "OTK_INITIATED",
+    OTK_ACCEPTED = "OTK_ACCEPTED",
+    OTK_COMPLETED = "OTK_COMPLETED"
+}
+export interface KeyExchangeContactCardInput {
+    ownerPlainData?: {
+        name: ContactCardName;
+    };
+    plainOwnerCipherDataJson: any;
+    plainSharedCipherDataJson: TrustedPartyDetails;
+}
+export interface InitiateOtkInput {
+    email?: string;
+    message?: KeyExchangeMessage;
+    contactCard?: KeyExchangeContactCardInput;
+    upgrade?: boolean;
+}
+export interface RespondOtkInput {
+    id: string;
+    token: string;
+    decryptedOtk: DecryptedOtk;
+    message?: KeyExchangeMessage;
+    initiatorContactCard?: {
+        plainReceiverCipherDataJson: any;
+    };
+    responderContactCard?: KeyExchangeContactCardInput;
+}
+export declare enum KeyExchangeState {
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETED = "COMPLETED",
+    DECLINED = "DECLINED",
+    CANCELLED = "CANCELLED"
+}
+export declare enum KeyExchangeMode {
+    OTK = "OTK"
+}
+export interface Otk {
+    id: string;
+    state: OtkState;
+    otKeyParams: string;
+    otKeyCipher: string;
+    sharedKey: Key;
+    mkSharedKey: Key;
+    initiatorSigPxk: Key;
+    responderSigPxk: Key;
+    initiatorOneTimePbkCipher: string;
+    responderPbkCipher?: string;
+}
+export interface KeyExchange {
+    id: string;
+    state: KeyExchangeState;
+    mode: KeyExchangeMode;
+    created: string;
+    modified: string;
+    isInitiator: boolean;
+    initiator: {
+        id: string;
+        username: string;
+    };
+    responder: {
+        id: string;
+        username: string;
+    };
+    initiatorActionRequired?: boolean;
+    responderActionRequired?: boolean;
+    responderEmailAddress?: string;
+    token?: string;
+    tokenExpiryTime?: string;
+    isExpired?: boolean;
+    otk?: Otk;
+    initiatorRootKeyCipher: string;
+}
+export interface DecryptedKeyExchange extends KeyExchange {
+    decryptedOtk?: DecryptedOtk;
+    message?: KeyExchangeMessage;
+    contactCard?: TrustedPartyDetails;
+    myMessage?: KeyExchangeMessage;
+    myContactCard?: TrustedPartyDetails;
+}
+export interface GetKeyExchangeOptions {
+    otKeyK?: string;
+    token?: string;
+}
+export interface RespondOtk {
+    keyExchange: KeyExchange;
+    userSharedKey: UserSharedKey;
+    tp: {
+        id: string;
+    };
+}
+export interface CompleteOtk {
+    keyExchange: KeyExchange;
+    userSharedKey: UserSharedKey;
+    tp: {
+        id: string;
+    };
+}
+export interface UserSharedKey {
+    userSigPrk: Key;
+    sharedKey: Key;
+    mkSharedKey?: Key;
+    mkPxk?: Key;
+    mkReshareRequestCipher?: string;
+    mkReshareResponseCipher?: string;
+    mkReshareRequestSent?: boolean;
+    mkReshareResponseSent?: boolean;
+}
+export interface GetKeyExchangeListOptions {
+    orderBy?: 'created' | '-created' | 'modified' | '-modified' | 'expiry_time' | '-expiry_time';
+    isExpired?: boolean;
+    initiatorActionRequired?: boolean;
+    responderActionRequired?: boolean;
+    initiator?: string;
+    responder?: string;
+    state?: 'IN_PROGRESS' | 'COMPLETED' | 'DECLINED' | 'CANCELLED';
+}
+export interface PlainResponderPbkCipher {
+    otKey: object;
+}

package/lib/api/key-exchange2.gql.d.ts

@@ -0,0 +1,125 @@
+import { JWK } from 'node-jose';
+import { Connection, DateTime, ID, LrEmail, OtKeyCipherClearJson2 } from './types';
+export declare type KeyExchangeState2 = 'IN_PROGRESS' | 'COMPLETED' | 'DECLINED' | 'CANCELLED' | 'DELETED';
+export interface KeyExchangeFragment {
+    id: ID;
+    token: string;
+    state: KeyExchangeState2;
+    mode: 'OTK';
+    isInitiator: boolean;
+    initiator: {
+        id: ID;
+        username: string;
+    };
+    responder: {
+        id: ID;
+        username: string;
+    };
+    created: DateTime;
+    modified: DateTime;
+    tokenExpiryTime: DateTime;
+    isExpired: boolean;
+    initiatorRootKeyCipher: string;
+    initiatorRootKeyCipherClearJson: any;
+    initiatorActionRequired: boolean;
+    responderActionRequired: boolean;
+    responderEmailAddress: LrEmail;
+    otk: {
+        state: 'OTK_INITIATED' | 'OTK_ACCEPTED' | 'OTK_COMPLETED';
+        otKeyParams: string;
+        otKeyCipher: string;
+        otKey?: JWK.Key;
+        otKeyCipherClearJson?: OtKeyCipherClearJson2;
+        sharedKey: {
+            id: ID;
+        };
+        mkSharedKey: {
+            id: ID;
+        };
+        initiatorSigPxk: {
+            id: ID;
+        };
+        responderSigPxk: {
+            id: ID;
+        };
+        initiatorOneTimePbkCipher: string;
+        initiatorOneTimePbkCipherClearJson: any;
+        responderPbkCipher: string;
+    };
+}
+export declare const KeyExchangeFragment: import("../_common/ast").TypedDocumentNode<KeyExchangeFragment>;
+export interface UserSharedKeyFragment {
+    userSigPrk: {
+        id: ID;
+    };
+    otherSigPbk: {
+        id: ID;
+    };
+    sharedKey: {
+        id: ID;
+    };
+    mkSharedKey: {
+        id: ID;
+    };
+}
+export declare const UserSharedKeyFragment: import("../_common/ast").TypedDocumentNode<UserSharedKeyFragment>;
+export interface KeyExchangesQuery2 {
+    keyExchanges: Connection<KeyExchangeFragment>;
+}
+export declare const KeyExchangesQuery2: import("../_common/ast").TypedDocumentNode<KeyExchangesQuery2>;
+export interface KeyExchangeQuery2 {
+    keyExchange: KeyExchangeFragment;
+}
+export declare const KeyExchangeQuery2: import("../_common/ast").TypedDocumentNode<KeyExchangeQuery2>;
+export interface KeyExchangeTokenQuery2 {
+    keyExchange: KeyExchangeFragment;
+}
+export declare const KeyExchangeTokenQuery2: import("../_common/ast").TypedDocumentNode<KeyExchangeTokenQuery2>;
+export interface CancelKeyExchangeMutation {
+    cancelKeyExchange: {
+        keyExchange: {
+            id: ID;
+        };
+    };
+}
+export declare const CancelKeyExchangeMutation: import("../_common/ast").TypedDocumentNode<CancelKeyExchangeMutation>;
+export interface DeclineKeyExchangeMutation {
+    declineKeyExchange: {
+        keyExchange: {
+            id: ID;
+        };
+    };
+}
+export declare const DeclineKeyExchangeMutation: import("../_common/ast").TypedDocumentNode<DeclineKeyExchangeMutation>;
+export interface InitiateKeyExchangeOtkMutation {
+    initiateKeyExchangeOtk: {
+        keyExchange: KeyExchangeFragment;
+    };
+}
+export declare const InitiateKeyExchangeOtkMutation: import("../_common/ast").TypedDocumentNode<InitiateKeyExchangeOtkMutation>;
+export interface RespondKeyExchangeOtkMutation {
+    respondKeyExchangeOtk: {
+        keyExchange: KeyExchangeFragment;
+        userSharedKey: UserSharedKeyFragment;
+        tp: {
+            id: ID;
+        };
+    };
+}
+export declare const RespondKeyExchangeOtkMutation: import("../_common/ast").TypedDocumentNode<RespondKeyExchangeOtkMutation>;
+export interface CompleteKeyExchangeOtkMutation {
+    completeKeyExchangeOtk: {
+        keyExchange: KeyExchangeFragment;
+        userSharedKey: UserSharedKeyFragment;
+        tp: {
+            id: ID;
+        };
+    };
+}
+export declare const CompleteKeyExchangeOtkMutation: import("../_common/ast").TypedDocumentNode<CompleteKeyExchangeOtkMutation>;
+export interface CurrentUserSharedKeyQuery2 {
+    currentUserSharedKey: {
+        userSharedKey: UserSharedKeyFragment;
+    };
+}
+export declare const CurrentUserSharedKeyQuery2: import("../_common/ast").TypedDocumentNode<CurrentUserSharedKeyQuery2>;

package/lib/api/key-exchange2.service.d.ts

@@ -0,0 +1,187 @@
+import { NgZone } from '@angular/core';
+import { JWK } from 'node-jose';
+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 { UserService } from './../users/user.service';
+import { OwnerPlainDataJson } from './contact-card2.service';
+import { CancelKeyExchangeMutation, CompleteKeyExchangeOtkMutation, CurrentUserSharedKeyQuery2, DeclineKeyExchangeMutation, InitiateKeyExchangeOtkMutation, KeyExchangeFragment, KeyExchangeState2, RespondKeyExchangeOtkMutation } from './key-exchange2.gql';
+import { LrGraphQLService, LrMutation } from './lr-graphql';
+import { ContactCardSharedCipherData, OtKeyCipherClearJson2 } from './types';
+/**
+ * The decrypted content of the one-time key cipher;
+ * When user supplies this information the lib doesn't need to do another API call
+ * to fetch the key exchange node. And since the typical use case is to display
+ * some information to the user, the key exchange node would already have been
+ * fetched and decrypted.
+ */
+export interface DecryptedOtk2 {
+    otKeyCipherClearJson: OtKeyCipherClearJson2;
+    otKey: JWK.Key;
+}
+export interface ContactCardReceiverCipherData {
+    receiverCipherDataClearJson: any;
+}
+export interface ContactCardOwnerPlainData {
+    ownerPlainDataJson: OwnerPlainDataJson;
+}
+export interface ContactCardOwnerCipherData {
+    ownerCipherDataClearJson: any;
+}
+/**
+ * Sending contact card information from the owner to the receiver.
+ */
+export declare type SendContactCardInput = ContactCardOwnerPlainData & ContactCardOwnerCipherData & ContactCardSharedCipherData;
+export interface InitiateOtkInput2 {
+    email?: string;
+    message?: any;
+    contactCard?: SendContactCardInput;
+    upgrade?: boolean;
+}
+export interface RespondOtkInput2 {
+    keyExchangeId: string;
+    token: string;
+    decryptedOtk: DecryptedOtk2;
+    message?: any;
+    initiatorContactCard?: ContactCardReceiverCipherData;
+    responderContactCard?: SendContactCardInput;
+}
+export interface CompleteOtkInput2 {
+    keyExchangeId: string;
+    initiatorRootKeyCipher: string;
+    initiatorOneTimePbkCipher: string;
+    responderContactCard?: ContactCardReceiverCipherData;
+    initiatorContactCard?: ContactCardOwnerCipherData;
+}
+export interface InitiatorRootKeyCipherClearJson2 {
+    nonce: string;
+    oneTimePrk: object;
+    otKey: object;
+    initiatorContactCard?: ContactCardOwnerCipherData & ContactCardSharedCipherData;
+    initiator: {
+        message?: any;
+        contactCard?: ContactCardSharedCipherData;
+    };
+}
+export interface InitiatorOneTimePbkCipherClearJson {
+    nonce: string;
+    sharedKey: object;
+    mkSharedKey: object;
+    responder: {
+        pbk: object;
+        sigPbk: object;
+        message?: any;
+        contactCard?: ContactCardSharedCipherData & {
+            sharedCipherKey: object;
+        };
+    };
+}
+export interface GetKeyExchangeOptions2 {
+    otKeyK?: string;
+    token?: string;
+}
+export declare class KeyExchange2Service {
+    private ngZone;
+    private keyFactory;
+    private keyService;
+    private encryptionService;
+    private userService;
+    private keyGraph;
+    private lrGraphQL;
+    private readonly CLIENT_NONCE_LENGTH;
+    constructor(ngZone: NgZone, keyFactory: KeyFactoryService, keyService: KeyService, encryptionService: EncryptionService, userService: UserService, keyGraph: KeyGraphService, lrGraphQL: LrGraphQLService);
+    private getOtKey;
+    private decryptOtk;
+    private decryptResponseCipher;
+    private decryptKeyExchangeAsInitiator;
+    private decryptKeyExchangeAsResponder;
+    decryptKeyExchange(keyExchange: KeyExchangeFragment, otKeyK?: string): Promise<KeyExchangeFragment>;
+    getKeyExchanges({ state }?: {
+        state?: KeyExchangeState2;
+    }): Promise<KeyExchangeFragment[]>;
+    /**
+     * @param id If the current user can responder the key exchange if they are either the initiator or the receiver.
+     * @param token If not signed in, or not the initiator or responder, 'token' must be given.
+     * @param otKeyK Is the raw one-time key (string). If the responder is explicitly specified at time of initiation, then
+     *   it's possible to have the otKey wrapped by the public key of the responder. In which case, the otKeyK is not needed.
+     */
+    getKeyExchange(id: string, { otKeyK, token }?: GetKeyExchangeOptions2): Promise<KeyExchangeFragment>;
+    getCurrentUserSharedKey(input: {
+        username?: string;
+        userId?: string;
+    }): Promise<CurrentUserSharedKeyQuery2>;
+    cancelKeyExchange(id: string): Promise<LrMutation<CancelKeyExchangeMutation, {
+        input: {
+            id: string;
+        };
+    }>>;
+    cancelKeyExchangeMutation(id: string): LrMutation<CancelKeyExchangeMutation, {
+        input: {
+            id: string;
+        };
+    }>;
+    declineKeyExchange(id: string, token: string): Promise<LrMutation<DeclineKeyExchangeMutation, {
+        input: {
+            id: string;
+            token: string;
+        };
+    }>>;
+    declineKeyExchangeMutation(id: string, token: string): LrMutation<DeclineKeyExchangeMutation, {
+        input: {
+            id: string;
+            token: string;
+        };
+    }>;
+    initiateOtk({ message, email, contactCard, upgrade, }?: InitiateOtkInput2): Promise<{
+        lrMutation: LrMutation<InitiateKeyExchangeOtkMutation, {
+            input: {
+                initiatorRootKeyCipher: string;
+                initiatorPxkId: string;
+                initiatorSigPxkId: string;
+                otKeyParams: string;
+                otKeyCipher: string;
+                sendEmail: {
+                    email: string;
+                    rawOtKey: string;
+                };
+                createTp: boolean;
+                initiatorPlainDataSig: string;
+                upgrade: boolean;
+            };
+        }>;
+        otKeyK: string;
+    }>;
+    respondOtk({ keyExchangeId, token, decryptedOtk, message, initiatorContactCard, responderContactCard, }: RespondOtkInput2): Promise<LrMutation<RespondKeyExchangeOtkMutation, {
+        input: {
+            keyExchangeId: string;
+            keyExchangeToken: string;
+            rootKeyId: string;
+            masterKeyId: string;
+            responderPxkId: string;
+            responderSigPxkId: string;
+            signedInitiatorPbk: string;
+            signedInitiatorSigPbk: string;
+            rkWrappedSharedKey: string;
+            mkWrappedMkSharedKey: string;
+            initiatorOneTimePbkCipher: string;
+            initiatorContactCard: any;
+            responderContactCard: any;
+        };
+    }>>;
+    completeOtk({ keyExchangeId, initiatorRootKeyCipher, initiatorOneTimePbkCipher, responderContactCard, initiatorContactCard, }: CompleteOtkInput2): Promise<LrMutation<CompleteKeyExchangeOtkMutation, {
+        input: {
+            keyExchangeId: string;
+            rootKeyId: string;
+            masterKeyId: string;
+            initiatorSigPxkId: string;
+            signedResponderPbk: string;
+            signedResponderSigPbk: string;
+            rkWrappedSharedKey: string;
+            mkWrappedMkSharedKey: string;
+            responderContactCardCipher: any;
+            initiatorContactCardCipher: any;
+            initiatorContactCardSharedCipher: any;
+        };
+    }>>;
+}

package/lib/api/lock.gql.d.ts

@@ -0,0 +1,27 @@
+import { DateTime, LockState, UUID } from './types';
+export interface LockFragmentResult {
+    created: DateTime;
+    modified: DateTime;
+    version?: UUID;
+    expiryTime: DateTime;
+    state: LockState;
+}
+export declare const LockFragment: import("../_common/ast").TypedDocumentNode<LockFragmentResult>;
+export interface UpdateLockMutationResult {
+    updateLock: {
+        lock: LockFragmentResult;
+    };
+}
+export declare const UpdateLockMutation: import("../_common/ast").TypedDocumentNode<UpdateLockMutationResult>;
+export interface AcquireLockMutationResult {
+    acquireLock: {
+        lock: LockFragmentResult;
+    };
+}
+export declare const AcquireLockMutation: import("../_common/ast").TypedDocumentNode<AcquireLockMutationResult>;
+export interface ReleaseLockMutationResult {
+    releaseLock: {
+        lock: LockFragmentResult;
+    };
+}
+export declare const ReleaseLockMutation: import("../_common/ast").TypedDocumentNode<ReleaseLockMutationResult>;

package/lib/api/lock.service.d.ts

@@ -0,0 +1,25 @@
+import { Injector, NgZone } from '@angular/core';
+import { LrMutation, LrService } from './lr-graphql';
+export declare class LockService extends LrService {
+    private ngZone;
+    private injector;
+    constructor(ngZone: NgZone, injector: Injector);
+    updateLockMutation(resourceId: string, version: string): LrMutation<import("./lock.gql").UpdateLockMutationResult, {
+        input: {
+            resourceId: string;
+            version: string;
+        };
+    }>;
+    acquireLockMutation(resourceId: string, timeoutMs: number): LrMutation<import("./lock.gql").AcquireLockMutationResult, {
+        input: {
+            resourceId: string;
+            timeoutMs: number;
+        };
+    }>;
+    releaseLockMutation(resourceId: string, version: string): LrMutation<import("./lock.gql").ReleaseLockMutationResult, {
+        input: {
+            resourceId: string;
+            version: string;
+        };
+    }>;
+}

package/lib/api/lr-apollo.service.d.ts

@@ -0,0 +1,15 @@
+import { Apollo } from 'apollo-angular';
+import { QueryOptions, MutationOptions } from '@apollo/client/core';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+export declare class LrApolloService {
+    private apollo;
+    private keyGraph;
+    constructor(apollo: Apollo, keyGraph: KeyGraphService);
+    private addKeys;
+    query<T, V = {
+        [key: string]: any;
+    }>(options: QueryOptions<V>): Promise<T>;
+    mutate<T extends any, V = {
+        [key: string]: any;
+    }>(options: MutationOptions<T, V>): Promise<T>;
+}

package/{src/lib/api/lr-graphql/index.ts → lib/api/lr-graphql/index.d.ts}

@@ -1,5 +1,5 @@
-export * from './lr-graphql.service';
-export * from './lr-merged-mutation';
-export * from './lr-mutation';
-export * from './lr-mutation-base';
-export * from './lr.service';
+export * from './lr-graphql.service';
+export * from './lr-merged-mutation';
+export * from './lr-mutation';
+export * from './lr-mutation-base';
+export * from './lr.service';

package/lib/api/lr-graphql/lr-graphql.service.d.ts

@@ -0,0 +1,60 @@
+import { NgZone } from '@angular/core';
+import { Apollo } from 'apollo-angular';
+import { QueryOptions, MutationOptions, OperationVariables, FetchPolicy } from '@apollo/client/core';
+import { MutationBaseOptions } from '@apollo/client/core/watchQueryOptions';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { TypedDocumentNode } from '../../_common/ast';
+import { ProcessorOptions, QueryProcessorService } from '../query-processor';
+import { LrMutationBase } from './lr-mutation-base';
+import { LrMergedMutation } from './lr-merged-mutation';
+export interface LrQueryOptions<T, TVariables> extends QueryOptions<TVariables> {
+    query: TypedDocumentNode<T>;
+    includeKeyGraph?: boolean;
+    processorOptions?: ProcessorOptions;
+}
+export interface LrMutationOptions<T = {
+    [key: string]: any;
+}, TVariables = OperationVariables> extends MutationBaseOptions<T, TVariables> {
+    context?: any;
+    fetchPolicy?: FetchPolicy;
+    includeKeyGraph?: boolean;
+}
+export interface LrApolloMutationOptions<T, TVariables = OperationVariables> extends MutationOptions<T, TVariables> {
+    mutation: TypedDocumentNode<T>;
+    includeKeyGraph?: boolean;
+    processorOptions?: ProcessorOptions;
+}
+interface LrGraphQLServiceStats {
+    queryCount: number;
+    mutationCount: number;
+}
+export declare class LrGraphQLService {
+    private ngZone;
+    private apollo;
+    private keyGraph;
+    private queryProcessor;
+    private stats;
+    constructor(ngZone: NgZone, apollo: Apollo, keyGraph: KeyGraphService, queryProcessor: QueryProcessorService);
+    query<T, V = {
+        [key: string]: any;
+    }>(options: LrQueryOptions<T, V>): Promise<T>;
+    private lrMutateImpl;
+    apolloMutate<T extends any, TVariables = {
+        [key: string]: any;
+    }>(options: LrApolloMutationOptions<T, TVariables>): Promise<T>;
+    statsSnapshot(): LrGraphQLServiceStats;
+    private addKeys;
+    private isIncludeKeyGraph;
+    lrMutate<T1, TVariables1, T2, TVariables2>(lrMutations: [LrMutationMayAsync<T1, TVariables1>, LrMutationMayAsync<T2, TVariables2>], options?: LrMutationOptions): Promise<[T1, T2]>;
+    lrMutate<T1, TVariables1, T2, TVariables2, T3, TVariables3>(lrMutations: [LrMutationMayAsync<T1, TVariables1>, LrMutationMayAsync<T2, TVariables2>, LrMutationMayAsync<T3, TVariables3>], options?: LrMutationOptions): Promise<[T1, T2, T3]>;
+    lrMutate<T1, TVariables1, T2, TVariables2, T3, TVariables3, T4, TVariables4>(lrMutations: [LrMutationMayAsync<T1, TVariables1>, LrMutationMayAsync<T2, TVariables2>, LrMutationMayAsync<T3, TVariables3>, LrMutationMayAsync<T4, TVariables4>], options?: LrMutationOptions): Promise<[T1, T2, T3, T4]>;
+    lrMutate<T1, TVariables1, T2, TVariables2, T3, TVariables3, T4, TVariables4, T5, TVariables5>(lrMutations: [LrMutationMayAsync<T1, TVariables1>, LrMutationMayAsync<T2, TVariables2>, LrMutationMayAsync<T3, TVariables3>, LrMutationMayAsync<T4, TVariables4>, LrMutationMayAsync<T5, TVariables5>], options?: LrMutationOptions): Promise<[T1, T2, T3, T4, T5]>;
+    lrMutate<T, TVariables = {
+        [key: string]: any;
+    }>(lrMutation: LrMutationMayAsync<T, TVariables>, options?: LrMutationOptions<T, TVariables>): Promise<T>;
+    lrMutate<T, TVariables = {
+        [key: string]: any;
+    }>(lrMutations: LrMutationMayAsync<T, TVariables>[] | LrMutationMayAsync<T, TVariables>, options?: LrMutationOptions): any;
+}
+declare type LrMutationMayAsync<T, TVariables> = LrMutationBase<T, TVariables> | Promise<LrMutationBase<T, TVariables>> | LrMergedMutation<T> | Promise<LrMergedMutation<T>>;
+export {};