@lifeready/core 1.0.12 → 1.0.15

package/lib/category/category.types.d.ts

@@ -1,79 +1,79 @@
-export declare enum AccessLevel {
-    Owner = "OWNER",
-    Admin = "ADMIN",
-    Writer = "WRITER",
-    Reader = "READER",
-    Deny = "DENY"
-}
-export declare class SharedAccess {
-    trustedPartyId: string;
-    accessLevel: AccessLevel;
-    isInherited: boolean;
-    inheritedFrom?: string;
-}
-export declare class DefaultCategory {
-    code: string;
-    name: string;
-    allowRecords: boolean;
-    allowCustomCategories: boolean;
-    archived: boolean;
-    subCategories?: DefaultCategory[];
-}
-export declare class VaultRecordType {
-    id: string;
-    name: string;
-}
-export declare class VaultRecord {
-    id: string;
-    keyId: string;
-    name: string;
-    recordType: VaultRecordType;
-    createdOn: string | Date;
-    lastModified: string | Date;
-    isArchived: boolean;
-    myAccessLevel: AccessLevel;
-    sharedAccess: SharedAccess[];
-}
-export declare class Category {
-    id: string;
-    keyId: string;
-    code?: string;
-    name: string;
-    isHidden: boolean;
-    isCustom: boolean;
-    isEmpty: boolean;
-    isArchived: boolean;
-    allRecordsCount: number;
-    allowRecords: boolean;
-    allowCustomCategories: boolean;
-    myAccessLevel: AccessLevel;
-    sharedAccess: SharedAccess[];
-}
-export declare class CurrentCategory extends Category {
-    parents: Category[];
-}
-export declare class VaultCategory {
-    category?: CurrentCategory;
-    subCategories?: Category[];
-    records?: VaultRecord[];
-}
-export declare class NewCategory {
-    name: string;
-    code?: string;
-    isCustom: boolean;
-    allowRecords: boolean;
-    allowCustomCategories: boolean;
-    categoryIds?: string[];
-}
-export declare class UpdatedCategory {
-    name: string;
-    code?: string;
-    isCustom: boolean;
-    allowRecords: boolean;
-    allowCustomCategories: boolean;
-}
-export declare class Vault {
-    id: string;
-    keyId: string;
-    name?: string;
-}
+export declare enum AccessLevel {
+    Owner = "OWNER",
+    Admin = "ADMIN",
+    Writer = "WRITER",
+    Reader = "READER",
+    Deny = "DENY"
+}
+export declare class SharedAccess {
+    trustedPartyId: string;
+    accessLevel: AccessLevel;
+    isInherited: boolean;
+    inheritedFrom?: string;
+}
+export declare class DefaultCategory {
+    code: string;
+    name: string;
+    allowRecords: boolean;
+    allowCustomCategories: boolean;
+    archived: boolean;
+    subCategories?: DefaultCategory[];
+}
+export declare class VaultRecordType {
+    id: string;
+    name: string;
+}
+export declare class VaultRecord {
+    id: string;
+    keyId: string;
+    name: string;
+    recordType: VaultRecordType;
+    createdOn: string | Date;
+    lastModified: string | Date;
+    isArchived: boolean;
+    myAccessLevel: AccessLevel;
+    sharedAccess: SharedAccess[];
+}
+export declare class Category {
+    id: string;
+    keyId: string;
+    code?: string;
+    name: string;
+    isHidden: boolean;
+    isCustom: boolean;
+    isEmpty: boolean;
+    isArchived: boolean;
+    allRecordsCount: number;
+    allowRecords: boolean;
+    allowCustomCategories: boolean;
+    myAccessLevel: AccessLevel;
+    sharedAccess: SharedAccess[];
+}
+export declare class CurrentCategory extends Category {
+    parents: Category[];
+}
+export declare class VaultCategory {
+    category?: CurrentCategory;
+    subCategories?: Category[];
+    records?: VaultRecord[];
+}
+export declare class NewCategory {
+    name: string;
+    code?: string;
+    isCustom: boolean;
+    allowRecords: boolean;
+    allowCustomCategories: boolean;
+    categoryIds?: string[];
+}
+export declare class UpdatedCategory {
+    name: string;
+    code?: string;
+    isCustom: boolean;
+    allowRecords: boolean;
+    allowCustomCategories: boolean;
+}
+export declare class Vault {
+    id: string;
+    keyId: string;
+    name?: string;
+}

package/lib/cryptography/cryptography.types.d.ts

@@ -1,83 +1,83 @@
-import { JWK } from 'node-jose';
-export interface Key {
-    id: string;
-    pbk?: string;
-    jwk?: JWK.Key;
-}
-export interface PassKeyParams {
-    kid: string;
-    salt: string;
-    iterations: number;
-}
-export interface PassIdpParams {
-    salt: string;
-    iterations: number;
-}
-export interface LbopKeyParams {
-    kid: string;
-    salt: string;
-    iterations: number;
-}
-export interface PassIdpVerifier {
-    wrappedPrK: object;
-    pbk: object;
-}
-export interface LbopKeyVerifier {
-    wrappedKey: object;
-    key: object;
-}
-export interface PassKey {
-    id: string;
-    passKeyParams?: PassKeyParams;
-    passIdpParams?: PassIdpParams;
-    wrappedPassIdpVerifierPrk?: object;
-    created?: string;
-}
-export interface KeyLink {
-    keyId: string;
-    wrappingKeyId: string;
-    wrappedKey: string;
-}
-export interface PassKeyLink {
-    keyId: string;
-    passKeyId: string;
-    wrappedKey: string;
-}
-export declare enum NodeType {
-    Key = "key",
-    PassKey = "passKey"
-}
-export interface Node {
-    type: NodeType;
-    data: Key | PassKey;
-}
-export declare enum EdgeType {
-    KeyLink = "keyLink",
-    PassKeyLink = "passKeyLink"
-}
-export interface Edge {
-    type: EdgeType;
-    data: KeyLink | PassKeyLink;
-}
-export interface KeyGraphResponse {
-    keys?: Key[];
-    keyLinks?: KeyLink[];
-    passKeys?: PassKey[];
-    passKeyLinks?: PassKeyLink[];
-}
-export interface HasKeyGraph {
-    keyGraph?: KeyGraphResponse;
-}
-export declare type PayloadType = 'json' | 'ArrayBuffer';
-export interface DeriveKeyResult {
-    jwk: JWK.Key;
-}
-export interface DerivePassIdpParams extends PassIdpParams {
-    password: string;
-}
-export interface DerivePassKeyParams extends PassKeyParams {
-    password: string;
-}
-export interface DeriveLbopKeyParams extends PassKeyParams {
-    password: string;
-}
+import { JWK } from 'node-jose';
+export interface Key {
+    id: string;
+    pbk?: string;
+    jwk?: JWK.Key;
+}
+export interface PassKeyParams {
+    kid: string;
+    salt: string;
+    iterations: number;
+}
+export interface PassIdpParams {
+    salt: string;
+    iterations: number;
+}
+export interface LbopKeyParams {
+    kid: string;
+    salt: string;
+    iterations: number;
+}
+export interface PassIdpVerifier {
+    wrappedPrK: object;
+    pbk: object;
+}
+export interface LbopKeyVerifier {
+    wrappedKey: object;
+    key: object;
+}
+export interface PassKey {
+    id: string;
+    passKeyParams?: PassKeyParams;
+    passIdpParams?: PassIdpParams;
+    wrappedPassIdpVerifierPrk?: object;
+    created?: string;
+}
+export interface KeyLink {
+    keyId: string;
+    wrappingKeyId: string;
+    wrappedKey: string;
+}
+export interface PassKeyLink {
+    keyId: string;
+    passKeyId: string;
+    wrappedKey: string;
+}
+export declare enum NodeType {
+    Key = "key",
+    PassKey = "passKey"
+}
+export interface Node {
+    type: NodeType;
+    data: Key | PassKey;
+}
+export declare enum EdgeType {
+    KeyLink = "keyLink",
+    PassKeyLink = "passKeyLink"
+}
+export interface Edge {
+    type: EdgeType;
+    data: KeyLink | PassKeyLink;
+}
+export interface KeyGraphResponse {
+    keys?: Key[];
+    keyLinks?: KeyLink[];
+    passKeys?: PassKey[];
+    passKeyLinks?: PassKeyLink[];
+}
+export interface HasKeyGraph {
+    keyGraph?: KeyGraphResponse;
+}
+export declare type PayloadType = 'json' | 'ArrayBuffer';
+export interface DeriveKeyResult {
+    jwk: JWK.Key;
+}
+export interface DerivePassIdpParams extends PassIdpParams {
+    password: string;
+}
+export interface DerivePassKeyParams extends PassKeyParams {
+    password: string;
+}
+export interface DeriveLbopKeyParams extends PassKeyParams {
+    password: string;
+}

package/lib/cryptography/encryption.service.d.ts

@@ -1,41 +1,41 @@
-/// <reference types="node" />
-import { JWE, JWK } from 'node-jose';
-import { Key, PayloadType } from './cryptography.types';
-import { TimeService } from '../api/time.service';
-export declare enum JoseSerialization {
-    JSON = "JSON",
-    COMPACT = "COMPACT"
-}
-export interface VerifyOptions {
-    payloadType?: PayloadType;
-    returnOnlyPayload?: boolean;
-}
-export interface DecryptOptions {
-    payloadType?: PayloadType;
-    returnOnlyPayload?: boolean;
-    serializations?: JoseSerialization[];
-}
-export declare const VERIFY_OPTIONS_DEFAULT: VerifyOptions;
-export declare const DECRYPT_OPTIONS_DEFAULT: DecryptOptions;
-export declare function isSymmetricKey(key: JWK.Key): boolean;
-export declare function asJwk(key: JWK.Key | Key | any): JWK.Key | null;
-export declare class EncryptionService {
-    private timeService;
-    constructor(timeService: TimeService);
-    decrypt(key: JWK.Key | Key, // string is assumed to be key.id, will unwrap key.
-    jwe: object | string, // string will be JSON.parsed
-    options?: DecryptOptions): Promise<JWE.DecryptResult | any>;
-    encryptToString(key: JWK.Key, content: ArrayBuffer | string | object): Promise<string>;
-    encrypt(key: JWK.Key, content: ArrayBuffer | string | object): Promise<any>;
-    sign(key: JWK.Key, content: Buffer | string | object): Promise<any>;
-    signToString(key: JWK.Key, content: Buffer | string | object): Promise<string>;
-    verify(key: JWK.Key, jws: object, options?: VerifyOptions): Promise<any>;
-    encryptThenSign({ key, sigPrk, }: {
-        key: JWK.Key;
-        sigPrk: JWK.Key;
-    }, content: ArrayBuffer | string | object): Promise<{
-        cipher: string;
-        sig: string;
-    }>;
-    private decodePayload;
-}
+/// <reference types="node" />
+import { JWE, JWK } from 'node-jose';
+import { Key, PayloadType } from './cryptography.types';
+import { TimeService } from '../api/time.service';
+export declare enum JoseSerialization {
+    JSON = "JSON",
+    COMPACT = "COMPACT"
+}
+export interface VerifyOptions {
+    payloadType?: PayloadType;
+    returnOnlyPayload?: boolean;
+}
+export interface DecryptOptions {
+    payloadType?: PayloadType;
+    returnOnlyPayload?: boolean;
+    serializations?: JoseSerialization[];
+}
+export declare const VERIFY_OPTIONS_DEFAULT: VerifyOptions;
+export declare const DECRYPT_OPTIONS_DEFAULT: DecryptOptions;
+export declare function isSymmetricKey(key: JWK.Key): boolean;
+export declare function asJwk(key: JWK.Key | Key | any): JWK.Key | null;
+export declare class EncryptionService {
+    private timeService;
+    constructor(timeService: TimeService);
+    decrypt(key: JWK.Key | Key, // string is assumed to be key.id, will unwrap key.
+    jwe: object | string, // string will be JSON.parsed
+    options?: DecryptOptions): Promise<JWE.DecryptResult | any>;
+    encryptToString(key: JWK.Key, content: ArrayBuffer | string | object): Promise<string>;
+    encrypt(key: JWK.Key, content: ArrayBuffer | string | object): Promise<any>;
+    sign(key: JWK.Key, content: Buffer | string | object): Promise<any>;
+    signToString(key: JWK.Key, content: Buffer | string | object): Promise<string>;
+    verify(key: JWK.Key, jws: object, options?: VerifyOptions): Promise<any>;
+    encryptThenSign({ key, sigPrk, }: {
+        key: JWK.Key;
+        sigPrk: JWK.Key;
+    }, content: ArrayBuffer | string | object): Promise<{
+        cipher: string;
+        sig: string;
+    }>;
+    private decodePayload;
+}

package/lib/cryptography/key-factory.service.d.ts

@@ -1,38 +1,38 @@
-/// <reference types="node" />
-import { JWK } from 'node-jose';
-import { LbopKeyParams, PassIdpParams, PassKeyParams, DeriveKeyResult, DerivePassIdpParams, DerivePassKeyParams, DeriveLbopKeyParams } from './cryptography.types';
-import { WebCryptoService } from './web-crypto.service';
-export declare function sha256(message: any): Promise<string>;
-export declare class KeyFactoryService {
-    private webCryptoService;
-    constructor(webCryptoService: WebCryptoService);
-    private readonly crypto;
-    readonly MIN_PASS_IDP_PBKDF_ITER = 100000;
-    readonly MIN_PASS_KEY_PBKDF_ITER = 100000;
-    readonly MIN_LBOP_KEY_PBKDF_ITER = 100000;
-    readonly DEFAULT_PASS_IDP_PBKDF_ITER = 100000;
-    readonly DEFAULT_PASS_KEY_PBKDF_ITER = 100000;
-    readonly DEFAULT_LBOP_KEY_PBKDF_ITER = 100000;
-    static asKey(key: string | Buffer | object | JWK.RawKey, form?: 'json' | 'private' | 'pkcs8' | 'public' | 'spki' | 'pkix' | 'x509' | 'pem', extras?: Record<string, unknown>): Promise<JWK.Key>;
-    randomString(digits: number): string;
-    randomDigitsNoZeros(digits: number): string;
-    randomChoices<T>(array: T[], chooseN: number): T[];
-    createSalt(): string;
-    createKey(): Promise<JWK.Key>;
-    createSignKey(): Promise<JWK.Key>;
-    createPkcKey(): Promise<JWK.Key>;
-    createPkcSignKey(): Promise<JWK.Key>;
-    deriveKey({ password, salt, iterations, kid, }: {
-        password: string;
-        salt: string;
-        iterations: number;
-        kid?: string;
-    }): Promise<DeriveKeyResult>;
-    derivePassIdp(params: DerivePassIdpParams): Promise<DeriveKeyResult>;
-    derivePassKey(params: DerivePassKeyParams): Promise<DeriveKeyResult>;
-    deriveLbopKey(params: DeriveLbopKeyParams): Promise<DeriveKeyResult>;
-    createKid(): Promise<string>;
-    createPassIdpParams(): Promise<PassIdpParams>;
-    createPassKeyParams(): Promise<PassKeyParams>;
-    createLbopKeyParams(): Promise<LbopKeyParams>;
-}
+/// <reference types="node" />
+import { JWK } from 'node-jose';
+import { LbopKeyParams, PassIdpParams, PassKeyParams, DeriveKeyResult, DerivePassIdpParams, DerivePassKeyParams, DeriveLbopKeyParams } from './cryptography.types';
+import { WebCryptoService } from './web-crypto.service';
+export declare function sha256(message: any): Promise<string>;
+export declare class KeyFactoryService {
+    private webCryptoService;
+    constructor(webCryptoService: WebCryptoService);
+    private readonly crypto;
+    readonly MIN_PASS_IDP_PBKDF_ITER = 100000;
+    readonly MIN_PASS_KEY_PBKDF_ITER = 100000;
+    readonly MIN_LBOP_KEY_PBKDF_ITER = 100000;
+    readonly DEFAULT_PASS_IDP_PBKDF_ITER = 100000;
+    readonly DEFAULT_PASS_KEY_PBKDF_ITER = 100000;
+    readonly DEFAULT_LBOP_KEY_PBKDF_ITER = 100000;
+    static asKey(key: string | Buffer | object | JWK.RawKey, form?: 'json' | 'private' | 'pkcs8' | 'public' | 'spki' | 'pkix' | 'x509' | 'pem', extras?: Record<string, unknown>): Promise<JWK.Key>;
+    randomString(digits: number): string;
+    randomDigitsNoZeros(digits: number): string;
+    randomChoices<T>(array: T[], chooseN: number): T[];
+    createSalt(): string;
+    createKey(): Promise<JWK.Key>;
+    createSignKey(): Promise<JWK.Key>;
+    createPkcKey(): Promise<JWK.Key>;
+    createPkcSignKey(): Promise<JWK.Key>;
+    deriveKey({ password, salt, iterations, kid, }: {
+        password: string;
+        salt: string;
+        iterations: number;
+        kid?: string;
+    }): Promise<DeriveKeyResult>;
+    derivePassIdp(params: DerivePassIdpParams): Promise<DeriveKeyResult>;
+    derivePassKey(params: DerivePassKeyParams): Promise<DeriveKeyResult>;
+    deriveLbopKey(params: DeriveLbopKeyParams): Promise<DeriveKeyResult>;
+    createKid(): Promise<string>;
+    createPassIdpParams(): Promise<PassIdpParams>;
+    createPassKeyParams(): Promise<PassKeyParams>;
+    createLbopKeyParams(): Promise<LbopKeyParams>;
+}

package/lib/cryptography/key-graph.service.d.ts

@@ -1,41 +1,41 @@
-import { JWK } from 'node-jose';
-import { CurrentUserKey } from '../users/profile.types';
-import { Edge, Key, KeyGraphResponse, PassKey } from './cryptography.types';
-import { DecryptOptions, EncryptionService } from './encryption.service';
-import { KeyFactoryService } from './key-factory.service';
-import { KeyService } from './key.service';
-export interface GraphKey extends Key {
-    task?: Promise<any>;
-}
-export declare class KeyGraphService {
-    private encryptionService;
-    private keyService;
-    private keyFactory;
-    private graph;
-    constructor(encryptionService: EncryptionService, keyService: KeyService, keyFactory: KeyFactoryService);
-    purgeKeys(): void;
-    populateKeys(userKey: CurrentUserKey): Promise<void>;
-    hasKey(keyId: string): boolean;
-    private getNode;
-    key(id: any): GraphKey;
-    passKey(id: any): PassKey;
-    addKeys(src: KeyGraphResponse): void;
-    tracePath(distances: any, keyId: string): Edge[];
-    getPath(knownKeyId: string, keyId: string): Edge[];
-    getJwkKey(keyOrId: string | Key, getKeyIdCallback?: () => Promise<string> | string): Promise<JWK.Key>;
-    getKey(keyOrId: string | Key, getKeyIdCallback?: () => Promise<string> | string): Promise<Key>;
-    private _unwrapLink;
-    private _unwrap;
-    unwrapWithPassKey(passKeyId: string, passKey: JWK.Key, keyId: string): Promise<Key>;
-    unwrapKey(masterKeyId: string, keyId: string): Promise<Key>;
-    decryptFromString<T>(keyOrId: string | Key, cipherData: string, options?: DecryptOptions): Promise<T>;
-    decryptFile(keyId: string, file: any): Promise<any>;
-    encryptToString(key: string | Key | JWK.Key, content: any): Promise<string>;
-    wrapKey<T>(wrappingKey: string | Key | JWK.Key, key: JWK.Key): Promise<string>;
-    encryptWithNewKey(wrappingKeyId: string, cipherClearJson: any): Promise<{
-        key: JWK.Key;
-        wrappingKeyId: string;
-        wrappedKey: string;
-        cipher: string;
-    }>;
-}
+import { JWK } from 'node-jose';
+import { CurrentUserKey } from '../users/profile.types';
+import { Edge, Key, KeyGraphResponse, PassKey } from './cryptography.types';
+import { DecryptOptions, EncryptionService } from './encryption.service';
+import { KeyFactoryService } from './key-factory.service';
+import { KeyService } from './key.service';
+export interface GraphKey extends Key {
+    task?: Promise<any>;
+}
+export declare class KeyGraphService {
+    private encryptionService;
+    private keyService;
+    private keyFactory;
+    private graph;
+    constructor(encryptionService: EncryptionService, keyService: KeyService, keyFactory: KeyFactoryService);
+    purgeKeys(): void;
+    populateKeys(userKey: CurrentUserKey): Promise<void>;
+    hasKey(keyId: string): boolean;
+    private getNode;
+    key(id: any): GraphKey;
+    passKey(id: any): PassKey;
+    addKeys(src: KeyGraphResponse): void;
+    tracePath(distances: any, keyId: string): Edge[];
+    getPath(knownKeyId: string, keyId: string): Edge[];
+    getJwkKey(keyOrId: string | Key, getKeyIdCallback?: () => Promise<string> | string): Promise<JWK.Key>;
+    getKey(keyOrId: string | Key, getKeyIdCallback?: () => Promise<string> | string): Promise<Key>;
+    private _unwrapLink;
+    private _unwrap;
+    unwrapWithPassKey(passKeyId: string, passKey: JWK.Key, keyId: string): Promise<Key>;
+    unwrapKey(masterKeyId: string, keyId: string): Promise<Key>;
+    decryptFromString<T>(keyOrId: string | Key, cipherData: string, options?: DecryptOptions): Promise<T>;
+    decryptFile(keyId: string, file: any): Promise<any>;
+    encryptToString(key: string | Key | JWK.Key, content: any): Promise<string>;
+    wrapKey<T>(wrappingKey: string | Key | JWK.Key, key: JWK.Key): Promise<string>;
+    encryptWithNewKey(wrappingKeyId: string, cipherClearJson: any): Promise<{
+        key: JWK.Key;
+        wrappingKeyId: string;
+        wrappedKey: string;
+        cipher: string;
+    }>;
+}

package/lib/cryptography/key-meta.service.d.ts

@@ -1,44 +1,44 @@
-import { JWK } from 'node-jose';
-import { LrApolloService } from '../api/lr-apollo.service';
-import { EncryptionService } from './encryption.service';
-import { KeyFactoryService } from './key-factory.service';
-import { KeyGraphService } from './key-graph.service';
-import { KeyService } from './key.service';
-export interface HasCipherMeta {
-    keyId: string;
-    cipherMeta: string;
-}
-export declare class WrappedContent {
-    key: JWK.Key;
-    cipherMeta: string;
-    wrappedKeys?: WrappingKey[];
-    rootKey?: WrappingKey;
-}
-export declare class WrappingKey {
-    directoryId?: string;
-    wrappingKeyId: string;
-    wrappedKey: string;
-}
-export declare class KeyMetaService {
-    private encryptionService;
-    private keyGraph;
-    private lrApollo;
-    private keyService;
-    private keyFactory;
-    constructor(encryptionService: EncryptionService, keyGraph: KeyGraphService, lrApollo: LrApolloService, keyService: KeyService, keyFactory: KeyFactoryService);
-    decryptMeta<T>(metaHaver: HasCipherMeta): Promise<T>;
-    doubleWrapContent(secureContent: any, categoryIds: string[], fileContent?: ArrayBuffer): Promise<{
-        rootKey: WrappingKey;
-        wrappedKeys: WrappingKey[];
-        doubleWrappedKey: string;
-        cipherMeta: string;
-        cipherFileContent: string;
-    }>;
-    reWrapContent(keyId: string, secureContent: any): Promise<{
-        doubleWrappedKey: string;
-        cipherMeta: string;
-    }>;
-    wrapContent(secureContent: any, categoryIds?: string[]): Promise<WrappedContent>;
-    wrapContentWithKey(secureContent: any, keyId: string): Promise<WrappedContent>;
-    private getCategoryKeyId;
-}
+import { JWK } from 'node-jose';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { EncryptionService } from './encryption.service';
+import { KeyFactoryService } from './key-factory.service';
+import { KeyGraphService } from './key-graph.service';
+import { KeyService } from './key.service';
+export interface HasCipherMeta {
+    keyId: string;
+    cipherMeta: string;
+}
+export declare class WrappedContent {
+    key: JWK.Key;
+    cipherMeta: string;
+    wrappedKeys?: WrappingKey[];
+    rootKey?: WrappingKey;
+}
+export declare class WrappingKey {
+    directoryId?: string;
+    wrappingKeyId: string;
+    wrappedKey: string;
+}
+export declare class KeyMetaService {
+    private encryptionService;
+    private keyGraph;
+    private lrApollo;
+    private keyService;
+    private keyFactory;
+    constructor(encryptionService: EncryptionService, keyGraph: KeyGraphService, lrApollo: LrApolloService, keyService: KeyService, keyFactory: KeyFactoryService);
+    decryptMeta<T>(metaHaver: HasCipherMeta): Promise<T>;
+    doubleWrapContent(secureContent: any, categoryIds: string[], fileContent?: ArrayBuffer): Promise<{
+        rootKey: WrappingKey;
+        wrappedKeys: WrappingKey[];
+        doubleWrappedKey: string;
+        cipherMeta: string;
+        cipherFileContent: string;
+    }>;
+    reWrapContent(keyId: string, secureContent: any): Promise<{
+        doubleWrappedKey: string;
+        cipherMeta: string;
+    }>;
+    wrapContent(secureContent: any, categoryIds?: string[]): Promise<WrappedContent>;
+    wrapContentWithKey(secureContent: any, keyId: string): Promise<WrappedContent>;
+    private getCategoryKeyId;
+}