@lifeready/core 1.0.15 → 1.0.16

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

@@ -1,27 +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>;
+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

@@ -1,34 +1,34 @@
-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(options: {
-        resourceId?: string;
-        version: string;
-    }): LrMutation<import("./lock.gql").UpdateLockMutationResult, {
-        input: {
-            resourceId: string;
-            version: string;
-        };
-    }>;
-    acquireLockMutation(options: {
-        resourceId?: string;
-        timeoutMs: number;
-    }): LrMutation<import("./lock.gql").AcquireLockMutationResult, {
-        input: {
-            resourceId: string;
-            timeoutMs: number;
-        };
-    }>;
-    releaseLockMutation(options: {
-        resourceId: string;
-        version: string;
-    }): LrMutation<import("./lock.gql").ReleaseLockMutationResult, {
-        input: {
-            resourceId: string;
-            version: string;
-        };
-    }>;
-}
+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(options: {
+        resourceId?: string;
+        version: string;
+    }): LrMutation<import("./lock.gql").UpdateLockMutationResult, {
+        input: {
+            resourceId: string;
+            version: string;
+        };
+    }>;
+    acquireLockMutation(options: {
+        resourceId?: string;
+        timeoutMs: number;
+    }): LrMutation<import("./lock.gql").AcquireLockMutationResult, {
+        input: {
+            resourceId: string;
+            timeoutMs: number;
+        };
+    }>;
+    releaseLockMutation(options: {
+        resourceId: string;
+        version: string;
+    }): LrMutation<import("./lock.gql").ReleaseLockMutationResult, {
+        input: {
+            resourceId: string;
+            version: string;
+        };
+    }>;
+}

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

@@ -1,15 +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>;
-}
+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/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

@@ -1,60 +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 {};
+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 {};

package/lib/api/lr-graphql/lr-merged-mutation.d.ts

@@ -1,28 +1,28 @@
-import { LrMutationBase } from './lr-mutation-base';
-export declare class LrMergedMutation<T> extends LrMutationBase<T> {
-    readonly lrMutations: LrMutationBase<any>[];
-    readonly descendants: Set<LrMutationBase<any>>;
-    protected prefixes: string[];
-    constructor(lrMutations: LrMutationBase<any>[]);
-    static create<T1, T2>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>]): LrMergedMutation<[T1, T2]>;
-    static create<T1, T2, T3>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>]): LrMergedMutation<[T1, T2, T3]>;
-    static create<T1, T2, T3, T4>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>, LrMutationBase<T4> | LrMergedMutation<T4>]): LrMergedMutation<[T1, T2, T3, T4]>;
-    static create<T1, T2, T3, T4, T5>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>, LrMutationBase<T4> | LrMergedMutation<T4>, LrMutationBase<T5> | LrMergedMutation<T5>]): LrMergedMutation<[T1, T2, T3, T4, T5]>;
-    static create<T>(lrMutations: LrMutationBase<T>[]): LrMergedMutation<T[]>;
-    static create(lrMutations: LrMutationBase<any>[]): LrMergedMutation<any[]>;
-    private getDescendants;
-    resolve(value: any): void;
-    reject(reason?: any): void;
-    setExecuted(): void;
-    private renameVariableDefinition;
-    private renameVariableDefinitions;
-    private renameArgument;
-    private renameField;
-    private renameFragmentSpread;
-    private processSelection;
-    private processSelectionSet;
-    private renameSelections;
-    private renameFragmentDefinition;
-    private renameFragmentDefinitions;
-    private merge;
-}
+import { LrMutationBase } from './lr-mutation-base';
+export declare class LrMergedMutation<T> extends LrMutationBase<T> {
+    readonly lrMutations: LrMutationBase<any>[];
+    readonly descendants: Set<LrMutationBase<any>>;
+    protected prefixes: string[];
+    constructor(lrMutations: LrMutationBase<any>[]);
+    static create<T1, T2>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>]): LrMergedMutation<[T1, T2]>;
+    static create<T1, T2, T3>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>]): LrMergedMutation<[T1, T2, T3]>;
+    static create<T1, T2, T3, T4>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>, LrMutationBase<T4> | LrMergedMutation<T4>]): LrMergedMutation<[T1, T2, T3, T4]>;
+    static create<T1, T2, T3, T4, T5>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>, LrMutationBase<T4> | LrMergedMutation<T4>, LrMutationBase<T5> | LrMergedMutation<T5>]): LrMergedMutation<[T1, T2, T3, T4, T5]>;
+    static create<T>(lrMutations: LrMutationBase<T>[]): LrMergedMutation<T[]>;
+    static create(lrMutations: LrMutationBase<any>[]): LrMergedMutation<any[]>;
+    private getDescendants;
+    resolve(value: any): void;
+    reject(reason?: any): void;
+    setExecuted(): void;
+    private renameVariableDefinition;
+    private renameVariableDefinitions;
+    private renameArgument;
+    private renameField;
+    private renameFragmentSpread;
+    private processSelection;
+    private processSelectionSet;
+    private renameSelections;
+    private renameFragmentDefinition;
+    private renameFragmentDefinitions;
+    private merge;
+}

package/lib/api/lr-graphql/lr-mutation-base.d.ts

@@ -1,28 +1,28 @@
-import { OperationVariables } from '@apollo/client/core';
-import { FragmentSpreadNode } from 'graphql';
-import { TypedDocumentNode } from '../../_common/ast';
-import { DeferredPromise } from '../../_common/deferred-promise';
-export interface LrMutationData<T, TVariables = OperationVariables> {
-    mutation: TypedDocumentNode<T>;
-    variables?: TVariables;
-}
-export declare const fragmentSpreadAstSelection: FragmentSpreadNode;
-/**
- * DECISION: LrMutationBase does not provide a convenience method to call lrGraphQL.lrMutate()
- * because this class could be made independent of what lib is used to call the API. If we
- * provided a configurable call back to make the API call, then the typing for that callback
- * needs to be known. But since the API lib (eg. Apollo) has it's own unique return type, so
- * it's not possible to do in general.
- */
-export declare abstract class LrMutationBase<T, TVariables = OperationVariables> {
-    protected mutation: TypedDocumentNode<T>;
-    protected variables?: TVariables;
-    protected _executed: boolean;
-    readonly deferredPromise: DeferredPromise<T>;
-    get promise(): Promise<T>;
-    resolve(value: T): void;
-    reject(reason?: any): void;
-    get lrMutationData(): LrMutationData<T, TVariables>;
-    get executed(): boolean;
-    setExecuted(): void;
-}
+import { OperationVariables } from '@apollo/client/core';
+import { FragmentSpreadNode } from 'graphql';
+import { TypedDocumentNode } from '../../_common/ast';
+import { DeferredPromise } from '../../_common/deferred-promise';
+export interface LrMutationData<T, TVariables = OperationVariables> {
+    mutation: TypedDocumentNode<T>;
+    variables?: TVariables;
+}
+export declare const fragmentSpreadAstSelection: FragmentSpreadNode;
+/**
+ * DECISION: LrMutationBase does not provide a convenience method to call lrGraphQL.lrMutate()
+ * because this class could be made independent of what lib is used to call the API. If we
+ * provided a configurable call back to make the API call, then the typing for that callback
+ * needs to be known. But since the API lib (eg. Apollo) has it's own unique return type, so
+ * it's not possible to do in general.
+ */
+export declare abstract class LrMutationBase<T, TVariables = OperationVariables> {
+    protected mutation: TypedDocumentNode<T>;
+    protected variables?: TVariables;
+    protected _executed: boolean;
+    readonly deferredPromise: DeferredPromise<T>;
+    get promise(): Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: any): void;
+    get lrMutationData(): LrMutationData<T, TVariables>;
+    get executed(): boolean;
+    setExecuted(): void;
+}

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

@@ -1,8 +1,8 @@
-import { OperationVariables } from '@apollo/client/core';
-import { TypedDocumentNode } from '../../_common/ast';
-import { LrMutationData } from './lr-mutation-base';
-import { LrMutationBase } from './lr-mutation-base';
-export declare class LrMutation<T extends any, TVariables = OperationVariables> extends LrMutationBase<T, TVariables> {
-    constructor(options: LrMutationData<T, TVariables>);
-    select<TResult>(fragments: TypedDocumentNode<TResult>): LrMutation<TResult, TVariables>;
-}
+import { OperationVariables } from '@apollo/client/core';
+import { TypedDocumentNode } from '../../_common/ast';
+import { LrMutationData } from './lr-mutation-base';
+import { LrMutationBase } from './lr-mutation-base';
+export declare class LrMutation<T extends any, TVariables = OperationVariables> extends LrMutationBase<T, TVariables> {
+    constructor(options: LrMutationData<T, TVariables>);
+    select<TResult>(fragments: TypedDocumentNode<TResult>): LrMutation<TResult, TVariables>;
+}

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

@@ -1,9 +1,9 @@
-import { Injector } from '@angular/core';
-import { LrGraphQLService, LrMutationOptions, LrQueryOptions } from './lr-graphql.service';
-import { LrMutationBase } from './lr-mutation-base';
-export declare class LrService {
-    protected lrGraphQL: LrGraphQLService;
-    constructor(injector: Injector);
-    protected mutate<T, TVariables>(lrMutation: LrMutationBase<T, TVariables> | Promise<LrMutationBase<T, TVariables>>, options?: LrMutationOptions<T, TVariables>): Promise<T>;
-    protected query<T, V>(options: LrQueryOptions<T, V>): Promise<T>;
-}
+import { Injector } from '@angular/core';
+import { LrGraphQLService, LrMutationOptions, LrQueryOptions } from './lr-graphql.service';
+import { LrMutationBase } from './lr-mutation-base';
+export declare class LrService {
+    protected lrGraphQL: LrGraphQLService;
+    constructor(injector: Injector);
+    protected mutate<T, TVariables>(lrMutation: LrMutationBase<T, TVariables> | Promise<LrMutationBase<T, TVariables>>, options?: LrMutationOptions<T, TVariables>): Promise<T>;
+    protected query<T, V>(options: LrQueryOptions<T, V>): Promise<T>;
+}

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

@@ -1,58 +1,58 @@
-import { JWK } from 'node-jose';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { KeyExchangeService } from './key-exchange.service';
-import { LrApolloService } from './lr-apollo.service';
-export declare const SendMessageMutation: import("graphql").DocumentNode;
-export declare const MessageQuery: import("graphql").DocumentNode;
-export interface SendMessage {
-    message: {
-        id: string;
-    };
-}
-export interface SendMessageInput {
-    username?: string;
-    userId?: string;
-    plainMessageJson?: any;
-    plainCipherMessageJson?: any;
-}
-export interface Message {
-    id: string;
-    sender: {
-        id: string;
-        username: string;
-    };
-    receiver: {
-        id: string;
-        username: string;
-    };
-    plainMessage: string;
-    plainMessageJson?: any;
-    signedCipherMessage: string;
-    plainSignedCipherMessageJson?: any;
-    senderSigPbk: {
-        id: string;
-    };
-    sharedKey: {
-        id: string;
-    };
-}
-interface DecryptMessageOptions {
-    sharedKey: JWK.Key;
-    senderSigPbk: JWK.Key;
-}
-export declare class MessageService {
-    private lrApollo;
-    private keyGraph;
-    private encryptionService;
-    private keyExchangeService;
-    private readonly encrypt;
-    private readonly decrypt;
-    private readonly sign;
-    private readonly verify;
-    constructor(lrApollo: LrApolloService, keyGraph: KeyGraphService, encryptionService: EncryptionService, keyExchangeService: KeyExchangeService);
-    sendMessage({ username, userId, plainMessageJson, plainCipherMessageJson, }: SendMessageInput): Promise<SendMessage>;
-    decryptMessage(message: Message, { sharedKey, senderSigPbk }: DecryptMessageOptions): Promise<void>;
-    getMessage(id: string): Promise<Message>;
-}
-export {};
+import { JWK } from 'node-jose';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyExchangeService } from './key-exchange.service';
+import { LrApolloService } from './lr-apollo.service';
+export declare const SendMessageMutation: import("graphql").DocumentNode;
+export declare const MessageQuery: import("graphql").DocumentNode;
+export interface SendMessage {
+    message: {
+        id: string;
+    };
+}
+export interface SendMessageInput {
+    username?: string;
+    userId?: string;
+    plainMessageJson?: any;
+    plainCipherMessageJson?: any;
+}
+export interface Message {
+    id: string;
+    sender: {
+        id: string;
+        username: string;
+    };
+    receiver: {
+        id: string;
+        username: string;
+    };
+    plainMessage: string;
+    plainMessageJson?: any;
+    signedCipherMessage: string;
+    plainSignedCipherMessageJson?: any;
+    senderSigPbk: {
+        id: string;
+    };
+    sharedKey: {
+        id: string;
+    };
+}
+interface DecryptMessageOptions {
+    sharedKey: JWK.Key;
+    senderSigPbk: JWK.Key;
+}
+export declare class MessageService {
+    private lrApollo;
+    private keyGraph;
+    private encryptionService;
+    private keyExchangeService;
+    private readonly encrypt;
+    private readonly decrypt;
+    private readonly sign;
+    private readonly verify;
+    constructor(lrApollo: LrApolloService, keyGraph: KeyGraphService, encryptionService: EncryptionService, keyExchangeService: KeyExchangeService);
+    sendMessage({ username, userId, plainMessageJson, plainCipherMessageJson, }: SendMessageInput): Promise<SendMessage>;
+    decryptMessage(message: Message, { sharedKey, senderSigPbk }: DecryptMessageOptions): Promise<void>;
+    getMessage(id: string): Promise<Message>;
+}
+export {};

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

@@ -1,31 +1,31 @@
-import { JWK } from 'node-jose';
-import { Injector } from '@angular/core';
-import { CookieService } from 'ngx-cookie-service';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
-export declare class PersistService {
-    private keyFactory;
-    private cookieService;
-    private encryptionService;
-    private injector;
-    private readonly KEY_PREFIX;
-    private cookieSecure;
-    private serverSessionEncryptionKey;
-    constructor(keyFactory: KFS, cookieService: CookieService, encryptionService: EncryptionService, injector: Injector);
-    setServerSessionEncryptionKey(key: JWK.Key): void;
-    clearServerSessionEncryptionKey(): void;
-    private getCookieParams;
-    clear(): void;
-    setCookieSecure(value: boolean): void;
-    private prefixName;
-    delete(name: string): void;
-    private deletePrefixedName;
-    set({ name, value, serverSession, expiry, }: {
-        name: string;
-        value: any;
-        serverSession: boolean;
-        expiry?: Date;
-    }): Promise<void>;
-    get(name: string): Promise<any>;
-    private getImpl;
-}
+import { JWK } from 'node-jose';
+import { Injector } from '@angular/core';
+import { CookieService } from 'ngx-cookie-service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+export declare class PersistService {
+    private keyFactory;
+    private cookieService;
+    private encryptionService;
+    private injector;
+    private readonly KEY_PREFIX;
+    private cookieSecure;
+    private serverSessionEncryptionKey;
+    constructor(keyFactory: KFS, cookieService: CookieService, encryptionService: EncryptionService, injector: Injector);
+    setServerSessionEncryptionKey(key: JWK.Key): void;
+    clearServerSessionEncryptionKey(): void;
+    private getCookieParams;
+    clear(): void;
+    setCookieSecure(value: boolean): void;
+    private prefixName;
+    delete(name: string): void;
+    private deletePrefixedName;
+    set({ name, value, serverSession, expiry, }: {
+        name: string;
+        value: any;
+        serverSession: boolean;
+        expiry?: Date;
+    }): Promise<void>;
+    get(name: string): Promise<any>;
+    private getImpl;
+}