@lifeready/core 0.6.0-beta.1

package/lib/life-ready.config.d.ts

@@ -0,0 +1,14 @@
+import { InjectionToken } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { ApolloClientOptions } from '@apollo/client/core';
+export declare const LR_CONFIG: InjectionToken<LifeReadyConfig>;
+export interface LifeReadyConfig {
+    authUrl: string;
+    apiUrl: string;
+    apolloUrl: string;
+    userPoolId: string;
+    userPoolWebClientId: string;
+    apolloConfig?: ApolloClientOptions<any>;
+    disableSessionEncryptionKey?: boolean;
+}
+export declare const configureApollo: (config: LifeReadyConfig, auth: AuthClass) => ApolloClientOptions<any>;

package/lib/life-ready.module.d.ts

@@ -0,0 +1,5 @@
+import { ModuleWithProviders } from '@angular/core';
+import { LifeReadyConfig } from './life-ready.config';
+export declare class LifeReadyModule {
+    static forRoot(config: LifeReadyConfig): ModuleWithProviders<LifeReadyModule>;
+}

package/lib/plan/plan.gql.d.ts

@@ -0,0 +1,11 @@
+export declare const CreateStripeCheckoutSessionMutation: import("graphql").DocumentNode;
+export declare const CreateStripeBillingPortalSessionMutation: import("graphql").DocumentNode;
+export declare const planFields = "\n  name\n  data\n  state\n";
+export declare const CreateUserIssuedPlanMutation: import("graphql").DocumentNode;
+export declare const DeleteUserIssuedPlanMutation: import("graphql").DocumentNode;
+export declare const UserIssuablePlansQuery: import("graphql").DocumentNode;
+export declare const UserIssuedPlansQuery: import("graphql").DocumentNode;
+export declare const UserIssuedPlanQuery: import("graphql").DocumentNode;
+export declare const AssociateUserIssuedPlanMutation: import("graphql").DocumentNode;
+export declare const UserPlansQuery: import("graphql").DocumentNode;
+export declare const StripeQuery: import("graphql").DocumentNode;

package/lib/plan/plan.service.d.ts

@@ -0,0 +1,33 @@
+import { LrApolloService } from '../api/lr-apollo.service';
+import { StripeCheckoutSession, StripeBillingPortalSession, UserIssuablePlan, UserIssuedPlan, UserPlan } from './plan.types';
+export declare function mapUserPlans(userPlans: any[]): UserPlan[];
+export declare class PlanService {
+    private lrApollo;
+    constructor(lrApollo: LrApolloService);
+    createStripeCheckoutSession(input: {
+        priceId: string;
+        successUrl: string;
+        cancelUrl: string;
+    }): Promise<StripeCheckoutSession>;
+    createStripeBillingPortalSession(returnUrl: string): Promise<StripeBillingPortalSession>;
+    getUserIssuablePlans(): Promise<UserIssuablePlan[]>;
+    createUserIssuedPlan({ planName, tokenExpiryTime, planPeriodEnd, planPeriodEndAfterSeconds, }: {
+        planName: string;
+        tokenExpiryTime: Date;
+        planPeriodEnd?: Date;
+        planPeriodEndAfterSeconds?: number;
+    }): Promise<UserIssuedPlan>;
+    deleteUserIssuedPlan(id: string): Promise<void>;
+    getUserIssuedPlans(): Promise<any[]>;
+    getUserIssuedPlan(id: string, token?: string): Promise<any>;
+    associateUserIssuedPlan({ id, token, }: {
+        id: string;
+        token: string;
+    }): Promise<UserPlan>;
+    getUserPlans(): Promise<UserPlan[]>;
+    getPlanType(subscriptionId: string): Promise<string>;
+    getStripe(): Promise<{
+        id: string;
+        customer: object;
+    }>;
+}

package/lib/plan/plan.types.d.ts

@@ -0,0 +1,31 @@
+export declare class Plan {
+    name: string;
+    data: object;
+    state: string;
+}
+export declare class Subscription {
+    id: string;
+}
+export declare class UserPlan {
+    id: string;
+    plan: Plan;
+    periodEnd: Date;
+    subscription: Subscription;
+}
+export declare class StripeCheckoutSession {
+    id: string;
+}
+export declare class StripeBillingPortalSession {
+    url: string;
+}
+export interface UserIssuablePlan {
+    plan: Plan;
+}
+export interface UserIssuedPlan {
+    id: string;
+    plan: Plan;
+    token: string;
+    tokenExpiryTime: Date;
+    planPeriodEnd: Date;
+    planPeriodEndAfterSeconds: number;
+}

package/lib/record/record-attachment.service.d.ts

@@ -0,0 +1,16 @@
+import { NewOrUpdatedAttachment } from './record.types';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { FileService } from '../api/file.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+export declare class RecordAttachmentService {
+    private fileService;
+    private lrApollo;
+    private keyMetaService;
+    private keyGraph;
+    constructor(fileService: FileService, lrApollo: LrApolloService, keyMetaService: KeyMetaService, keyGraph: KeyGraphService);
+    downloadAttachment(fileStateNodeId: string, keyId: string): Promise<any>;
+    uploadAttachments(recordId: string, attachments: NewOrUpdatedAttachment[]): Promise<string[]>;
+    private addAttachment;
+    deleteAttachment(fileId: string): Promise<void>;
+}

package/lib/record/record.gql.d.ts

@@ -0,0 +1,14 @@
+export declare enum FileType {
+    RecordContent = "record-content",
+    RecordAttachment = "record-attachment"
+}
+export declare const RecordContentFilter: string;
+export declare const RecordAttachmentFilter: string;
+export declare const GetRecordQuery: (depth?: number) => import("graphql").DocumentNode;
+export declare const CreateRecordContainerMutation: import("graphql").DocumentNode;
+export declare const CreateRecordMutation: import("graphql").DocumentNode;
+export declare const UpdateRecordContainerMutation: import("graphql").DocumentNode;
+export declare const UpdateRecordMutation: import("graphql").DocumentNode;
+export declare const DeleteRecordMutation: import("graphql").DocumentNode;
+export declare const CreateFileMutation: import("graphql").DocumentNode;
+export declare const DeleteFileMutation: import("graphql").DocumentNode;

package/lib/record/record.service.d.ts

@@ -0,0 +1,25 @@
+import { RecordAttachmentService } from './record-attachment.service';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { LrRecord, NewRecord, UpdatedRecord } from './record.types';
+import { CategoryService } from '../category/category.service';
+export declare class RecordService {
+    private lrApollo;
+    private keyMetaService;
+    private categoryService;
+    private recordAttachmentService;
+    constructor(lrApollo: LrApolloService, keyMetaService: KeyMetaService, categoryService: CategoryService, recordAttachmentService: RecordAttachmentService);
+    getRecord(recordId: string): Promise<LrRecord>;
+    private mapAttachments;
+    createRecord(newRecord: NewRecord): Promise<{
+        recordId: string;
+        attachmentError?: Error;
+    }>;
+    updateRecord(recordId: string, updateId: string, updateKeyId: string, updatedRecord: UpdatedRecord): Promise<{
+        recordId: string;
+        attachmentError?: Error;
+    }>;
+    archiveRecord(recordId: string): Promise<void>;
+    unarchiveRecord(recordId: string): Promise<void>;
+    deleteRecord(recordId: string): Promise<void>;
+}

package/lib/record/record.types.d.ts

@@ -0,0 +1,57 @@
+import { AccessLevel, Category, SharedAccess } from '../category/category.types';
+import { RecordFieldType, RecordTypeFieldOption, RecordTypeSummary } from '../record-type/record-type.types';
+export declare type RecordFieldValue = string | string[] | RecordTypeFieldOption | RecordTypeFieldOption[] | RecordField[];
+export declare class RecordField {
+    id?: string;
+    label: string;
+    type: RecordFieldType;
+    value?: RecordFieldValue;
+}
+export declare class RecordAttachment {
+    fileId: string;
+    keyId: string;
+    fieldId?: string;
+    contentId: string;
+    name: string;
+    fileType: string;
+    fileSize: number;
+    lastModified: number | Date;
+}
+export declare class LrRecord {
+    id: string;
+    keyId: string;
+    updateKeyId: string;
+    updateId: string;
+    name: string;
+    categories?: Category[][];
+    fields?: RecordField[];
+    attachments?: RecordAttachment[];
+    recordType: RecordTypeSummary;
+    createdOn: string | Date;
+    lastModified: string | Date;
+    isArchived: boolean;
+    myAccessLevel: AccessLevel;
+    sharedAccess: SharedAccess[];
+}
+export declare class NewAttachment {
+    fieldId?: string;
+    name: string;
+    file?: File;
+}
+export declare class NewRecord {
+    name: string;
+    recordType: RecordTypeSummary;
+    categoryIds: string[];
+    fields?: RecordField[];
+    attachments?: NewAttachment[];
+}
+export declare class NewOrUpdatedAttachment extends NewAttachment {
+    fileId?: string;
+    isDeleted?: boolean;
+}
+export declare class UpdatedRecord {
+    name: string;
+    recordType: RecordTypeSummary;
+    fields?: RecordField[];
+    attachments?: NewOrUpdatedAttachment[];
+}

package/lib/record-type/record-type.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from '@angular/common/http';
+import { RecordType } from './record-type.types';
+export declare class RecordTypeService {
+    private http;
+    private recordTypes;
+    private categories;
+    constructor(http: HttpClient);
+    getRecordTypes(): Promise<RecordType[]>;
+    getRecordType(recordTypeId: string): Promise<RecordType>;
+    getRecordTypesForCategory(categoryTree: string[]): Promise<RecordType[]>;
+}

package/lib/record-type/record-type.types.d.ts

@@ -0,0 +1,50 @@
+export declare enum RecordFieldType {
+    Text = "text",
+    Email = "email",
+    Url = "url",
+    Phone = "phone",
+    Date = "date",
+    Password = "password",
+    TextArea = "textArea",
+    Select = "select",
+    SingleChoice = "singleChoice",
+    MultiChoice = "multiChoice",
+    File = "file",
+    MultiFile = "multiFile",
+    Record = "record",
+    MultiRecord = "multiRecord",
+    Group = "group",
+    Custom = "custom"
+}
+export declare class RecordType {
+    id: string;
+    version: number;
+    name: string;
+    tags: string[];
+    allowAttachments: boolean;
+    allowCustomFields: boolean;
+    fields: RecordTypeField[];
+    categories: string[][];
+    categoryNames: string[][];
+}
+export declare class RecordTypeFieldOption {
+    name: string;
+    categories?: string[][];
+}
+export declare class RecordTypeField {
+    id: string;
+    label: string;
+    type: RecordFieldType;
+    placeholder?: string;
+    hint?: string;
+    isMandatory?: boolean;
+    options?: RecordTypeFieldOption[];
+    extensions?: string;
+    recordTypeIds?: string[];
+    fields?: RecordTypeField[];
+}
+export declare class RecordTypeSummary {
+    id: string;
+    version: number;
+    name: string;
+}

package/lib/scenario/approvals/scenario-approval.gql.d.ts

@@ -0,0 +1,7 @@
+export declare const SubAssemblyFields: string;
+export declare const CreateScenarioApproverAssemblyMutation: import("graphql").DocumentNode;
+export declare const UpdateScenarioApproverAssemblyMutation: import("graphql").DocumentNode;
+export declare const DeleteScenarioApproverAssemblyMutation: import("graphql").DocumentNode;
+export declare const GetScenarioApproverQuery: import("graphql").DocumentNode;
+export declare const AddScenarioApproverMutation: import("graphql").DocumentNode;
+export declare const UpdateScenarioApproverMutation: import("graphql").DocumentNode;

package/lib/scenario/approvals/scenario-approval.types.d.ts

@@ -0,0 +1,63 @@
+import { Receiver } from './../receivers/scenario-receiver.types';
+import { TrustedParty } from '../../trusted-parties/trusted-party.types';
+export interface ApprovalGroup {
+    id: string;
+    keyId: string;
+    name: string;
+    singleReject: boolean;
+    quorum: number;
+    approvers?: Approver[];
+}
+export interface Approver {
+    id: string;
+    keyId: string;
+    trustedParty: TrustedParty;
+    message?: string;
+}
+export interface ScenarioApproverAssemblyInput {
+    scenarioId: string;
+    keyId: string;
+    singleReject: boolean;
+    quorum: number;
+    plainAssemblyCipherData?: any;
+}
+export interface CreateSubAssemblyInput {
+    quorum: number;
+    singleReject: boolean;
+    plainSubAssemblyCipherData: any;
+}
+export interface CreateScenarioApprovalGroups {
+    scenarioId: string;
+    event: string;
+    keyId: string;
+    quorum: number;
+    singleReject: boolean;
+    plainAssemblyCipherData?: string;
+    approvalGroups: UpdateScenarioApprovalGroup[];
+    receivers?: Receiver[];
+}
+export interface UpdateScenarioApprovalGroups {
+    scenarioId: string;
+    assemblyKeyId: string;
+    quorum: number;
+    singleReject: boolean;
+    plainAssemblyCipherData?: string;
+    approvalGroups: UpdateScenarioApprovalGroup[];
+    deletedGroupIds: string[];
+}
+export interface UpdateScenarioApprovalGroup {
+    subAssemblyId?: string;
+    quorum: number;
+    singleReject: boolean;
+    plainSubAssemblyCipherData: object;
+    approvers: UpdateScenarioApprover[];
+    deletedApproverIds?: string[];
+}
+export interface UpdateScenarioApprover {
+    approverId?: string;
+    keyId?: string;
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    plainSharedCipherData: object;
+    approvalData?: string;
+}

package/lib/scenario/approvals/scenario-approver.service.d.ts

@@ -0,0 +1,32 @@
+import { LrApolloService } from '../../api/lr-apollo.service';
+import { EncryptionService } from '../../cryptography/encryption.service';
+import { KeyFactoryService } from '../../cryptography/key-factory.service';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { KeyMetaService } from '../../cryptography/key-meta.service';
+import * as slip from '../../cryptography/slip39.service';
+import { TrustedPartyService } from '../../trusted-parties/trusted-party.service';
+import { Receiver } from '../receivers/scenario-receiver.types';
+import { ApprovalGroup, Approver, CreateScenarioApprovalGroups, UpdateScenarioApprovalGroups, UpdateScenarioApprover } from './scenario-approval.types';
+export declare class ScenarioApproverService {
+    private lrApollo;
+    private keyFactory;
+    private keyMetaService;
+    private keyGraph;
+    private slip39Service;
+    private encryptionService;
+    private trustedPartyService;
+    static SLIP39_PASSPHRASE: string;
+    constructor(lrApollo: LrApolloService, keyFactory: KeyFactoryService, keyMetaService: KeyMetaService, keyGraph: KeyGraphService, slip39Service: slip.Slip39Service, encryptionService: EncryptionService, trustedPartyService: TrustedPartyService);
+    getApprover(approverId: string): Promise<Approver>;
+    mapApproverGroup(group: any): Promise<ApprovalGroup>;
+    private mapApprover;
+    updateApprover(approver: UpdateScenarioApprover): Promise<void>;
+    createScenarioApproverAssembly(input: CreateScenarioApprovalGroups): Promise<string>;
+    updateScenarioApproverAssembly(input: UpdateScenarioApprovalGroups): Promise<void>;
+    deleteScenarioApproverAssembly(scenarioId: string, event: string, receivers: Receiver[]): Promise<void>;
+    private rewrapReceivers;
+    private mapApprovalGroups;
+    private mapApprovalGroup;
+    private mapApprovers;
+    private createSlipAssembly;
+}

package/lib/scenario/claimants/scenario-claimant.gql.d.ts

@@ -0,0 +1,5 @@
+export declare const ClaimantFields: string;
+export declare const GetScenarioClaimantQuery: import("graphql").DocumentNode;
+export declare const AddScenarioClaimantMutation: import("graphql").DocumentNode;
+export declare const UpdateScenarioClaimantMutation: import("graphql").DocumentNode;
+export declare const DeleteScenarioClaimantMutation: import("graphql").DocumentNode;

package/lib/scenario/claimants/scenario-claimant.service.d.ts

@@ -0,0 +1,17 @@
+import { LrApolloService } from '../../api/lr-apollo.service';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { KeyMetaService } from '../../cryptography/key-meta.service';
+import { TrustedPartyService } from '../../trusted-parties/trusted-party.service';
+import { Claimant, AddScenarioClaimant, UpdateScenarioClaimant } from './scenario-claimant.types';
+export declare class ScenarioClaimantService {
+    private lrApollo;
+    private keyMetaService;
+    private keyGraph;
+    private tpService;
+    constructor(lrApollo: LrApolloService, keyMetaService: KeyMetaService, keyGraph: KeyGraphService, tpService: TrustedPartyService);
+    getClaimant(claimantId: string): Promise<Claimant>;
+    mapClaimant(claimant: any): Promise<Claimant>;
+    addClaimant(claimant: AddScenarioClaimant): Promise<string>;
+    updateClaimant(claimant: UpdateScenarioClaimant): Promise<string>;
+    deleteClaimant(claimantId: string): Promise<void>;
+}

package/lib/scenario/claimants/scenario-claimant.types.d.ts

@@ -0,0 +1,18 @@
+import { TrustedParty } from '../../trusted-parties/trusted-party.types';
+export interface Claimant {
+    id: string;
+    keyId: string;
+    trustedParty: TrustedParty;
+    message?: string;
+}
+export interface AddScenarioClaimant {
+    scenarioId: string;
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    plainSharedCipherData: object;
+}
+export interface UpdateScenarioClaimant {
+    id: string;
+    keyId: string;
+    plainSharedCipherData: object;
+}

package/lib/scenario/receivers/scenario-receiver.gql.d.ts

@@ -0,0 +1,8 @@
+export declare const ReceiverFields: string;
+export declare const GetScenarioReceiverQuery: import("graphql").DocumentNode;
+export declare const CreateScenarioReceiverMutation: import("graphql").DocumentNode;
+export declare const UpdateScenarioReceiverMutation: import("graphql").DocumentNode;
+export declare const DeleteScenarioReceiverMutation: import("graphql").DocumentNode;
+export declare const AddScenarioReceiverDirectoryMutation: import("graphql").DocumentNode;
+export declare const UpdateScenarioReceiverDirectoryMutation: import("graphql").DocumentNode;
+export declare const DeleteScenarioReceiverDirectoryMutation: import("graphql").DocumentNode;

package/lib/scenario/receivers/scenario-receiver.service.d.ts

@@ -0,0 +1,30 @@
+import { LrApolloService } from '../../api/lr-apollo.service';
+import { CategoryService } from '../../category/category.service';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { KeyMetaService } from '../../cryptography/key-meta.service';
+import { RecordService } from '../../record/record.service';
+import { TrustedPartyService } from '../../trusted-parties/trusted-party.service';
+import { AddScenarioReceiverCategoryInput, AddScenarioReceiverRecordInput, AddScenarioReceiver, Receiver, UpdateScenarioReceiver, UpdateScenarioReceiverItemInput } from './scenario-receiver.types';
+export declare class ScenarioReceiverService {
+    private lrApollo;
+    private keyGraph;
+    private keyMetaService;
+    private tpService;
+    private categoryService;
+    private recordService;
+    constructor(lrApollo: LrApolloService, keyGraph: KeyGraphService, keyMetaService: KeyMetaService, tpService: TrustedPartyService, categoryService: CategoryService, recordService: RecordService);
+    getReceiver(receiverId: string): Promise<Receiver>;
+    mapReceiver(receiver: any): Promise<Receiver>;
+    private mapCategories;
+    private mapRecords;
+    private mapReceiverCategory;
+    private mapReceiverRecord;
+    addReceiver(receiver: AddScenarioReceiver): Promise<string>;
+    updateReceiver(receiver: UpdateScenarioReceiver): Promise<void>;
+    deleteReceiver(receiverId: string): Promise<void>;
+    addReceiverCategory(input: AddScenarioReceiverCategoryInput): Promise<string>;
+    addReceiverRecord(input: AddScenarioReceiverRecordInput): Promise<string>;
+    private addReceiverItem;
+    updateReceiverItem(input: UpdateScenarioReceiverItemInput): Promise<void>;
+    deleteReceiverItem(receiverCategoryId: string): Promise<void>;
+}

package/lib/scenario/receivers/scenario-receiver.types.d.ts

@@ -0,0 +1,54 @@
+import { AccessLevel } from './../../category/category.types';
+import { TrustedParty } from '../../trusted-parties/trusted-party.types';
+import { Category, VaultRecord } from '../../category/category.types';
+export interface Receiver {
+    id: string;
+    keyId: string;
+    trustedParty: TrustedParty;
+    message?: string;
+    categories: ReceiverCategory[];
+    records?: ReceiverRecord[];
+}
+export interface ReceiverCategory {
+    id: string;
+    keyId: string;
+    accessLevel: AccessLevel;
+    category: Category;
+}
+export interface ReceiverRecord {
+    id: string;
+    keyId: string;
+    accessLevel: AccessLevel;
+    record: VaultRecord;
+}
+export interface AddScenarioReceiver {
+    scenarioId: string;
+    trustedPartyId: string;
+    trustedPartySharedKeyId: string;
+    plainSharedCipherData: object;
+}
+export interface UpdateScenarioReceiver {
+    id: string;
+    keyId: string;
+    plainSharedCipherData: object;
+}
+export interface AddScenarioReceiverItemInput {
+    scenarioId: string;
+    assemblyKeyId?: string;
+    receiverId: string;
+    receiverKeyId: string;
+    accessRole: AccessLevel;
+    plainSharedCipherData?: string;
+}
+export interface AddScenarioReceiverCategoryInput extends AddScenarioReceiverItemInput {
+    categoryId: string;
+}
+export interface AddScenarioReceiverRecordInput extends AddScenarioReceiverItemInput {
+    recordId: string;
+}
+export interface UpdateScenarioReceiverItemInput {
+    id: string;
+    keyId: string;
+    accessRole: AccessLevel;
+    plainSharedCipherData?: string;
+}

package/lib/scenario/scenario-setup.service.d.ts

@@ -0,0 +1,22 @@
+import { LrException } from './../_common/exceptions';
+import { ScenarioApproverService } from './approvals/scenario-approver.service';
+import { ScenarioClaimantService } from './claimants/scenario-claimant.service';
+import { ScenarioReceiverService } from './receivers/scenario-receiver.service';
+import { ScenarioService } from './scenario.service';
+import { NewScenario, UpdateScenario } from './scenario.types';
+export declare class ScenarioSetupService {
+    private scenarioService;
+    private scenarioClaimantService;
+    private scenarioApproverService;
+    private scenarioReceiverService;
+    constructor(scenarioService: ScenarioService, scenarioClaimantService: ScenarioClaimantService, scenarioApproverService: ScenarioApproverService, scenarioReceiverService: ScenarioReceiverService);
+    setupScenario(newScenario: NewScenario): Promise<{
+        scenarioId: string;
+        error?: LrException;
+    }>;
+    updateScenario(updateScenario: UpdateScenario): Promise<void>;
+    private updateClaimant;
+    private updateApprovalGroups;
+    private updateReceiver;
+    private updateReceiverItems;
+}

package/lib/scenario/scenario.gql.d.ts

@@ -0,0 +1,34 @@
+import { ID } from '../api/types';
+export declare const GetSharedScenarioQuery: import("graphql").DocumentNode;
+export declare const GetAllSharedScenariosQuery: import("graphql").DocumentNode;
+export declare const GetTrustedPartyScenariosQuery: import("graphql").DocumentNode;
+export declare const GetAllScenarioIdsQuery: import("graphql").DocumentNode;
+export declare const GetAllScenariosQuery: import("graphql").DocumentNode;
+export declare const GetScenarioQuery: import("graphql").DocumentNode;
+export declare const GetAllScenarioClaimsQuery: import("graphql").DocumentNode;
+export declare const CreateScenarioMutation: import("graphql").DocumentNode;
+export declare const UpdateScenarioMutation: import("graphql").DocumentNode;
+export declare const DeleteScenarioMutation: import("graphql").DocumentNode;
+export declare const EnableScenarioMutation: import("graphql").DocumentNode;
+export declare const DisableScenarioMutation: import("graphql").DocumentNode;
+export declare const CreateScenarioClaimMutation: import("graphql").DocumentNode;
+export declare const CancelScenarioClaimMutation: import("graphql").DocumentNode;
+export interface ApproveScenarioClaimMutationResult {
+    approveScenarioClaim: {
+        sharedClaim: {
+            id: ID;
+        };
+    };
+}
+export declare const ApproveScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<ApproveScenarioClaimMutationResult>;
+export interface RejectScenarioClaimMutationResult {
+    rejectScenarioClaim: {
+        sharedClaim: {
+            id: ID;
+        };
+    };
+}
+export declare const RejectScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<RejectScenarioClaimMutationResult>;
+export declare const ReceiveScenarioClaimMutation: import("graphql").DocumentNode;
+export declare const ResetScenarioMutation: import("graphql").DocumentNode;
+export declare const UpdateScenarioApproverSubAssemblyMutation: import("graphql").DocumentNode;

package/lib/scenario/scenario.service.d.ts

@@ -0,0 +1,58 @@
+import { LrApolloService } from '../api/lr-apollo.service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { KeyService } from '../cryptography/key.service';
+import * as slip from '../cryptography/slip39.service';
+import { TrustedPartyService } from '../trusted-parties/trusted-party.service';
+import { ScenarioApproverService } from './approvals/scenario-approver.service';
+import { ScenarioClaimantService } from './claimants/scenario-claimant.service';
+import { ScenarioReceiverService } from './receivers/scenario-receiver.service';
+import { CreateScenarioInput, Scenario, ScenarioClaim, ScenarioSummary, SharedScenario, UpdateScenarioInput, SharedScenarioSummary } from './scenario.types';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+import { LrGraphQLService, LrMergedMutation } from '../api/lr-graphql';
+export declare class ScenarioService {
+    private lrApollo;
+    private keyMetaService;
+    private keyFactory;
+    private keyService;
+    private encryptionService;
+    private keyGraph;
+    private tpService;
+    private slip39Service;
+    private scenarioClaimantService;
+    private scenarioApproverService;
+    private scenarioReceiverService;
+    private lrGraphQL;
+    constructor(lrApollo: LrApolloService, keyMetaService: KeyMetaService, keyFactory: KFS, keyService: KeyService, encryptionService: EncryptionService, keyGraph: KeyGraphService, tpService: TrustedPartyService, slip39Service: slip.Slip39Service, scenarioClaimantService: ScenarioClaimantService, scenarioApproverService: ScenarioApproverService, scenarioReceiverService: ScenarioReceiverService, lrGraphQL: LrGraphQLService);
+    getMyScenarios(): Promise<ScenarioSummary[]>;
+    private mapScenarioSummary;
+    getSharedScenarios(): Promise<SharedScenarioSummary[]>;
+    private mapSharedScenarioSummary;
+    getSharedScenario(scenarioId: string): Promise<SharedScenario>;
+    private mapSharedScenario;
+    getTrustedPartyScenarios(trustedPartyId: string): Promise<{
+        myScenarios: ScenarioSummary[];
+        sharedScenarios: SharedScenario[];
+    }>;
+    getScenarioClaims(): Promise<ScenarioClaim[]>;
+    private getCipherData;
+    private getApproverKey;
+    getScenario(scenarioId: string): Promise<Scenario>;
+    private mapScenario;
+    createScenario(input: CreateScenarioInput): Promise<string>;
+    updateScenario(input: UpdateScenarioInput): Promise<void>;
+    enableScenario(scenarioId: string): Promise<void>;
+    disableScenario(scenarioId: string): Promise<void>;
+    deleteScenario(scenarioId: string): Promise<void>;
+    createClaim(scenarioId: string): Promise<string>;
+    cancelClaim(claimId: string): Promise<void>;
+    approveClaim(scenarioId: string, claimId: string): Promise<any>;
+    approveClaimMutation(scenarioId: string, claimId: string): Promise<LrMergedMutation<any[]>>;
+    rejectClaim(scenarioId: string, claimId: string): Promise<any>;
+    rejectClaimMutation(scenarioId: string, claimId: string): Promise<LrMergedMutation<any[]>>;
+    receiveClaim(scenarioId: string, claimId: string): Promise<void>;
+    private getClaimAssemblyKey;
+    resetScenario(scenarioId: string, disable?: boolean): Promise<void>;
+    getAllScenarioIds(): Promise<string[]>;
+}