@lifeready/core 0.6.0-beta.1

package/esm2015/lib/record/record.service.js

@@ -0,0 +1,206 @@
+import { __awaiter } from "tslib";
+import { RecordAttachmentService } from './record-attachment.service';
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { CategoryFilter } from '../category/category.gql';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { DirectoryType } from './../category/category.gql';
+import { CreateRecordContainerMutation, CreateRecordMutation, DeleteRecordMutation, FileType, GetRecordQuery, RecordAttachmentFilter, RecordContentFilter, UpdateRecordMutation, } from './record.gql';
+import { AccessLevel } from '../category/category.types';
+import { CategoryService } from '../category/category.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/lr-apollo.service";
+import * as i2 from "../cryptography/key-meta.service";
+import * as i3 from "../category/category.service";
+import * as i4 from "./record-attachment.service";
+export class RecordService {
+    constructor(lrApollo, keyMetaService, categoryService, recordAttachmentService) {
+        this.lrApollo = lrApollo;
+        this.keyMetaService = keyMetaService;
+        this.categoryService = categoryService;
+        this.recordAttachmentService = recordAttachmentService;
+    }
+    getRecord(recordId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { record } = yield this.lrApollo.query({
+                query: GetRecordQuery(),
+                variables: {
+                    id: recordId,
+                    categoryFilter: CategoryFilter,
+                    contentFilter: RecordContentFilter,
+                    attachmentsFilter: RecordAttachmentFilter,
+                },
+            });
+            const contents = record.content.edges[0].node.childFile;
+            const { name, recordType, fields } = (yield this.keyMetaService.decryptMeta(contents.currentVersion.state)) ||
+                {};
+            const categories = yield Promise.all(record.parentCategories.edges.map((x) => __awaiter(this, void 0, void 0, function* () {
+                return [
+                    ...(yield this.categoryService.mapParentCategories(x.node.parentDirectory)),
+                    yield this.categoryService.mapCategory(x.node.parentDirectory),
+                ];
+            })));
+            const attachments = yield this.mapAttachments(record.attachments.edges);
+            const isOwner = record.accessRoles &&
+                record.accessRoles.some((x) => x.role === AccessLevel.Owner);
+            return {
+                id: record.id,
+                keyId: record.keyId,
+                updateKeyId: contents.keyId,
+                updateId: contents.id,
+                name,
+                recordType,
+                fields,
+                categories,
+                attachments,
+                myAccessLevel: isOwner ? AccessLevel.Owner : record.accessRoles[0].role,
+                sharedAccess: isOwner
+                    ? record.accessRoles
+                        .filter((x) => x.role !== AccessLevel.Owner)
+                        .map((x) => ({
+                        trustedPartyId: x.trustedParty && x.trustedParty.id,
+                        accessLevel: x.role,
+                        isInherited: x.method === 'inherited',
+                        inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,
+                    }))
+                    : [],
+                isArchived: !!record.archived,
+                createdOn: record.created,
+                lastModified: new Date(record.modified) >
+                    new Date(contents.currentVersion.state.modified)
+                    ? record.modified
+                    : contents.currentVersion.state.modified,
+            };
+        });
+    }
+    mapAttachments(attachments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield Promise.all(attachments
+                .map((x) => x.node.childFile)
+                .map((x) => __awaiter(this, void 0, void 0, function* () {
+                const { name, fieldId, fileType, fileSize, lastModified } = (yield this.keyMetaService.decryptMeta(x.currentVersion.state)) ||
+                    {};
+                return {
+                    fileId: x.id,
+                    keyId: x.currentVersion.state.keyId,
+                    contentId: x.currentVersion.state.id,
+                    fieldId,
+                    name,
+                    fileType,
+                    fileSize,
+                    lastModified,
+                };
+            })));
+        });
+    }
+    createRecord(newRecord) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create directory that holds the record
+            const wrappedContent = yield this.keyMetaService.wrapContent(null, newRecord.categoryIds);
+            const response = yield this.lrApollo.mutate({
+                mutation: CreateRecordContainerMutation,
+                variables: {
+                    plainMeta: JSON.stringify({
+                        directoryType: DirectoryType.Record,
+                        isHidden: false,
+                    }),
+                    parentDirectories: wrappedContent.wrappedKeys,
+                    parentRootDirectory: wrappedContent.rootKey,
+                },
+            });
+            const recordId = response.new.category.id;
+            const secureContent = {
+                name: newRecord.name,
+                recordType: newRecord.recordType,
+                fields: newRecord.fields,
+            };
+            const doubleWrappedContent = yield this.keyMetaService.doubleWrapContent(secureContent, [recordId]);
+            // Create the file that holds the record contents
+            yield this.lrApollo.mutate({
+                mutation: CreateRecordMutation,
+                variables: {
+                    input: {
+                        plainMeta: JSON.stringify({ fileType: FileType.RecordContent }),
+                        wrappedStateKey: doubleWrappedContent.doubleWrappedKey,
+                        cipherMeta: doubleWrappedContent.cipherMeta,
+                        parentDirectories: doubleWrappedContent.wrappedKeys.map((x) => ({
+                            directoryId: x.directoryId,
+                            wrappingKeyId: x.wrappingKeyId,
+                            wrappedFileKey: x.wrappedKey,
+                        })),
+                    },
+                },
+            });
+            try {
+                yield this.recordAttachmentService.uploadAttachments(recordId, newRecord.attachments);
+            }
+            catch (e) {
+                console.error(e);
+                return { recordId, attachmentError: e };
+            }
+            return { recordId };
+        });
+    }
+    updateRecord(recordId, updateId, updateKeyId, updatedRecord) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const secureContent = {
+                name: updatedRecord.name,
+                recordType: updatedRecord.recordType,
+                fields: updatedRecord.fields,
+            };
+            const reWrappedContent = yield this.keyMetaService.reWrapContent(updateKeyId, secureContent);
+            yield this.lrApollo.mutate({
+                mutation: UpdateRecordMutation,
+                variables: {
+                    input: {
+                        fileId: updateId,
+                        plainMeta: JSON.stringify({ fileType: FileType.RecordContent }),
+                        wrappedStateKey: reWrappedContent.doubleWrappedKey,
+                        cipherMeta: reWrappedContent.cipherMeta,
+                    },
+                },
+            });
+            try {
+                yield this.recordAttachmentService.uploadAttachments(recordId, updatedRecord.attachments);
+            }
+            catch (e) {
+                console.error(e);
+                return { recordId, attachmentError: e };
+            }
+            return { recordId };
+        });
+    }
+    archiveRecord(recordId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // All content of the record should also be archived, hence, recursive=true
+            return this.categoryService.archiveDirectory(recordId, true);
+        });
+    }
+    unarchiveRecord(recordId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // All content of the record should also be unarchived, hence, recursive=true
+            return this.categoryService.unarchiveDirectory(recordId, true);
+        });
+    }
+    deleteRecord(recordId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeleteRecordMutation,
+                variables: { recordId },
+            });
+        });
+    }
+}
+RecordService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RecordService_Factory() { return new RecordService(i0.ɵɵinject(i1.LrApolloService), i0.ɵɵinject(i2.KeyMetaService), i0.ɵɵinject(i3.CategoryService), i0.ɵɵinject(i4.RecordAttachmentService)); }, token: RecordService, providedIn: "root" });
+RecordService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+RecordService.ctorParameters = () => [
+    { type: LrApolloService },
+    { type: KeyMetaService },
+    { type: CategoryService },
+    { type: RecordAttachmentService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/record/record.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { RecordAttachmentService } from './record-attachment.service';\r\nimport { Injectable } from '@angular/core';\r\nimport { LrApolloService } from '../api/lr-apollo.service';\r\nimport { CategoryFilter } from '../category/category.gql';\r\nimport { KeyMetaService } from '../cryptography/key-meta.service';\r\nimport { DirectoryType } from './../category/category.gql';\r\nimport {\r\n  LrRecord,\r\n  NewRecord,\r\n  UpdatedRecord,\r\n  RecordAttachment,\r\n} from './record.types';\r\nimport {\r\n  CreateRecordContainerMutation,\r\n  CreateRecordMutation,\r\n  DeleteRecordMutation,\r\n  FileType,\r\n  GetRecordQuery,\r\n  RecordAttachmentFilter,\r\n  RecordContentFilter,\r\n  UpdateRecordContainerMutation,\r\n  UpdateRecordMutation,\r\n} from './record.gql';\r\nimport { Category, AccessLevel } from '../category/category.types';\r\nimport { CategoryService } from '../category/category.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RecordService {\r\n  constructor(\r\n    private lrApollo: LrApolloService,\r\n    private keyMetaService: KeyMetaService,\r\n    private categoryService: CategoryService,\r\n    private recordAttachmentService: RecordAttachmentService\r\n  ) {}\r\n\r\n  public async getRecord(recordId: string): Promise<LrRecord> {\r\n    const { record } = await this.lrApollo.query<any>({\r\n      query: GetRecordQuery(),\r\n      variables: {\r\n        id: recordId,\r\n        categoryFilter: CategoryFilter,\r\n        contentFilter: RecordContentFilter,\r\n        attachmentsFilter: RecordAttachmentFilter,\r\n      },\r\n    });\r\n    const contents = record.content.edges[0].node.childFile;\r\n    const { name, recordType, fields } =\r\n      (await this.keyMetaService.decryptMeta(contents.currentVersion.state)) ||\r\n      {};\r\n    const categories = await Promise.all<Category[]>(\r\n      record.parentCategories.edges.map(async (x: any) => [\r\n        ...(await this.categoryService.mapParentCategories(\r\n          x.node.parentDirectory\r\n        )),\r\n        await this.categoryService.mapCategory(x.node.parentDirectory),\r\n      ])\r\n    );\r\n    const attachments = await this.mapAttachments(record.attachments.edges);\r\n    const isOwner =\r\n      record.accessRoles &&\r\n      record.accessRoles.some((x) => x.role === AccessLevel.Owner);\r\n\r\n    return {\r\n      id: record.id,\r\n      keyId: record.keyId,\r\n      updateKeyId: contents.keyId,\r\n      updateId: contents.id,\r\n      name,\r\n      recordType,\r\n      fields,\r\n      categories,\r\n      attachments,\r\n      myAccessLevel: isOwner ? AccessLevel.Owner : record.accessRoles[0].role,\r\n      sharedAccess: isOwner\r\n        ? record.accessRoles\r\n            .filter((x) => x.role !== AccessLevel.Owner)\r\n            .map((x) => ({\r\n              trustedPartyId: x.trustedParty && x.trustedParty.id,\r\n              accessLevel: x.role,\r\n              isInherited: x.method === 'inherited',\r\n              inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,\r\n            }))\r\n        : [],\r\n      isArchived: !!record.archived,\r\n      createdOn: record.created,\r\n      lastModified:\r\n        new Date(record.modified) >\r\n        new Date(contents.currentVersion.state.modified)\r\n          ? record.modified\r\n          : contents.currentVersion.state.modified,\r\n    };\r\n  }\r\n\r\n  private async mapAttachments(\r\n    attachments: any[]\r\n  ): Promise<RecordAttachment[]> {\r\n    return await Promise.all<RecordAttachment>(\r\n      attachments\r\n        .map((x) => x.node.childFile)\r\n        .map(async (x: any) => {\r\n          const { name, fieldId, fileType, fileSize, lastModified } =\r\n            (await this.keyMetaService.decryptMeta(x.currentVersion.state)) ||\r\n            {};\r\n\r\n          return {\r\n            fileId: x.id,\r\n            keyId: x.currentVersion.state.keyId,\r\n            contentId: x.currentVersion.state.id,\r\n            fieldId,\r\n            name,\r\n            fileType,\r\n            fileSize,\r\n            lastModified,\r\n          };\r\n        })\r\n    );\r\n  }\r\n\r\n  public async createRecord(\r\n    newRecord: NewRecord\r\n  ): Promise<{ recordId: string; attachmentError?: Error }> {\r\n    // Create directory that holds the record\r\n    const wrappedContent = await this.keyMetaService.wrapContent(\r\n      null,\r\n      newRecord.categoryIds\r\n    );\r\n    const response = await this.lrApollo.mutate<any>({\r\n      mutation: CreateRecordContainerMutation,\r\n      variables: {\r\n        plainMeta: JSON.stringify({\r\n          directoryType: DirectoryType.Record,\r\n          isHidden: false,\r\n        }),\r\n        parentDirectories: wrappedContent.wrappedKeys,\r\n        parentRootDirectory: wrappedContent.rootKey,\r\n      },\r\n    });\r\n    const recordId = response.new.category.id;\r\n    const secureContent = {\r\n      name: newRecord.name,\r\n      recordType: newRecord.recordType,\r\n      fields: newRecord.fields,\r\n    };\r\n    const doubleWrappedContent = await this.keyMetaService.doubleWrapContent(\r\n      secureContent,\r\n      [recordId]\r\n    );\r\n\r\n    // Create the file that holds the record contents\r\n    await this.lrApollo.mutate({\r\n      mutation: CreateRecordMutation,\r\n      variables: {\r\n        input: {\r\n          plainMeta: JSON.stringify({ fileType: FileType.RecordContent }),\r\n          wrappedStateKey: doubleWrappedContent.doubleWrappedKey,\r\n          cipherMeta: doubleWrappedContent.cipherMeta,\r\n          parentDirectories: doubleWrappedContent.wrappedKeys.map((x) => ({\r\n            directoryId: x.directoryId,\r\n            wrappingKeyId: x.wrappingKeyId,\r\n            wrappedFileKey: x.wrappedKey,\r\n          })),\r\n        },\r\n      },\r\n    });\r\n\r\n    try {\r\n      await this.recordAttachmentService.uploadAttachments(\r\n        recordId,\r\n        newRecord.attachments\r\n      );\r\n    } catch (e) {\r\n      console.error(e);\r\n      return { recordId, attachmentError: e };\r\n    }\r\n    return { recordId };\r\n  }\r\n\r\n  public async updateRecord(\r\n    recordId: string,\r\n    updateId: string,\r\n    updateKeyId: string,\r\n    updatedRecord: UpdatedRecord\r\n  ): Promise<{ recordId: string; attachmentError?: Error }> {\r\n    const secureContent = {\r\n      name: updatedRecord.name,\r\n      recordType: updatedRecord.recordType,\r\n      fields: updatedRecord.fields,\r\n    };\r\n    const reWrappedContent = await this.keyMetaService.reWrapContent(\r\n      updateKeyId,\r\n      secureContent\r\n    );\r\n\r\n    await this.lrApollo.mutate({\r\n      mutation: UpdateRecordMutation,\r\n      variables: {\r\n        input: {\r\n          fileId: updateId,\r\n          plainMeta: JSON.stringify({ fileType: FileType.RecordContent }),\r\n          wrappedStateKey: reWrappedContent.doubleWrappedKey,\r\n          cipherMeta: reWrappedContent.cipherMeta,\r\n        },\r\n      },\r\n    });\r\n\r\n    try {\r\n      await this.recordAttachmentService.uploadAttachments(\r\n        recordId,\r\n        updatedRecord.attachments\r\n      );\r\n    } catch (e) {\r\n      console.error(e);\r\n      return { recordId, attachmentError: e };\r\n    }\r\n    return { recordId };\r\n  }\r\n\r\n  public async archiveRecord(recordId: string): Promise<void> {\r\n    // All content of the record should also be archived, hence, recursive=true\r\n    return this.categoryService.archiveDirectory(recordId, true);\r\n  }\r\n\r\n  public async unarchiveRecord(recordId: string): Promise<void> {\r\n    // All content of the record should also be unarchived, hence, recursive=true\r\n    return this.categoryService.unarchiveDirectory(recordId, true);\r\n  }\r\n\r\n  public async deleteRecord(recordId: string): Promise<void> {\r\n    await this.lrApollo.mutate({\r\n      mutation: DeleteRecordMutation,\r\n      variables: { recordId },\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/lib/record/record.types.js

@@ -0,0 +1,15 @@
+export class RecordField {
+}
+export class RecordAttachment {
+}
+export class LrRecord {
+}
+export class NewAttachment {
+}
+export class NewRecord {
+}
+export class NewOrUpdatedAttachment extends NewAttachment {
+}
+export class UpdatedRecord {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/record-type/record-type.service.js

@@ -0,0 +1,75 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const arraysEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+};
+const ɵ0 = arraysEqual;
+export class RecordTypeService {
+    constructor(http) {
+        this.http = http;
+    }
+    getRecordTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.recordTypes) {
+                this.recordTypes = yield this.http
+                    .get('/assets/meta/record-types.json')
+                    .toPromise();
+            }
+            if (!this.categories) {
+                this.categories = yield this.http
+                    .get('/assets/meta/categories.json')
+                    .toPromise();
+            }
+            const subCategories = this.categories
+                .map((cat) => cat.subCategories)
+                .reduce((acc, next) => [...acc, ...next], []);
+            const recordTypesWithCategories = this.recordTypes.map((recordType) => (Object.assign(Object.assign({}, recordType), { categoryNames: recordType.categories.map((cat) => {
+                    return cat.map((categoryCode) => {
+                        const subCat = subCategories.find((c) => c.code === categoryCode);
+                        if (subCat) {
+                            return subCat.name;
+                        }
+                        else {
+                            return this.categories.find((c) => c.code === categoryCode).name;
+                        }
+                    });
+                }) })));
+            return Promise.resolve(recordTypesWithCategories);
+        });
+    }
+    getRecordType(recordTypeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getRecordTypes()).find((x) => x.id === recordTypeId);
+        });
+    }
+    getRecordTypesForCategory(categoryTree) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const recordTypes = yield this.getRecordTypes();
+            return recordTypes.filter((x) => x.categories.some((y) => arraysEqual(y, categoryTree)));
+        });
+    }
+}
+RecordTypeService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RecordTypeService_Factory() { return new RecordTypeService(i0.ɵɵinject(i1.HttpClient)); }, token: RecordTypeService, providedIn: "root" });
+RecordTypeService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+RecordTypeService.ctorParameters = () => [
+    { type: HttpClient }
+];
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/record-type/record-type.types.js

@@ -0,0 +1,28 @@
+export var RecordFieldType;
+(function (RecordFieldType) {
+    RecordFieldType["Text"] = "text";
+    RecordFieldType["Email"] = "email";
+    RecordFieldType["Url"] = "url";
+    RecordFieldType["Phone"] = "phone";
+    RecordFieldType["Date"] = "date";
+    RecordFieldType["Password"] = "password";
+    RecordFieldType["TextArea"] = "textArea";
+    RecordFieldType["Select"] = "select";
+    RecordFieldType["SingleChoice"] = "singleChoice";
+    RecordFieldType["MultiChoice"] = "multiChoice";
+    RecordFieldType["File"] = "file";
+    RecordFieldType["MultiFile"] = "multiFile";
+    RecordFieldType["Record"] = "record";
+    RecordFieldType["MultiRecord"] = "multiRecord";
+    RecordFieldType["Group"] = "group";
+    RecordFieldType["Custom"] = "custom";
+})(RecordFieldType || (RecordFieldType = {}));
+export class RecordType {
+}
+export class RecordTypeFieldOption {
+}
+export class RecordTypeField {
+}
+export class RecordTypeSummary {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/scenario/approvals/scenario-approval.gql.js

@@ -0,0 +1,105 @@
+import gql from 'graphql-tag';
+import { TrustedPartyProperties } from '../../trusted-parties/trusted-party.gql';
+import { KeyGraphField, FetchKeyGraphField } from '../../_common/queries.gql';
+const ApproverFields = `
+id
+tp {
+  ${TrustedPartyProperties}
+}
+sharedKey {
+  id
+}
+sharedCipherData
+sharedCipherApprovalData
+sharedCipherPartialAssemblyKey
+`;
+export const SubAssemblyFields = `
+id
+singleReject
+quorum
+assemblyKey {
+  id
+}
+subAssemblyCipherData
+approverCount
+approvers {
+  edges {
+    node {
+      ${ApproverFields}
+    }
+  }
+}
+`;
+export const CreateScenarioApproverAssemblyMutation = gql `
+mutation CreateScenarioApproverAssemblyMutation(
+  $input: CreateScenarioApproverAssemblyInput!
+) {
+  createScenarioApproverAssembly(input: $input) {
+    scenario {
+      approverAssembly {
+        assemblyKey {
+          id
+        }
+      }
+    }
+  }
+  ${FetchKeyGraphField}
+}`;
+export const UpdateScenarioApproverAssemblyMutation = gql `
+  mutation UpdateScenarioApproverAssemblyMutation(
+    $input: UpdateScenarioApproverAssemblyInput!
+  ) {
+    updateScenarioApproverAssembly(input: $input) {
+      scenario {
+        id
+      }
+      createdSubAssemblies {
+        id
+      }
+      createdApprovers {
+        id
+      }
+    }
+  }
+`;
+export const DeleteScenarioApproverAssemblyMutation = gql `
+  mutation DeleteScenarioApproverAssemblyMutation(
+    $input: DeleteScenarioApproverAssemblyInput!
+  ) {
+    deleteScenarioApproverAssembly(input: $input) {
+      scenario {
+        id
+      }
+    }
+  }
+`;
+export const GetScenarioApproverQuery = gql `
+query GetScenarioApproverQuery(
+  $id: LrRelayIdInput!
+) {
+  scenarioApprover(id: $id) {
+    ${ApproverFields}
+  }
+  ${KeyGraphField}
+} `;
+export const AddScenarioApproverMutation = gql `
+  mutation AddScenarioApproverMutation($input: AddScenarioApproverInput!) {
+    addScenarioApprover(input: $input) {
+      approver {
+        id
+      }
+    }
+  }
+`;
+export const UpdateScenarioApproverMutation = gql `
+  mutation UpdateScenarioApproverMutation(
+    $input: UpdateScenarioApproverInput!
+  ) {
+    updateScenarioApprover(input: $input) {
+      approver {
+        id
+      }
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/scenario/approvals/scenario-approval.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,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