@lifeready/core 0.6.0-beta.1

package/esm2015/lib/api/shared-contact-card2.service.js

@@ -0,0 +1,117 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { LrGraphQLService, LrMutation } from './lr-graphql';
+import { GetOwnedContactCardKeyIdsQuery, GetReceivedContactCardKeyIdQuery, UpdateOwnedContactCardMutation, UpdateReceivedContactCardMutation, } from './shared-contact-card2.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key.service";
+import * as i2 from "../cryptography/key-graph.service";
+import * as i3 from "../cryptography/encryption.service";
+import * as i4 from "./lr-graphql/lr-graphql.service";
+let SharedContactCard2Service = class SharedContactCard2Service {
+    constructor(ngZone, keyService, keyGraph, encryptionService, lrGraphQL) {
+        this.ngZone = ngZone;
+        this.keyService = keyService;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+        this.lrGraphQL = lrGraphQL;
+    }
+    getOwnedContactCardKeyIds(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { ownedContactCard: cc } = yield this.lrGraphQL.query({
+                query: GetOwnedContactCardKeyIdsQuery,
+                variables: {
+                    id,
+                },
+            });
+            return {
+                sharedKeyId: cc.sharedKey.id,
+                ownerKeyId: cc.ownerKey.id,
+            };
+        });
+    }
+    getReceivedContactCardKeyId(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.lrGraphQL.query({
+                query: GetReceivedContactCardKeyIdQuery,
+                variables: {
+                    id,
+                },
+            })).receivedContactCard.receiverKey.id;
+        });
+    }
+    updateOwnedContactCard({ id, ownerKeyId, sharedKeyId, ownerPlainDataJson, ownerCipherDataClearJson, sharedCipherDataClearJson, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ownerKey;
+            let sharedKey;
+            try {
+                ownerKey = yield this.keyGraph.getKey(ownerKeyId);
+                sharedKey = yield this.keyGraph.getKey(sharedKeyId);
+            }
+            catch (error) {
+                const keys = yield this.getOwnedContactCardKeyIds(id);
+                // try again
+                ownerKey = yield this.keyGraph.getKey(keys.ownerKeyId);
+                sharedKey = yield this.keyGraph.getKey(keys.sharedKeyId);
+            }
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const sharedCipherData = yield this.encryptionService.encrypt(sharedKey.jwk, sharedCipherDataClearJson);
+            const sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+            const ownerPlainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, ownerPlainDataJson));
+            const ownerCipherData = yield this.encryptionService.encryptToString(ownerKey.jwk, ownerCipherDataClearJson);
+            return new LrMutation({
+                mutation: UpdateOwnedContactCardMutation,
+                variables: {
+                    input: {
+                        id,
+                        ownerCipherData,
+                        ownerKeyId: ownerKey.id,
+                        sharedCipherDataSig,
+                        sharedKeyId: sharedKey.id,
+                        sigPxkId: sigPxk.id,
+                        ownerPlainDataSig,
+                    },
+                },
+            });
+        });
+    }
+    updateReceivedContactCard({ id, receiverKeyId, receiverCipherDataClearJson, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const receiverKey = yield this.keyGraph.getKey(receiverKeyId, () => this.getReceivedContactCardKeyId(id));
+            const receiverCipherData = yield this.encryptionService.encryptToString(receiverKey.jwk, receiverCipherDataClearJson);
+            return new LrMutation({
+                mutation: UpdateReceivedContactCardMutation,
+                variables: {
+                    input: {
+                        id,
+                        receiverCipherData,
+                        receiverKeyId: receiverKey.id,
+                    },
+                },
+            });
+        });
+    }
+};
+SharedContactCard2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedContactCard2Service_Factory() { return new SharedContactCard2Service(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.KeyService), i0.ɵɵinject(i2.KeyGraphService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.LrGraphQLService)); }, token: SharedContactCard2Service, providedIn: "root" });
+SharedContactCard2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+SharedContactCard2Service.ctorParameters = () => [
+    { type: NgZone },
+    { type: KeyService },
+    { type: KeyGraphService },
+    { type: EncryptionService },
+    { type: LrGraphQLService }
+];
+SharedContactCard2Service = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], SharedContactCard2Service);
+export { SharedContactCard2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-contact-card2.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/shared-contact-card2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { Key } from '../cryptography/cryptography.types';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\nimport {\r\n  ContactCardReceiverCipherData,\r\n  SendContactCardInput,\r\n} from './key-exchange2.service';\r\nimport { LrGraphQLService, LrMutation } from './lr-graphql';\r\nimport {\r\n  GetOwnedContactCardKeyIdsQuery,\r\n  GetReceivedContactCardKeyIdQuery,\r\n  UpdateOwnedContactCardMutation,\r\n  UpdateReceivedContactCardMutation,\r\n} from './shared-contact-card2.gql';\r\nimport { LrRelayIdInput } from './types';\r\n\r\nexport interface UpdateOwnedContactCardInput extends SendContactCardInput {\r\n  id: LrRelayIdInput;\r\n  ownerKeyId?: LrRelayIdInput;\r\n  sharedKeyId?: LrRelayIdInput;\r\n}\r\n\r\nexport interface UpdateReceivedContactCardInput\r\n  extends ContactCardReceiverCipherData {\r\n  id: LrRelayIdInput;\r\n  receiverKeyId?: LrRelayIdInput;\r\n}\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SharedContactCard2Service {\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private keyService: KeyService,\r\n    private keyGraph: KeyGraphService,\r\n    private encryptionService: EncryptionService,\r\n    private lrGraphQL: LrGraphQLService\r\n  ) {}\r\n\r\n  private async getOwnedContactCardKeyIds(id: LrRelayIdInput) {\r\n    const { ownedContactCard: cc } = await this.lrGraphQL.query({\r\n      query: GetOwnedContactCardKeyIdsQuery,\r\n      variables: {\r\n        id,\r\n      },\r\n    });\r\n\r\n    return {\r\n      sharedKeyId: cc.sharedKey.id,\r\n      ownerKeyId: cc.ownerKey.id,\r\n    };\r\n  }\r\n\r\n  private async getReceivedContactCardKeyId(id: LrRelayIdInput) {\r\n    return (\r\n      await this.lrGraphQL.query({\r\n        query: GetReceivedContactCardKeyIdQuery,\r\n        variables: {\r\n          id,\r\n        },\r\n      })\r\n    ).receivedContactCard.receiverKey.id;\r\n  }\r\n\r\n  async updateOwnedContactCard({\r\n    id,\r\n    ownerKeyId,\r\n    sharedKeyId,\r\n    ownerPlainDataJson,\r\n    ownerCipherDataClearJson,\r\n    sharedCipherDataClearJson,\r\n  }: UpdateOwnedContactCardInput) {\r\n    let ownerKey: Key;\r\n    let sharedKey: Key;\r\n\r\n    try {\r\n      ownerKey = await this.keyGraph.getKey(ownerKeyId);\r\n      sharedKey = await this.keyGraph.getKey(sharedKeyId);\r\n    } catch (error) {\r\n      const keys = await this.getOwnedContactCardKeyIds(id);\r\n\r\n      // try again\r\n      ownerKey = await this.keyGraph.getKey(keys.ownerKeyId);\r\n      sharedKey = await this.keyGraph.getKey(keys.sharedKeyId);\r\n    }\r\n\r\n    const sigPxk = await this.keyService.getCurrentSigPxk();\r\n\r\n    const sharedCipherData = await this.encryptionService.encrypt(\r\n      sharedKey.jwk,\r\n      sharedCipherDataClearJson\r\n    );\r\n    const sharedCipherDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\r\n    );\r\n\r\n    const ownerPlainDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, ownerPlainDataJson)\r\n    );\r\n\r\n    const ownerCipherData = await this.encryptionService.encryptToString(\r\n      ownerKey.jwk,\r\n      ownerCipherDataClearJson\r\n    );\r\n\r\n    return new LrMutation({\r\n      mutation: UpdateOwnedContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          id,\r\n          ownerCipherData,\r\n          ownerKeyId: ownerKey.id,\r\n          sharedCipherDataSig,\r\n          sharedKeyId: sharedKey.id,\r\n          sigPxkId: sigPxk.id,\r\n          ownerPlainDataSig,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  async updateReceivedContactCard({\r\n    id,\r\n    receiverKeyId,\r\n    receiverCipherDataClearJson,\r\n  }: UpdateReceivedContactCardInput) {\r\n    const receiverKey = await this.keyGraph.getKey(receiverKeyId, () =>\r\n      this.getReceivedContactCardKeyId(id)\r\n    );\r\n\r\n    const receiverCipherData = await this.encryptionService.encryptToString(\r\n      receiverKey.jwk,\r\n      receiverCipherDataClearJson\r\n    );\r\n\r\n    return new LrMutation({\r\n      mutation: UpdateReceivedContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          id,\r\n          receiverCipherData,\r\n          receiverKeyId: receiverKey.id,\r\n        },\r\n      },\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/time.service.js

@@ -0,0 +1,146 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { Apollo } from 'apollo-angular';
+import gql from 'graphql-tag';
+import * as moment_ from 'moment';
+import { LrErrorCode, LrException, handleApolloError, } from '../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "@aws-amplify/auth/lib-esm/Auth";
+import * as i2 from "apollo-angular";
+// "why?" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment
+const moment = moment_;
+export const ServerTimeQuery = gql `
+  query {
+    serverTime {
+      timestamp
+    }
+  }
+`;
+export class TimeService {
+    constructor(auth, apollo) {
+        this.auth = auth;
+        this.apollo = apollo;
+        this.VERIFY_ENABLED = true;
+        this.MAX_DIFF_MSEC = moment
+            .duration({ seconds: 30 })
+            .asMilliseconds();
+        this.offsetMs = null; // Millisecond offset of local clock.
+        this.verified = false; // Verified with independent time source
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (yield this.auth.currentAuthenticatedUser())
+                    .getSignInUserSession()
+                    .getAccessToken()
+                    .getJwtToken();
+            }
+            catch (error) {
+                return ''; // Not authenticated
+            }
+        });
+    }
+    // Get time from independent source to confirm.
+    verifyCognito() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accessToken = yield this.getAccessToken();
+            if (!accessToken) {
+                return;
+            }
+            // Request headers from AWS Amplify Auth lib
+            // accept: */*
+            // accept-encoding: gzip, deflate, br
+            // accept-language: en-GB,en-US;q=0.9,en;q=0.8
+            // cache-control: no-cache
+            // content-length: 1089
+            // content-type: application/x-amz-json-1.1
+            // origin: http://localhost:4200
+            // pragma: no-cache
+            // referer: http://localhost:4200/
+            // sec-fetch-dest: empty
+            // sec-fetch-mode: cors
+            // sec-fetch-site: cross-site
+            // user-agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36
+            // x-amz-target: AWSCognitoIdentityProviderService.GetUser
+            // x-amz-user-agent: aws-amplify/0.1.x js
+            // We are only interested in the Date field.
+            // AZ: I suppose we could use any end-point that provides a reliable Date field in the header. And we don't
+            // need to be authenticated. Even a 400 response would have a Date header. But the worry is that AWS might
+            // think it's some sort of attack, and block the IP or domain. At least in an authenticated call it can't be
+            // seen as illegitimate.
+            const response = yield fetch('https://cognito-idp.ap-southeast-2.amazonaws.com/', {
+                method: 'POST',
+                mode: 'cors',
+                cache: 'no-cache',
+                headers: {
+                    'x-amz-target': 'AWSCognitoIdentityProviderService.GetUser',
+                    'x-amz-user-agent': 'aws-amplify/0.1.x js',
+                    'Content-Type': 'application/x-amz-json-1.1',
+                },
+                // redirect: 'follow', // manual, *follow, error
+                // referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url
+                body: JSON.stringify({
+                    AccessToken: accessToken,
+                }),
+            });
+            const now = Date.now();
+            const verifyTime = moment(response.headers.get('Date')).valueOf();
+            const serverTime = now + this.offsetMs;
+            const diff = Math.abs(serverTime - verifyTime);
+            if (diff > this.MAX_DIFF_MSEC) {
+                throw new LrException({
+                    code: LrErrorCode.BadTimeSync,
+                    message: `Server time does not match independent source. ServerTime: ${serverTime}, Cognito time: ${verifyTime}`,
+                });
+            }
+            this.verified = true;
+        });
+    }
+    refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const start = Date.now();
+            const res = yield this.apollo
+                .query({ query: ServerTimeQuery })
+                .toPromise();
+            const end = Date.now();
+            handleApolloError(res.errors);
+            const serverTime = parseInt(res.data.serverTime.timestamp, 10);
+            const roundtrip = end - start;
+            this.offsetMs = serverTime - (start + roundtrip / 2);
+            if (this.VERIFY_ENABLED) {
+                yield this.verifyCognito();
+            }
+        });
+    }
+    serverNow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let needsRefresh = false;
+            // First call
+            if (this.offsetMs === null) {
+                needsRefresh = true;
+            }
+            if (this.VERIFY_ENABLED) {
+                // logged in but not yet verified time matches.
+                if (!this.verified && (yield this.getAccessToken())) {
+                    needsRefresh = true;
+                }
+            }
+            if (needsRefresh) {
+                yield this.refresh();
+            }
+            return Date.now() + this.offsetMs;
+        });
+    }
+}
+TimeService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TimeService_Factory() { return new TimeService(i0.ɵɵinject(i1.AuthClass), i0.ɵɵinject(i2.Apollo)); }, token: TimeService, providedIn: "root" });
+TimeService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TimeService.ctorParameters = () => [
+    { type: AuthClass },
+    { type: Apollo }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/time.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\nimport { Apollo } from 'apollo-angular';\r\nimport gql from 'graphql-tag';\r\nimport * as moment_ from 'moment';\r\nimport {\r\n  LrErrorCode,\r\n  LrException,\r\n  handleApolloError,\r\n} from '../_common/exceptions';\r\n// \"why?\" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment\r\nconst moment = moment_;\r\n\r\nexport const ServerTimeQuery = gql`\r\n  query {\r\n    serverTime {\r\n      timestamp\r\n    }\r\n  }\r\n`;\r\n\r\ninterface ServerTime {\r\n  timestamp: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TimeService {\r\n  public VERIFY_ENABLED = true;\r\n  private readonly MAX_DIFF_MSEC = moment\r\n    .duration({ seconds: 30 })\r\n    .asMilliseconds();\r\n\r\n  offsetMs: number = null; // Millisecond offset of local clock.\r\n  verified = false; // Verified with independent time source\r\n\r\n  constructor(private auth: AuthClass, private apollo: Apollo) {}\r\n\r\n  private async getAccessToken(): Promise<string> {\r\n    try {\r\n      return (await this.auth.currentAuthenticatedUser())\r\n        .getSignInUserSession()\r\n        .getAccessToken()\r\n        .getJwtToken();\r\n    } catch (error) {\r\n      return ''; // Not authenticated\r\n    }\r\n  }\r\n\r\n  // Get time from independent source to confirm.\r\n  private async verifyCognito(): Promise<void> {\r\n    const accessToken = await this.getAccessToken();\r\n    if (!accessToken) {\r\n      return;\r\n    }\r\n\r\n    // Request headers from AWS Amplify Auth lib\r\n    // accept: */*\r\n    // accept-encoding: gzip, deflate, br\r\n    // accept-language: en-GB,en-US;q=0.9,en;q=0.8\r\n    // cache-control: no-cache\r\n    // content-length: 1089\r\n    // content-type: application/x-amz-json-1.1\r\n    // origin: http://localhost:4200\r\n    // pragma: no-cache\r\n    // referer: http://localhost:4200/\r\n    // sec-fetch-dest: empty\r\n    // sec-fetch-mode: cors\r\n    // sec-fetch-site: cross-site\r\n    // user-agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36\r\n    // x-amz-target: AWSCognitoIdentityProviderService.GetUser\r\n    // x-amz-user-agent: aws-amplify/0.1.x js\r\n\r\n    // We are only interested in the Date field.\r\n    // AZ: I suppose we could use any end-point that provides a reliable Date field in the header. And we don't\r\n    // need to be authenticated. Even a 400 response would have a Date header. But the worry is that AWS might\r\n    // think it's some sort of attack, and block the IP or domain. At least in an authenticated call it can't be\r\n    // seen as illegitimate.\r\n    const response = await fetch(\r\n      'https://cognito-idp.ap-southeast-2.amazonaws.com/',\r\n      {\r\n        method: 'POST', // *GET, POST, PUT, DELETE, etc.\r\n        mode: 'cors', // no-cors, *cors, same-origin\r\n        cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached\r\n        headers: {\r\n          'x-amz-target': 'AWSCognitoIdentityProviderService.GetUser',\r\n          'x-amz-user-agent': 'aws-amplify/0.1.x js',\r\n          'Content-Type': 'application/x-amz-json-1.1',\r\n        },\r\n        // redirect: 'follow', // manual, *follow, error\r\n        // referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url\r\n        body: JSON.stringify({\r\n          AccessToken: accessToken,\r\n        }), // body data type must match \"Content-Type\" header\r\n      }\r\n    );\r\n\r\n    const now = Date.now();\r\n\r\n    const verifyTime = moment(response.headers.get('Date')).valueOf();\r\n    const serverTime = now + this.offsetMs;\r\n    const diff = Math.abs(serverTime - verifyTime);\r\n\r\n    if (diff > this.MAX_DIFF_MSEC) {\r\n      throw new LrException({\r\n        code: LrErrorCode.BadTimeSync,\r\n        message: `Server time does not match independent source. ServerTime: ${serverTime}, Cognito time: ${verifyTime}`,\r\n      });\r\n    }\r\n\r\n    this.verified = true;\r\n  }\r\n\r\n  private async refresh(): Promise<void> {\r\n    const start = Date.now();\r\n    const res = await this.apollo\r\n      .query<{ serverTime: ServerTime }>({ query: ServerTimeQuery })\r\n      .toPromise();\r\n    const end = Date.now();\r\n\r\n    handleApolloError(res.errors);\r\n\r\n    const serverTime = parseInt(res.data.serverTime.timestamp, 10);\r\n\r\n    const roundtrip = end - start;\r\n    this.offsetMs = serverTime - (start + roundtrip / 2);\r\n\r\n    if (this.VERIFY_ENABLED) {\r\n      await this.verifyCognito();\r\n    }\r\n  }\r\n\r\n  async serverNow(): Promise<number> {\r\n    let needsRefresh = false;\r\n\r\n    // First call\r\n    if (this.offsetMs === null) {\r\n      needsRefresh = true;\r\n    }\r\n\r\n    if (this.VERIFY_ENABLED) {\r\n      // logged in but not yet verified time matches.\r\n      if (!this.verified && (await this.getAccessToken())) {\r\n        needsRefresh = true;\r\n      }\r\n    }\r\n\r\n    if (needsRefresh) {\r\n      await this.refresh();\r\n    }\r\n\r\n    return Date.now() + this.offsetMs;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/types/graphql.types.js

@@ -0,0 +1,7 @@
+// ------------------------------------------------------
+// Basic types
+// ------------------------------------------------------
+// These types map directory to types of the same name in graphql.
+// We use these aliases in case in the future we wish to reify the types and do
+// additional automated conversion.
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/types/index.js

@@ -0,0 +1,3 @@
+export * from './graphql.types';
+export * from './lr-graphql.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVjdHMvdGVzdC9wcm9qZWN0cy9jb3JlL3NyYy8iLCJzb3VyY2VzIjpbImxpYi9hcGkvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ncmFwaHFsLnR5cGVzJztcclxuZXhwb3J0ICogZnJvbSAnLi9sci1ncmFwaHFsLnR5cGVzJztcclxuIl19

package/esm2015/lib/api/types/lr-graphql.types.js

@@ -0,0 +1,71 @@
+export var AccessRoleChoice;
+(function (AccessRoleChoice) {
+    AccessRoleChoice["READER"] = "READER";
+    AccessRoleChoice["WRITER"] = "WRITER";
+    AccessRoleChoice["ADMIN"] = "ADMIN";
+    AccessRoleChoice["DENY"] = "DENY";
+    AccessRoleChoice["OWNER"] = "OWNER";
+})(AccessRoleChoice || (AccessRoleChoice = {}));
+export var AccessRoleMethod;
+(function (AccessRoleMethod) {
+    AccessRoleMethod["inherited"] = "inherited";
+    AccessRoleMethod["direct"] = "direct";
+})(AccessRoleMethod || (AccessRoleMethod = {}));
+export var FileVersionOperation;
+(function (FileVersionOperation) {
+    FileVersionOperation["CREATE"] = "CREATE";
+    FileVersionOperation["READ"] = "READ";
+    FileVersionOperation["UPDATE"] = "UPDATE";
+    FileVersionOperation["REVERT"] = "REVERT";
+    FileVersionOperation["DELETE"] = "DELETE";
+})(FileVersionOperation || (FileVersionOperation = {}));
+export var KeyExchangeOtkState;
+(function (KeyExchangeOtkState) {
+    KeyExchangeOtkState["OTK_INITIATED"] = "OTK_INITIATED";
+    KeyExchangeOtkState["OTK_ACCEPTED"] = "OTK_ACCEPTED";
+    KeyExchangeOtkState["OTK_COMPLETED"] = "OTK_COMPLETED";
+})(KeyExchangeOtkState || (KeyExchangeOtkState = {}));
+export var KeyExchangeState;
+(function (KeyExchangeState) {
+    KeyExchangeState["IN_PROGRESS"] = "IN_PROGRESS";
+    KeyExchangeState["COMPLETED"] = "COMPLETED";
+    KeyExchangeState["DECLINED"] = "DECLINED";
+    KeyExchangeState["CANCELLED"] = "CANCELLED";
+    KeyExchangeState["DELETED"] = "DELETED";
+})(KeyExchangeState || (KeyExchangeState = {}));
+export var KeyExchangeMode;
+(function (KeyExchangeMode) {
+    KeyExchangeMode["OTK"] = "OTK";
+})(KeyExchangeMode || (KeyExchangeMode = {}));
+export var TpAssemblyState;
+(function (TpAssemblyState) {
+    TpAssemblyState["DISABLED"] = "DISABLED";
+    TpAssemblyState["ENABLED"] = "ENABLED";
+    TpAssemblyState["CLAIMED"] = "CLAIMED";
+    TpAssemblyState["APPROVED"] = "APPROVED";
+    TpAssemblyState["REJECTED"] = "REJECTED";
+    TpAssemblyState["EXPIRED"] = "EXPIRED";
+    TpAssemblyState["CANCELLED"] = "CANCELLED";
+    TpAssemblyState["RESET"] = "RESET";
+})(TpAssemblyState || (TpAssemblyState = {}));
+export var TpClaimState;
+(function (TpClaimState) {
+    TpClaimState["CLAIMED"] = "CLAIMED";
+    TpClaimState["APPROVED"] = "APPROVED";
+    TpClaimState["REJECTED"] = "REJECTED";
+    TpClaimState["EXPIRED"] = "EXPIRED";
+    TpClaimState["CANCELLED"] = "CANCELLED";
+    TpClaimState["RESET"] = "RESET";
+})(TpClaimState || (TpClaimState = {}));
+export var TpClaimApproverState;
+(function (TpClaimApproverState) {
+    TpClaimApproverState["CLAIMED"] = "CLAIMED";
+    TpClaimApproverState["APPROVED"] = "APPROVED";
+    TpClaimApproverState["REJECTED"] = "REJECTED";
+})(TpClaimApproverState || (TpClaimApproverState = {}));
+export var LockState;
+(function (LockState) {
+    LockState["UNLOCKED"] = "UNLOCKED";
+    LockState["MUTEX_LOCKED"] = "MUTEX_LOCKED";
+})(LockState || (LockState = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lr-graphql.types.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/types/lr-graphql.types.ts"],"names":[],"mappings":"AA+HA,MAAM,CAAN,IAAY,gBAMX;AAND,WAAY,gBAAgB;IAC1B,qCAAiB,CAAA;IACjB,qCAAiB,CAAA;IACjB,mCAAe,CAAA;IACf,iCAAa,CAAA;IACb,mCAAe,CAAA;AACjB,CAAC,EANW,gBAAgB,KAAhB,gBAAgB,QAM3B;AAED,MAAM,CAAN,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,2CAAuB,CAAA;IACvB,qCAAiB,CAAA;AACnB,CAAC,EAHW,gBAAgB,KAAhB,gBAAgB,QAG3B;AAYD,MAAM,CAAN,IAAY,oBAMX;AAND,WAAY,oBAAoB;IAC9B,yCAAiB,CAAA;IACjB,qCAAa,CAAA;IACb,yCAAiB,CAAA;IACjB,yCAAiB,CAAA;IACjB,yCAAiB,CAAA;AACnB,CAAC,EANW,oBAAoB,KAApB,oBAAoB,QAM/B;AAkBD,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC7B,sDAA+B,CAAA;IAC/B,oDAA6B,CAAA;IAC7B,sDAA+B,CAAA;AACjC,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAoCD,MAAM,CAAN,IAAY,gBAMX;AAND,WAAY,gBAAgB;IAC1B,+CAA2B,CAAA;IAC3B,2CAAuB,CAAA;IACvB,yCAAqB,CAAA;IACrB,2CAAuB,CAAA;IACvB,uCAAmB,CAAA;AACrB,CAAC,EANW,gBAAgB,KAAhB,gBAAgB,QAM3B;AAED,MAAM,CAAN,IAAY,eAEX;AAFD,WAAY,eAAe;IACzB,8BAAW,CAAA;AACb,CAAC,EAFW,eAAe,KAAf,eAAe,QAE1B;AAoFD,MAAM,CAAN,IAAY,eASX;AATD,WAAY,eAAe;IACzB,wCAAqB,CAAA;IACrB,sCAAmB,CAAA;IACnB,sCAAmB,CAAA;IACnB,wCAAqB,CAAA;IACrB,wCAAqB,CAAA;IACrB,sCAAmB,CAAA;IACnB,0CAAuB,CAAA;IACvB,kCAAe,CAAA;AACjB,CAAC,EATW,eAAe,KAAf,eAAe,QAS1B;AAED,MAAM,CAAN,IAAY,YAOX;AAPD,WAAY,YAAY;IACtB,mCAAmB,CAAA;IACnB,qCAAqB,CAAA;IACrB,qCAAqB,CAAA;IACrB,mCAAmB,CAAA;IACnB,uCAAuB,CAAA;IACvB,+BAAe,CAAA;AACjB,CAAC,EAPW,YAAY,KAAZ,YAAY,QAOvB;AAED,MAAM,CAAN,IAAY,oBAIX;AAJD,WAAY,oBAAoB;IAC9B,2CAAmB,CAAA;IACnB,6CAAqB,CAAA;IACrB,6CAAqB,CAAA;AACvB,CAAC,EAJW,oBAAoB,KAApB,oBAAoB,QAI/B;AAmID,MAAM,CAAN,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,kCAAqB,CAAA;IACrB,0CAA6B,CAAA;AAC/B,CAAC,EAHW,SAAS,KAAT,SAAS,QAGpB","sourcesContent":["import { Time } from '@angular/common';\r\nimport {\r\n  Connection,\r\n  DateTime,\r\n  GenericScalar,\r\n  ID,\r\n  JSONString,\r\n  LrEmail,\r\n  Node,\r\n  TimeStamped,\r\n} from './graphql.types';\r\n\r\n// TODO: fill these types\r\nexport type UserStripeNode = any;\r\nexport type UserPlanNode = any;\r\nexport type UserDeleteNode = any;\r\nexport type FeaturesNode = any;\r\nexport type ScenarioNode = any;\r\nexport type SharedScenarioNode = any;\r\n\r\nexport type TpPasswordResetRequestNode = any;\r\n\r\nexport interface PassKeyNode extends Node, TimeStamped {\r\n  passKeyParams?: GenericScalar;\r\n  passIdpParams?: GenericScalar;\r\n  wrappedPassIdpVerifierPrk?: GenericScalar;\r\n}\r\n\r\nexport interface CurrentUserKeyNode extends Node, TimeStamped {\r\n  passKeys?: PassKeyNode[];\r\n  passKey?: PassKeyNode;\r\n  rootKey?: KeyNode;\r\n  masterKey?: KeyNode;\r\n  pxk?: KeyNode;\r\n  sigPxk?: KeyNode;\r\n}\r\n\r\n// ------------------------------------------------------\r\n// Node types\r\n// ------------------------------------------------------\r\nexport interface UserNode extends Node {\r\n  username?: string;\r\n  contactCards?: Connection<ContactCardNode>;\r\n  currentUserKey?: CurrentUserKeyNode;\r\n  ownedContactCard?: SharedContactCardNode;\r\n  receivedContactCard?: SharedContactCardNode;\r\n  isCurrentUser?: boolean;\r\n  haveTp?: boolean;\r\n  stripe?: UserStripeNode;\r\n  userPlans?: Connection<UserPlanNode>;\r\n  userDelete?: UserDeleteNode;\r\n  features?: FeaturesNode;\r\n}\r\n\r\nexport interface ServerTime {\r\n  timestamp?: string;\r\n}\r\n\r\nexport interface KeyNode extends Node, TimeStamped {\r\n  pbk?: string;\r\n}\r\n\r\nexport interface ContactCardNode extends Node, TimeStamped {\r\n  owner?: UserNode;\r\n  publicDataSig?: string;\r\n  publicSearchableSig?: string;\r\n  sigPxk?: KeyNode;\r\n  defaultFrom?: DateTime;\r\n  publicData?: string;\r\n  publicSearchable?: string;\r\n  cipherData?: string;\r\n  cipherDataClearJson?: any;\r\n  key?: KeyNode;\r\n  plainData?: string;\r\n  plainDataSig?: string;\r\n}\r\n\r\nexport interface DirectoryNode extends Node, TimeStamped {\r\n  plainMeta?: JSONString;\r\n  plainMetaJson?: any;\r\n  cipherMeta?: string;\r\n  cipherMetaClearJson?: any;\r\n  archived?: boolean;\r\n  keyId?: ID;\r\n  childFileLinks?: Connection<FileLinkNode>;\r\n  childDirectoryLinks?: Connection<DirectoryLinkNode>;\r\n  parentDirectoryLinks?: Connection<DirectoryLinkNode>;\r\n  nParentDirectoryLinks?: DirectoryLinkNodeLrNList;\r\n  descendants?: Descendants;\r\n  accessRoles?: AccessRole[];\r\n}\r\n\r\nexport interface FileNode extends Node, TimeStamped {\r\n  currentVersion?: FileVersionNode;\r\n  archived?: boolean;\r\n  versions?: Connection<FileVersionNode>;\r\n  keyId?: ID;\r\n  parentDirectoryLinks?: Connection<FileLinkNode>;\r\n  nParentDirectoryLinks?: FileLinkNodeLrNList;\r\n  accessRoles?: AccessRole[];\r\n}\r\n\r\nexport interface DirectoryLinkNode extends Node, TimeStamped {\r\n  parentDirectory?: DirectoryNode;\r\n  childDirectory?: DirectoryNode;\r\n}\r\n\r\nexport interface FileLinkNode extends Node, TimeStamped {\r\n  parentDirectory?: DirectoryNode;\r\n  childFile?: FileNode;\r\n}\r\n\r\nexport interface DirectoryLinkNodeLrNList {\r\n  list?: DirectoryLinkNode[];\r\n}\r\n\r\nexport interface FileLinkNodeLrNList {\r\n  list?: FileLinkNode[];\r\n}\r\n\r\nexport interface Descendants {\r\n  directories?: Connection<DirectoryNode>;\r\n  files?: Connection<FileNode>;\r\n  directoriesCount?: number;\r\n  filesCount?: number;\r\n}\r\n\r\nexport enum AccessRoleChoice {\r\n  READER = 'READER',\r\n  WRITER = 'WRITER',\r\n  ADMIN = 'ADMIN',\r\n  DENY = 'DENY',\r\n  OWNER = 'OWNER',\r\n}\r\n\r\nexport enum AccessRoleMethod {\r\n  inherited = 'inherited',\r\n  direct = 'direct',\r\n}\r\n\r\nexport interface AccessRole {\r\n  issuer?: UserNode;\r\n  subject?: UserNode;\r\n  role?: AccessRoleChoice;\r\n  method?: AccessRoleMethod;\r\n  inheritedFrom?: DirectoryNode;\r\n  trustedParty?: TpNode;\r\n  isIssuer?: boolean;\r\n}\r\n\r\nexport enum FileVersionOperation {\r\n  CREATE = 'CREATE',\r\n  READ = 'READ',\r\n  UPDATE = 'UPDATE',\r\n  REVERT = 'REVERT',\r\n  DELETE = 'DELETE',\r\n}\r\n\r\nexport interface FileVersionNode extends Node, TimeStamped {\r\n  file?: FileNode;\r\n  state?: FileStateNode;\r\n  operation?: FileVersionOperation;\r\n  author?: UserNode;\r\n}\r\nexport interface FileStateNode extends Node, TimeStamped {\r\n  plainMeta?: JSONString;\r\n  plainMetaJson?: any;\r\n  cipherMeta?: string;\r\n  cipherMetaClearJson?: any;\r\n  contentResource?: string;\r\n  versions?: Connection<FileVersionNode>;\r\n  keyId: ID;\r\n}\r\n\r\nexport enum KeyExchangeOtkState {\r\n  OTK_INITIATED = 'OTK_INITIATED',\r\n  OTK_ACCEPTED = 'OTK_ACCEPTED',\r\n  OTK_COMPLETED = 'OTK_COMPLETED',\r\n}\r\n\r\nexport interface ContactCardSharedCipherData {\r\n  // Shared read access between initiator and responder. But only the initiator has write access.\r\n  sharedCipherDataClearJson: any;\r\n}\r\n\r\n/**\r\n * The contents of the one-time key cipher\r\n */\r\nexport interface OtKeyCipherClearJson2 {\r\n  // Used to confirm to the initiator that the responder has access to the one-time key.\r\n  nonce: string;\r\n  // Data sent from initiator to the responder\r\n  initiator: {\r\n    oneTimePbk: object; // one-time public encryption key the responder will use to send data back to the initiator\r\n    pbk: object; // public encryption key\r\n    sigPbk: object; // public signing key\r\n    message?: any;\r\n    contactCard?: ContactCardSharedCipherData;\r\n  };\r\n}\r\n\r\nexport interface KeyExchangeOtkNode extends Node, TimeStamped {\r\n  state?: KeyExchangeOtkState;\r\n  sharedKey?: KeyNode;\r\n  mkSharedKey?: KeyNode;\r\n  initiatorSigPxk?: KeyNode;\r\n  responderSigPxk?: KeyNode;\r\n  initiatorOneTimePbkCipher?: string;\r\n  otKeyParams?: string;\r\n  otKeyCipher?: string;\r\n  otKeyCipherClearJson?: OtKeyCipherClearJson2;\r\n  responderPbkCipher?: string;\r\n}\r\n\r\nexport enum KeyExchangeState {\r\n  IN_PROGRESS = 'IN_PROGRESS',\r\n  COMPLETED = 'COMPLETED',\r\n  DECLINED = 'DECLINED',\r\n  CANCELLED = 'CANCELLED',\r\n  DELETED = 'DELETED',\r\n}\r\n\r\nexport enum KeyExchangeMode {\r\n  OTK = 'OTK',\r\n}\r\n\r\nexport interface KeyExchangeNode extends Node, TimeStamped {\r\n  expiryTime?: DateTime;\r\n  token?: string;\r\n  tokenExpiryTime?: DateTime;\r\n  state?: KeyExchangeState;\r\n  mode?: KeyExchangeMode;\r\n  initiator?: UserNode;\r\n  responder?: UserNode;\r\n  initiatorRootKeyCipher?: string;\r\n  responderRootKeyCipher?: string;\r\n  initiatorActionRequired?: boolean;\r\n  responderActionRequired?: boolean;\r\n  createTp?: boolean;\r\n  otk?: KeyExchangeOtkNode;\r\n  isInitiator?: boolean;\r\n  isExpired?: boolean;\r\n  responderEmailAddress?: LrEmail;\r\n}\r\n\r\nexport interface SharedItems {\r\n  directories?: Connection<DirectoryNode>;\r\n  files?: Connection<FileNode>;\r\n}\r\n\r\nexport interface SharedContactCardNode extends Node, TimeStamped {\r\n  owner?: UserNode;\r\n  receiver?: UserNode;\r\n  sharedKey?: KeyNode;\r\n  sharedCipherData?: string;\r\n  sharedCipherDataClearJson?: any;\r\n  sharedCipherDataSig?: string;\r\n  sharedCipherDataSigPxk?: KeyNode;\r\n  ownerCipherData?: string;\r\n  ownerCipherDataClearJson?: any;\r\n  ownerKey?: KeyNode;\r\n  ownerPlainData?: string;\r\n  ownerPlainDataJson?: any;\r\n  ownerPlainDataSig?: string;\r\n  receiverCipherData?: string;\r\n  receiverCipherDataClearJson?: any;\r\n  receiverKey?: KeyNode;\r\n}\r\n\r\nexport interface UserSharedKeyNode extends Node, TimeStamped {\r\n  keyExchange?: KeyExchangeNode;\r\n  user?: UserNode;\r\n  userPrk?: KeyNode;\r\n  userSigPrk?: KeyNode;\r\n  other?: UserNode;\r\n  otherPbk?: KeyNode;\r\n  otherSigPbk?: KeyNode;\r\n  sharedKey?: KeyNode;\r\n  mkSharedKey?: KeyNode;\r\n  mkPxk?: KeyNode;\r\n  mkReshareRequestCipher?: string;\r\n  mkReshareResponseCipher?: string;\r\n  mkReshareRequestCipherClearJson?: any;\r\n  mkReshareResponseCipherClearJson?: any;\r\n  mkReshareRequestSent?: boolean;\r\n  mkReshareResponseSent?: boolean;\r\n}\r\n\r\nexport interface CurrentUserSharedKeyNode extends Node, TimeStamped {\r\n  user?: UserNode;\r\n  other?: UserNode;\r\n  userSharedKey?: UserSharedKeyNode;\r\n}\r\n\r\nexport interface TpNode extends Node, TimeStamped {\r\n  user?: UserNode;\r\n  other?: UserNode;\r\n  currentUserSharedKey?: CurrentUserSharedKeyNode;\r\n  isCompleted?: boolean;\r\n  sharedKey?: KeyNode;\r\n  sharedContactCard?: SharedContactCardNode;\r\n  myContactCard?: SharedContactCardNode;\r\n  myItems?: SharedItems;\r\n  sharedItems?: SharedItems;\r\n  myScenarios?: Connection<ScenarioNode>;\r\n  sharedScenarios?: Connection<SharedScenarioNode>;\r\n}\r\n\r\nexport enum TpAssemblyState {\r\n  DISABLED = 'DISABLED',\r\n  ENABLED = 'ENABLED',\r\n  CLAIMED = 'CLAIMED',\r\n  APPROVED = 'APPROVED',\r\n  REJECTED = 'REJECTED',\r\n  EXPIRED = 'EXPIRED',\r\n  CANCELLED = 'CANCELLED',\r\n  RESET = 'RESET',\r\n}\r\n\r\nexport enum TpClaimState {\r\n  CLAIMED = 'CLAIMED',\r\n  APPROVED = 'APPROVED',\r\n  REJECTED = 'REJECTED',\r\n  EXPIRED = 'EXPIRED',\r\n  CANCELLED = 'CANCELLED',\r\n  RESET = 'RESET',\r\n}\r\n\r\nexport enum TpClaimApproverState {\r\n  CLAIMED = 'CLAIMED',\r\n  APPROVED = 'APPROVED',\r\n  REJECTED = 'REJECTED',\r\n}\r\n\r\nexport interface TpPasswordResetApproval extends Node, TimeStamped {\r\n  approverEmail?: string;\r\n  receiverCipher?: string;\r\n  receiverCipherClearJson?: any;\r\n  receiverCipherPartialAssemblyKey?: string;\r\n  receiverCipherPartialAssemblyKeyClearJson?: any;\r\n}\r\n\r\n// export interface TpPasswordResetUser {\r\n//   username?: string;\r\n//   resetUsername?: string;\r\n//   state?: TpAssemblyState;\r\n//   passKey?: PassKeyNode;\r\n//   masterKey?: KeyNode;\r\n//   pxk?: KeyNode;\r\n//   approvals?: TpPasswordResetApproval[];\r\n//   assemblyCipherData?: string;\r\n//   wrappedAssemblyKeyVerifierPrk?: string;\r\n// }\r\n\r\nexport interface TpPasswordResetUserApprovalNode extends Node, TimeStamped {\r\n  receiverCipher?: string;\r\n  receiverCipherClearJson?: any;\r\n  receiverCipherPartialAssemblyKey?: string;\r\n  receiverCipherPartialAssemblyKeyClearJson?: any;\r\n  approverEmail?: string;\r\n}\r\n\r\nexport interface TpPasswordResetUserApprover {\r\n  name?: string;\r\n  email?: string;\r\n  state?: TpClaimApproverState;\r\n}\r\n\r\nexport interface TpPasswordResetUserSubAssembly {\r\n  singleReject?: boolean;\r\n  quorum?: number;\r\n  approvers?: TpPasswordResetUserApprover[];\r\n}\r\n\r\nexport interface TpPasswordResetUserAssembly {\r\n  singleReject?: boolean;\r\n  quorum?: number;\r\n  subAssemblies?: TpPasswordResetUserSubAssembly[];\r\n}\r\n\r\nexport interface TpPasswordResetUserNode {\r\n  username?: string;\r\n  resetUsername?: string;\r\n  state?: TpClaimState;\r\n  passKey?: PassKeyNode;\r\n  masterKey?: KeyNode;\r\n  pxk?: KeyNode;\r\n  sessionEncryptionKey?: string;\r\n  approvals?: TpPasswordResetUserApprovalNode[];\r\n  assemblyCipherData?: string;\r\n  wrappedAssemblyKeyVerifierPrk?: string;\r\n  assembly?: TpPasswordResetUserAssembly;\r\n}\r\n\r\nexport interface TpPasswordResetNode extends Node, TimeStamped {\r\n  assembly?: TpAssemblyNode;\r\n  request?: TpPasswordResetRequestNode;\r\n  applied?: boolean;\r\n}\r\n\r\nexport interface TpAssemblyNode extends Node, TimeStamped {\r\n  id?: ID;\r\n  singleReject?: boolean;\r\n  quorum?: number;\r\n  subjectKey?: KeyNode;\r\n  assemblyKey?: KeyNode;\r\n  assemblyCipherData?: string;\r\n  assemblyCipherDataClearJson?: any;\r\n  subAssemblies?: Connection<TpSubAssemblyNode>;\r\n}\r\n\r\nexport interface TpSubAssemblyNode extends Node, TimeStamped {\r\n  singleReject?: boolean;\r\n  quorum?: number;\r\n  subjectCipherData?: string;\r\n  subjectCipherDataClearJson?: string;\r\n  approvers?: Connection<TpAssemblyApproverNode>;\r\n}\r\n\r\nexport interface TpAssemblyApproverNode extends Node, TimeStamped {\r\n  sharedKey?: KeyNode;\r\n  sharedCipherData?: string;\r\n  sharedCipherApprovalData?: string;\r\n  tp?: TpNode;\r\n}\r\n\r\nexport interface SharedTpPasswordResetNode extends Node, TimeStamped {\r\n  assembly?: SharedTpAssemblyNode;\r\n  tp?: TpNode;\r\n  sharedRequest?: SharedTpPasswordResetRequestNode;\r\n}\r\n\r\nexport interface SharedTpAssemblyNode extends Node, TimeStamped {\r\n  asApprovers?: Connection<TpAssemblyAsApproverNode>;\r\n}\r\n\r\nexport interface TpAssemblyAsApproverNode extends Node, TimeStamped {\r\n  sharedKey?: KeyNode;\r\n  sharedCipherData?: string;\r\n}\r\n\r\nexport interface SharedTpPasswordResetRequestNode extends Node, TimeStamped {\r\n  claim?: SharedTpClaimNode;\r\n  pxk?: KeyNode;\r\n}\r\n\r\nexport interface SharedTpClaimNode extends Node, TimeStamped {\r\n  state?: TpClaimState;\r\n  asClaimApprovers?: Connection<SharedTpClaimApproverNode>;\r\n}\r\n\r\nexport interface SharedTpClaimApproverNode extends Node, TimeStamped {\r\n  state?: TpClaimApproverState;\r\n  sharedKey?: KeyNode;\r\n  sharedCipherApprovalData?: string;\r\n  sharedCipherPartialAssemblyKey?: string;\r\n  receiverApprovals?: Connection<SharedTpClaimReceiverApprovalNode>;\r\n}\r\n\r\nexport interface SharedTpClaimReceiverApprovalNode extends Node, TimeStamped {\r\n  pxk?: KeyNode;\r\n}\r\n\r\nexport enum LockState {\r\n  UNLOCKED = 'UNLOCKED',\r\n  MUTEX_LOCKED = 'MUTEX_LOCKED',\r\n}\r\n"]}

package/esm2015/lib/auth/auth.config.js

@@ -0,0 +1,57 @@
+export function handleCognitoCallback(method) {
+    return new Promise((resolve, reject) => method((err, result) => (err ? reject(err) : resolve(result))));
+}
+export const awsFetch = (authUrl) => {
+    const fetch = window.fetch;
+    return (url, options) => {
+        const pass = () => fetch(url, options);
+        if (!options || !options.headers || !options.headers['X-Amz-Target']) {
+            return pass();
+        }
+        const operation = options.headers['X-Amz-Target'].split('.');
+        if (operation.length < 2 ||
+            operation[0] !== 'AWSCognitoIdentityProviderService') {
+            return pass();
+        }
+        const body = JSON.parse(options.body);
+        if (body && body.ClientMetadata && body.ClientMetadata.noProxy === 'true') {
+            return pass();
+        }
+        let custom = false;
+        if (operation[1] === 'RespondToAuthChallenge') {
+            if (body && body.ChallengeName === 'NEW_PASSWORD_REQUIRED') {
+                return pass();
+            }
+            custom = true;
+        }
+        else if (operation[1] === 'InitiateAuth') {
+            if (body.AuthFlow === 'REFRESH_TOKEN_AUTH') {
+                custom = true;
+            }
+        }
+        if (!custom) {
+            return pass();
+        }
+        return fetch(`${authUrl}auth/proxy/`, Object.assign(Object.assign({}, options), { credentials: 'include' }));
+    };
+};
+export const configureAmplifyAuth = ({ authUrl: authUrl, userPoolId, userPoolWebClientId }, auth) => {
+    return () => {
+        const tokens = userPoolId.split('_');
+        if (tokens.length < 2) {
+            throw new Error('userPoolId should have this format: {aws-region}_xxxxx');
+        }
+        window.fetch = awsFetch(authUrl);
+        auth.configure({
+            // REQUIRED - Amazon Cognito Region
+            region: tokens[0],
+            // OPTIONAL - Amazon Cognito User Pool ID
+            userPoolId,
+            // OPTIONAL - Amazon Cognito Web Client ID (26-char alphanumeric string)
+            userPoolWebClientId,
+            // OPTIONAL - Enforce user authentication prior to accessing AWS resources or not
+            mandatorySignIn: false,
+        });
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/auth/auth.gql.js

@@ -0,0 +1,48 @@
+import gql from 'graphql-tag';
+import { gqlTyped } from '../_common/ast';
+export const PasswordChangeRequestMutation = gql `
+  mutation {
+    passwordChangeRequest(input: {}) {
+      challenge
+      passKeys {
+        id
+        passIdpParams
+        wrappedPassIdpVerifierPrk
+      }
+    }
+  }
+`;
+export const PasswordChangeMutation = gql `
+  mutation PasswordChange($input: PasswordChangeInput!) {
+    passwordChange(input: $input) {
+      token
+      newPassKey {
+        id
+      }
+    }
+  }
+`;
+export const PasswordChangeConfigQuery = gql `
+  query PasswordChangeConfigQuery {
+    passwordChangeConfig {
+      maxAuthAgeSeconds
+      authTime
+      serverTime
+    }
+  }
+`;
+export const SetSessionEncryptionKeyMutation = gqlTyped `
+mutation SetSessionEncryptionKeyMutation($input: SetSessionEncryptionKeyInput!) {
+  setSessionEncryptionKey(input: $input) {
+    sessionEncryptionKey
+  }
+}
+`;
+export const ClearSessionEncryptionKeyMutation = gqlTyped `
+mutation ClearSessionEncryptionKeyMutation {
+  clearSessionEncryptionKey(input: {}) {
+    sessionEncryptionKey
+  }
+}
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/auth/auth.types.js

@@ -0,0 +1,27 @@
+import { CognitoUser } from '@aws-amplify/auth';
+export class CognitoChallengeUser extends CognitoUser {
+    constructor() {
+        super(...arguments);
+        this.isTpPasswordResetUser = false;
+    }
+}
+export var FeatureAction;
+(function (FeatureAction) {
+    // Just the one for now
+    FeatureAction["ACCESS"] = "access";
+})(FeatureAction || (FeatureAction = {}));
+export class Features {
+}
+export class CurrentUser {
+}
+export class LoginResult {
+}
+export class RegisterResult {
+}
+export var RecoveryStatus;
+(function (RecoveryStatus) {
+    RecoveryStatus["NONE"] = "none";
+    RecoveryStatus["NEW_PASSWORD"] = "new-password";
+    RecoveryStatus["OLD_PASSWORD"] = "old-password";
+})(RecoveryStatus || (RecoveryStatus = {}));
+//# sourceMappingURL=data:application/json;base64,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