diff --git a/keeperapi/package.json b/keeperapi/package.json index c69eb235..566e4fd4 100644 --- a/keeperapi/package.json +++ b/keeperapi/package.json @@ -10,8 +10,8 @@ "scripts": { "start": "rollup -cw", "build": "node ./scripts/cleanDistFolder.js && rollup -c && cp src/proto.d.ts dist", - "update-proto:es6": "pbjs -t static-module --force-number -w es6 -o src/proto.js ../../keeperapp-protobuf/APIRequest.proto ../../keeperapp-protobuf/AccountSummary.proto ../../keeperapp-protobuf/automator.proto ../../keeperapp-protobuf/breachwatch.proto ../../keeperapp-protobuf/client.proto ../../keeperapp-protobuf/externalservice.proto ../../keeperapp-protobuf/folder.proto ../../keeperapp-protobuf/push.proto ../../keeperapp-protobuf/record.proto ../../keeperapp-protobuf/servicelogger.proto ../../keeperapp-protobuf/ssocloud.proto ../../keeperapp-protobuf/token.proto ../../keeperapp-protobuf/upsell.proto ../../keeperapp-protobuf/SyncDown.proto ../../keeperapp-protobuf/BI.proto ../../keeperapp-protobuf/router.proto && pbts -o src/proto.d.ts src/proto.js", - "update-proto:cjs": "pbjs -t json-module -w commonjs -o src/proto.js ../../keeperapp-protobuf/APIRequest.proto ../../keeperapp-protobuf/AccountSummary.proto ../../keeperapp-protobuf/automator.proto ../../keeperapp-protobuf/breachwatch.proto ../../keeperapp-protobuf/client.proto ../../keeperapp-protobuf/externalservice.proto ../../keeperapp-protobuf/folder.proto ../../keeperapp-protobuf/push.proto ../../keeperapp-protobuf/record.proto ../../keeperapp-protobuf/servicelogger.proto ../../keeperapp-protobuf/ssocloud.proto ../../keeperapp-protobuf/token.proto ../../keeperapp-protobuf/upsell.proto ../../keeperapp-protobuf/SyncDown.proto ../../keeperapp-protobuf/router.proto && pbjs -t static-module --force-number -w commonjs ../../keeperapp-protobuf/APIRequest.proto ../../keeperapp-protobuf/AccountSummary.proto ../../keeperapp-protobuf/automator.proto ../../keeperapp-protobuf/breachwatch.proto ../../keeperapp-protobuf/client.proto ../../keeperapp-protobuf/externalservice.proto ../../keeperapp-protobuf/folder.proto ../../keeperapp-protobuf/push.proto ../../keeperapp-protobuf/record.proto ../../keeperapp-protobuf/servicelogger.proto ../../keeperapp-protobuf/ssocloud.proto ../../keeperapp-protobuf/token.proto ../../keeperapp-protobuf/upsell.proto ../../keeperapp-protobuf/SyncDown.proto ../../keeperapp-protobuf/BI.proto ../../keeperapp-protobuf/router.proto | pbts -o src/proto.d.ts -", + "update-proto:es6": "pbjs -t static-module --force-number -w es6 -o src/proto.js ../../keeperapp-protobuf/APIRequest.proto ../../keeperapp-protobuf/AccountSummary.proto ../../keeperapp-protobuf/automator.proto ../../keeperapp-protobuf/breachwatch.proto ../../keeperapp-protobuf/client.proto ../../keeperapp-protobuf/externalservice.proto ../../keeperapp-protobuf/folder.proto ../../keeperapp-protobuf/push.proto ../../keeperapp-protobuf/record.proto ../../keeperapp-protobuf/servicelogger.proto ../../keeperapp-protobuf/ssocloud.proto ../../keeperapp-protobuf/token.proto ../../keeperapp-protobuf/upsell.proto ../../keeperapp-protobuf/SyncDown.proto ../../keeperapp-protobuf/BI.proto ../../keeperapp-protobuf/router.proto ../../keeperapp-protobuf/record_endpoints.proto && pbts -o src/proto.d.ts src/proto.js", + "update-proto:cjs": "pbjs -t json-module -w commonjs -o src/proto.js ../../keeperapp-protobuf/APIRequest.proto ../../keeperapp-protobuf/AccountSummary.proto ../../keeperapp-protobuf/automator.proto ../../keeperapp-protobuf/breachwatch.proto ../../keeperapp-protobuf/client.proto ../../keeperapp-protobuf/externalservice.proto ../../keeperapp-protobuf/folder.proto ../../keeperapp-protobuf/push.proto ../../keeperapp-protobuf/record.proto ../../keeperapp-protobuf/servicelogger.proto ../../keeperapp-protobuf/ssocloud.proto ../../keeperapp-protobuf/token.proto ../../keeperapp-protobuf/upsell.proto ../../keeperapp-protobuf/SyncDown.proto ../../keeperapp-protobuf/BI.proto ../../keeperapp-protobuf/router.proto ../../keeperapp-protobuf/record_endpoints.proto && pbjs -t static-module -w commonjs ../../keeperapp-protobuf/APIRequest.proto ../../keeperapp-protobuf/AccountSummary.proto ../../keeperapp-protobuf/automator.proto ../../keeperapp-protobuf/breachwatch.proto ../../keeperapp-protobuf/client.proto ../../keeperapp-protobuf/externalservice.proto ../../keeperapp-protobuf/folder.proto ../../keeperapp-protobuf/push.proto ../../keeperapp-protobuf/record.proto ../../keeperapp-protobuf/servicelogger.proto ../../keeperapp-protobuf/ssocloud.proto ../../keeperapp-protobuf/token.proto ../../keeperapp-protobuf/upsell.proto ../../keeperapp-protobuf/SyncDown.proto ../../keeperapp-protobuf/BI.proto ../../keeperapp-protobuf/router.proto ../../keeperapp-protobuf/record_endpoints.proto | pbts -o src/proto.d.ts -", "format": "prettier --write .", "format:check": "prettier --check .", "test": "jest", diff --git a/keeperapi/src/__tests__/SyncDownResponseBuilder.ts b/keeperapi/src/__tests__/SyncDownResponseBuilder.ts index aee3cbb1..aa40cfb9 100644 --- a/keeperapi/src/__tests__/SyncDownResponseBuilder.ts +++ b/keeperapi/src/__tests__/SyncDownResponseBuilder.ts @@ -78,6 +78,7 @@ export class SyncDownResponseBuilder { removedSharedFolders: [], removedUsers: [], recordRotations: [], + keeperDriveData: {}, } } diff --git a/keeperapi/src/__tests__/syncDown/utils.test.ts b/keeperapi/src/__tests__/syncDown/utils.test.ts new file mode 100644 index 00000000..55296062 --- /dev/null +++ b/keeperapi/src/__tests__/syncDown/utils.test.ts @@ -0,0 +1,13 @@ +import { createKdRecordAccessCompositeKey, createKdFolderAccessCompositeKey } from '../../syncDown' + +describe('createKdRecordAccessCompositeKey', () => { + it('produces actorUid:recordUid format', () => { + expect(createKdRecordAccessCompositeKey('actor1', 'record1')).toBe('actor1:record1') + }) +}) + +describe('createKdFolderAccessCompositeKey', () => { + it('produces folderUid:actorUid format', () => { + expect(createKdFolderAccessCompositeKey('actor1', 'folder1')).toBe('folder1:actor1') + }) +}) diff --git a/keeperapi/src/browser/index.ts b/keeperapi/src/browser/index.ts index c3ac4170..4daff367 100644 --- a/keeperapi/src/browser/index.ts +++ b/keeperapi/src/browser/index.ts @@ -14,6 +14,7 @@ export * from '../proto' export * from '../cryptoWorker' export * from '../qrc' export * from '../pam' +export * from '../syncDown' import { connectPlatform } from '../platform' import { browserPlatform } from './platform' diff --git a/keeperapi/src/node/index.ts b/keeperapi/src/node/index.ts index 81935c72..b6f90feb 100644 --- a/keeperapi/src/node/index.ts +++ b/keeperapi/src/node/index.ts @@ -17,6 +17,7 @@ export * from '../proto' export * from '../cryptoWorker' export * from '../qrc' export * from '../pam' +export * from '../syncDown' import { connectPlatform } from '../platform' import { nodePlatform } from './platform' diff --git a/keeperapi/src/proto.d.ts b/keeperapi/src/proto.d.ts index cc0347e4..3d4ea782 100644 --- a/keeperapi/src/proto.d.ts +++ b/keeperapi/src/proto.d.ts @@ -1711,6 +1711,139 @@ export namespace Authentication { public static getTypeUrl(typeUrlPrefix?: string): string; } + /** Properties of a KeysInfo. */ + interface IKeysInfo { + + /** KeysInfo encryptionParams */ + encryptionParams?: (Uint8Array|null); + + /** KeysInfo encryptedDataKey */ + encryptedDataKey?: (Uint8Array|null); + + /** KeysInfo dataKeyBackupDate */ + dataKeyBackupDate?: (number|null); + + /** KeysInfo userAuthUid */ + userAuthUid?: (Uint8Array|null); + + /** KeysInfo encryptedPrivateKey */ + encryptedPrivateKey?: (Uint8Array|null); + + /** KeysInfo encryptedEccPrivateKey */ + encryptedEccPrivateKey?: (Uint8Array|null); + + /** KeysInfo eccPublicKey */ + eccPublicKey?: (Uint8Array|null); + } + + /** Represents a KeysInfo. */ + class KeysInfo implements IKeysInfo { + + /** + * Constructs a new KeysInfo. + * @param [properties] Properties to set + */ + constructor(properties?: Authentication.IKeysInfo); + + /** KeysInfo encryptionParams. */ + public encryptionParams: Uint8Array; + + /** KeysInfo encryptedDataKey. */ + public encryptedDataKey: Uint8Array; + + /** KeysInfo dataKeyBackupDate. */ + public dataKeyBackupDate: number; + + /** KeysInfo userAuthUid. */ + public userAuthUid: Uint8Array; + + /** KeysInfo encryptedPrivateKey. */ + public encryptedPrivateKey: Uint8Array; + + /** KeysInfo encryptedEccPrivateKey. */ + public encryptedEccPrivateKey: Uint8Array; + + /** KeysInfo eccPublicKey. */ + public eccPublicKey: Uint8Array; + + /** + * Creates a new KeysInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns KeysInfo instance + */ + public static create(properties?: Authentication.IKeysInfo): Authentication.KeysInfo; + + /** + * Encodes the specified KeysInfo message. Does not implicitly {@link Authentication.KeysInfo.verify|verify} messages. + * @param message KeysInfo message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: Authentication.IKeysInfo, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified KeysInfo message, length delimited. Does not implicitly {@link Authentication.KeysInfo.verify|verify} messages. + * @param message KeysInfo message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: Authentication.IKeysInfo, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a KeysInfo message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns KeysInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Authentication.KeysInfo; + + /** + * Decodes a KeysInfo message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns KeysInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Authentication.KeysInfo; + + /** + * Verifies a KeysInfo message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a KeysInfo message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns KeysInfo + */ + public static fromObject(object: { [k: string]: any }): Authentication.KeysInfo; + + /** + * Creates a plain object from a KeysInfo message. Also converts values to other types if specified. + * @param message KeysInfo + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Authentication.KeysInfo, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this KeysInfo to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for KeysInfo + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } + /** Properties of a LoginResponse. */ interface ILoginResponse { @@ -1761,6 +1894,12 @@ export namespace Authentication { /** LoginResponse sessionTokenTypeModifier */ sessionTokenTypeModifier?: (string|null); + + /** LoginResponse keysInfo */ + keysInfo?: (Authentication.IKeysInfo|null); + + /** LoginResponse clientKey */ + clientKey?: (Uint8Array|null); } /** Represents a LoginResponse. */ @@ -1820,6 +1959,12 @@ export namespace Authentication { /** LoginResponse sessionTokenTypeModifier. */ public sessionTokenTypeModifier: string; + /** LoginResponse keysInfo. */ + public keysInfo?: (Authentication.IKeysInfo|null); + + /** LoginResponse clientKey. */ + public clientKey: Uint8Array; + /** * Creates a new LoginResponse instance using the specified properties. * @param [properties] Properties to set @@ -86910,6 +87055,284 @@ export namespace record { public static getTypeUrl(typeUrlPrefix?: string): string; } } + + /** Properties of a RecordsAddRequest. */ + interface IRecordsAddRequest { + + /** RecordsAddRequest records */ + records?: (record.v3.IRecordAdd[]|null); + + /** RecordsAddRequest clientTime */ + clientTime?: (number|null); + + /** RecordsAddRequest securityDataKeyType */ + securityDataKeyType?: (Records.RecordKeyType|null); + } + + /** Represents a RecordsAddRequest. */ + class RecordsAddRequest implements IRecordsAddRequest { + + /** + * Constructs a new RecordsAddRequest. + * @param [properties] Properties to set + */ + constructor(properties?: record.v3.IRecordsAddRequest); + + /** RecordsAddRequest records. */ + public records: record.v3.IRecordAdd[]; + + /** RecordsAddRequest clientTime. */ + public clientTime: number; + + /** RecordsAddRequest securityDataKeyType. */ + public securityDataKeyType: Records.RecordKeyType; + + /** + * Creates a new RecordsAddRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns RecordsAddRequest instance + */ + public static create(properties?: record.v3.IRecordsAddRequest): record.v3.RecordsAddRequest; + + /** + * Encodes the specified RecordsAddRequest message. Does not implicitly {@link record.v3.RecordsAddRequest.verify|verify} messages. + * @param message RecordsAddRequest message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: record.v3.IRecordsAddRequest, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified RecordsAddRequest message, length delimited. Does not implicitly {@link record.v3.RecordsAddRequest.verify|verify} messages. + * @param message RecordsAddRequest message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: record.v3.IRecordsAddRequest, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a RecordsAddRequest message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns RecordsAddRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): record.v3.RecordsAddRequest; + + /** + * Decodes a RecordsAddRequest message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns RecordsAddRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): record.v3.RecordsAddRequest; + + /** + * Verifies a RecordsAddRequest message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a RecordsAddRequest message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns RecordsAddRequest + */ + public static fromObject(object: { [k: string]: any }): record.v3.RecordsAddRequest; + + /** + * Creates a plain object from a RecordsAddRequest message. Also converts values to other types if specified. + * @param message RecordsAddRequest + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: record.v3.RecordsAddRequest, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this RecordsAddRequest to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for RecordsAddRequest + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } + + /** Properties of a RecordAdd. */ + interface IRecordAdd { + + /** RecordAdd recordUid */ + recordUid?: (Uint8Array|null); + + /** RecordAdd recordKey */ + recordKey?: (Uint8Array|null); + + /** RecordAdd recordKeyType */ + recordKeyType?: (Folder.EncryptedKeyType|null); + + /** + * Record creates in root folder is encrypted by user key. + * Record creates in non-root folder is encrypted by folder key. + */ + recordKeyEncryptedBy?: (Folder.FolderKeyEncryptionType|null); + + /** RecordAdd clientModifiedTime */ + clientModifiedTime?: (number|null); + + /** RecordAdd data */ + data?: (Uint8Array|null); + + /** RecordAdd nonSharedData */ + nonSharedData?: (Uint8Array|null); + + /** RecordAdd folderUid */ + folderUid?: (Uint8Array|null); + + /** RecordAdd recordLinks */ + recordLinks?: (Records.IRecordLink[]|null); + + /** RecordAdd audit */ + audit?: (Records.IRecordAudit|null); + + /** RecordAdd securityData */ + securityData?: (Records.ISecurityData|null); + + /** RecordAdd securityScoreData */ + securityScoreData?: (Records.ISecurityScoreData|null); + } + + /** Represents a RecordAdd. */ + class RecordAdd implements IRecordAdd { + + /** + * Constructs a new RecordAdd. + * @param [properties] Properties to set + */ + constructor(properties?: record.v3.IRecordAdd); + + /** RecordAdd recordUid. */ + public recordUid: Uint8Array; + + /** RecordAdd recordKey. */ + public recordKey: Uint8Array; + + /** RecordAdd recordKeyType. */ + public recordKeyType: Folder.EncryptedKeyType; + + /** + * Record creates in root folder is encrypted by user key. + * Record creates in non-root folder is encrypted by folder key. + */ + public recordKeyEncryptedBy: Folder.FolderKeyEncryptionType; + + /** RecordAdd clientModifiedTime. */ + public clientModifiedTime: number; + + /** RecordAdd data. */ + public data: Uint8Array; + + /** RecordAdd nonSharedData. */ + public nonSharedData: Uint8Array; + + /** RecordAdd folderUid. */ + public folderUid: Uint8Array; + + /** RecordAdd recordLinks. */ + public recordLinks: Records.IRecordLink[]; + + /** RecordAdd audit. */ + public audit?: (Records.IRecordAudit|null); + + /** RecordAdd securityData. */ + public securityData?: (Records.ISecurityData|null); + + /** RecordAdd securityScoreData. */ + public securityScoreData?: (Records.ISecurityScoreData|null); + + /** + * Creates a new RecordAdd instance using the specified properties. + * @param [properties] Properties to set + * @returns RecordAdd instance + */ + public static create(properties?: record.v3.IRecordAdd): record.v3.RecordAdd; + + /** + * Encodes the specified RecordAdd message. Does not implicitly {@link record.v3.RecordAdd.verify|verify} messages. + * @param message RecordAdd message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: record.v3.IRecordAdd, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified RecordAdd message, length delimited. Does not implicitly {@link record.v3.RecordAdd.verify|verify} messages. + * @param message RecordAdd message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: record.v3.IRecordAdd, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a RecordAdd message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns RecordAdd + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): record.v3.RecordAdd; + + /** + * Decodes a RecordAdd message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns RecordAdd + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): record.v3.RecordAdd; + + /** + * Verifies a RecordAdd message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a RecordAdd message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns RecordAdd + */ + public static fromObject(object: { [k: string]: any }): record.v3.RecordAdd; + + /** + * Creates a plain object from a RecordAdd message. Also converts values to other types if specified. + * @param message RecordAdd + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: record.v3.RecordAdd, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this RecordAdd to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for RecordAdd + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } } } @@ -102970,6 +103393,12 @@ export namespace Router { /** RouterRecordRotationRequest saasConfiguration */ saasConfiguration?: (Uint8Array|null); + + /** RouterRecordRotationRequest updateServices */ + updateServices?: (boolean|null); + + /** RouterRecordRotationRequest serviceResources */ + serviceResources?: (PAM.IUidList|null); } /** Represents a RouterRecordRotationRequest. */ @@ -103017,6 +103446,12 @@ export namespace Router { /** RouterRecordRotationRequest saasConfiguration. */ public saasConfiguration?: (Uint8Array|null); + /** RouterRecordRotationRequest updateServices. */ + public updateServices?: (boolean|null); + + /** RouterRecordRotationRequest serviceResources. */ + public serviceResources?: (PAM.IUidList|null); + /** * Creates a new RouterRecordRotationRequest instance using the specified properties. * @param [properties] Properties to set @@ -105589,6 +106024,12 @@ export namespace Router { /** PAMNetworkSettings allowedSettings */ allowedSettings?: (Uint8Array|null); + + /** PAMNetworkSettings idpConfigUid */ + idpConfigUid?: (Uint8Array|null); + + /** PAMNetworkSettings adminUid */ + adminUid?: (Uint8Array|null); } /** Represents a PAMNetworkSettings. */ @@ -105603,6 +106044,12 @@ export namespace Router { /** PAMNetworkSettings allowedSettings. */ public allowedSettings: Uint8Array; + /** PAMNetworkSettings idpConfigUid. */ + public idpConfigUid?: (Uint8Array|null); + + /** PAMNetworkSettings adminUid. */ + public adminUid?: (Uint8Array|null); + /** * Creates a new PAMNetworkSettings instance using the specified properties. * @param [properties] Properties to set @@ -109977,6 +110424,9 @@ export namespace PAM { /** PAMResourceConfig keeperAiSettings */ keeperAiSettings?: (Uint8Array|null); + + /** PAMResourceConfig updateServices */ + updateServices?: (boolean|null); } /** Represents a PAMResourceConfig. */ @@ -110015,6 +110465,9 @@ export namespace PAM { /** PAMResourceConfig keeperAiSettings. */ public keeperAiSettings?: (Uint8Array|null); + /** PAMResourceConfig updateServices. */ + public updateServices?: (boolean|null); + /** * Creates a new PAMResourceConfig instance using the specified properties. * @param [properties] Properties to set @@ -111245,4 +111698,307 @@ export namespace PAM { */ public static getTypeUrl(typeUrlPrefix?: string): string; } + + /** Properties of a PAMUniversalSyncPreCheckRequest. */ + interface IPAMUniversalSyncPreCheckRequest { + + /** PAMUniversalSyncPreCheckRequest networkUid */ + networkUid?: (Uint8Array|null); + + /** PAMUniversalSyncPreCheckRequest folderUids */ + folderUids?: (Uint8Array[]|null); + } + + /** Represents a PAMUniversalSyncPreCheckRequest. */ + class PAMUniversalSyncPreCheckRequest implements IPAMUniversalSyncPreCheckRequest { + + /** + * Constructs a new PAMUniversalSyncPreCheckRequest. + * @param [properties] Properties to set + */ + constructor(properties?: PAM.IPAMUniversalSyncPreCheckRequest); + + /** PAMUniversalSyncPreCheckRequest networkUid. */ + public networkUid: Uint8Array; + + /** PAMUniversalSyncPreCheckRequest folderUids. */ + public folderUids: Uint8Array[]; + + /** + * Creates a new PAMUniversalSyncPreCheckRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns PAMUniversalSyncPreCheckRequest instance + */ + public static create(properties?: PAM.IPAMUniversalSyncPreCheckRequest): PAM.PAMUniversalSyncPreCheckRequest; + + /** + * Encodes the specified PAMUniversalSyncPreCheckRequest message. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckRequest.verify|verify} messages. + * @param message PAMUniversalSyncPreCheckRequest message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: PAM.IPAMUniversalSyncPreCheckRequest, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified PAMUniversalSyncPreCheckRequest message, length delimited. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckRequest.verify|verify} messages. + * @param message PAMUniversalSyncPreCheckRequest message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: PAM.IPAMUniversalSyncPreCheckRequest, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PAMUniversalSyncPreCheckRequest message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns PAMUniversalSyncPreCheckRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): PAM.PAMUniversalSyncPreCheckRequest; + + /** + * Decodes a PAMUniversalSyncPreCheckRequest message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns PAMUniversalSyncPreCheckRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): PAM.PAMUniversalSyncPreCheckRequest; + + /** + * Verifies a PAMUniversalSyncPreCheckRequest message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a PAMUniversalSyncPreCheckRequest message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns PAMUniversalSyncPreCheckRequest + */ + public static fromObject(object: { [k: string]: any }): PAM.PAMUniversalSyncPreCheckRequest; + + /** + * Creates a plain object from a PAMUniversalSyncPreCheckRequest message. Also converts values to other types if specified. + * @param message PAMUniversalSyncPreCheckRequest + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: PAM.PAMUniversalSyncPreCheckRequest, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this PAMUniversalSyncPreCheckRequest to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for PAMUniversalSyncPreCheckRequest + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } + + /** Properties of a PAMUniversalSyncPreCheckResult. */ + interface IPAMUniversalSyncPreCheckResult { + + /** PAMUniversalSyncPreCheckResult folderUid */ + folderUid?: (Uint8Array|null); + + /** PAMUniversalSyncPreCheckResult isUsed */ + isUsed?: (boolean|null); + } + + /** Represents a PAMUniversalSyncPreCheckResult. */ + class PAMUniversalSyncPreCheckResult implements IPAMUniversalSyncPreCheckResult { + + /** + * Constructs a new PAMUniversalSyncPreCheckResult. + * @param [properties] Properties to set + */ + constructor(properties?: PAM.IPAMUniversalSyncPreCheckResult); + + /** PAMUniversalSyncPreCheckResult folderUid. */ + public folderUid: Uint8Array; + + /** PAMUniversalSyncPreCheckResult isUsed. */ + public isUsed: boolean; + + /** + * Creates a new PAMUniversalSyncPreCheckResult instance using the specified properties. + * @param [properties] Properties to set + * @returns PAMUniversalSyncPreCheckResult instance + */ + public static create(properties?: PAM.IPAMUniversalSyncPreCheckResult): PAM.PAMUniversalSyncPreCheckResult; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResult message. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResult.verify|verify} messages. + * @param message PAMUniversalSyncPreCheckResult message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: PAM.IPAMUniversalSyncPreCheckResult, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResult message, length delimited. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResult.verify|verify} messages. + * @param message PAMUniversalSyncPreCheckResult message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: PAM.IPAMUniversalSyncPreCheckResult, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PAMUniversalSyncPreCheckResult message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns PAMUniversalSyncPreCheckResult + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): PAM.PAMUniversalSyncPreCheckResult; + + /** + * Decodes a PAMUniversalSyncPreCheckResult message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns PAMUniversalSyncPreCheckResult + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): PAM.PAMUniversalSyncPreCheckResult; + + /** + * Verifies a PAMUniversalSyncPreCheckResult message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a PAMUniversalSyncPreCheckResult message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns PAMUniversalSyncPreCheckResult + */ + public static fromObject(object: { [k: string]: any }): PAM.PAMUniversalSyncPreCheckResult; + + /** + * Creates a plain object from a PAMUniversalSyncPreCheckResult message. Also converts values to other types if specified. + * @param message PAMUniversalSyncPreCheckResult + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: PAM.PAMUniversalSyncPreCheckResult, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this PAMUniversalSyncPreCheckResult to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for PAMUniversalSyncPreCheckResult + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } + + /** Properties of a PAMUniversalSyncPreCheckResponse. */ + interface IPAMUniversalSyncPreCheckResponse { + + /** PAMUniversalSyncPreCheckResponse results */ + results?: (PAM.IPAMUniversalSyncPreCheckResult[]|null); + } + + /** Represents a PAMUniversalSyncPreCheckResponse. */ + class PAMUniversalSyncPreCheckResponse implements IPAMUniversalSyncPreCheckResponse { + + /** + * Constructs a new PAMUniversalSyncPreCheckResponse. + * @param [properties] Properties to set + */ + constructor(properties?: PAM.IPAMUniversalSyncPreCheckResponse); + + /** PAMUniversalSyncPreCheckResponse results. */ + public results: PAM.IPAMUniversalSyncPreCheckResult[]; + + /** + * Creates a new PAMUniversalSyncPreCheckResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns PAMUniversalSyncPreCheckResponse instance + */ + public static create(properties?: PAM.IPAMUniversalSyncPreCheckResponse): PAM.PAMUniversalSyncPreCheckResponse; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResponse message. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResponse.verify|verify} messages. + * @param message PAMUniversalSyncPreCheckResponse message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: PAM.IPAMUniversalSyncPreCheckResponse, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResponse message, length delimited. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResponse.verify|verify} messages. + * @param message PAMUniversalSyncPreCheckResponse message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: PAM.IPAMUniversalSyncPreCheckResponse, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a PAMUniversalSyncPreCheckResponse message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns PAMUniversalSyncPreCheckResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): PAM.PAMUniversalSyncPreCheckResponse; + + /** + * Decodes a PAMUniversalSyncPreCheckResponse message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns PAMUniversalSyncPreCheckResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): PAM.PAMUniversalSyncPreCheckResponse; + + /** + * Verifies a PAMUniversalSyncPreCheckResponse message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a PAMUniversalSyncPreCheckResponse message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns PAMUniversalSyncPreCheckResponse + */ + public static fromObject(object: { [k: string]: any }): PAM.PAMUniversalSyncPreCheckResponse; + + /** + * Creates a plain object from a PAMUniversalSyncPreCheckResponse message. Also converts values to other types if specified. + * @param message PAMUniversalSyncPreCheckResponse + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: PAM.PAMUniversalSyncPreCheckResponse, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this PAMUniversalSyncPreCheckResponse to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for PAMUniversalSyncPreCheckResponse + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } } diff --git a/keeperapi/src/proto.js b/keeperapi/src/proto.js index 4228f0db..4bccc267 100644 --- a/keeperapi/src/proto.js +++ b/keeperapi/src/proto.js @@ -4939,6 +4939,424 @@ export const Authentication = $root.Authentication = (() => { return StartLoginRequest; })(); + Authentication.KeysInfo = (function() { + + /** + * Properties of a KeysInfo. + * @memberof Authentication + * @interface IKeysInfo + * @property {Uint8Array|null} [encryptionParams] KeysInfo encryptionParams + * @property {Uint8Array|null} [encryptedDataKey] KeysInfo encryptedDataKey + * @property {number|null} [dataKeyBackupDate] KeysInfo dataKeyBackupDate + * @property {Uint8Array|null} [userAuthUid] KeysInfo userAuthUid + * @property {Uint8Array|null} [encryptedPrivateKey] KeysInfo encryptedPrivateKey + * @property {Uint8Array|null} [encryptedEccPrivateKey] KeysInfo encryptedEccPrivateKey + * @property {Uint8Array|null} [eccPublicKey] KeysInfo eccPublicKey + */ + + /** + * Constructs a new KeysInfo. + * @memberof Authentication + * @classdesc Represents a KeysInfo. + * @implements IKeysInfo + * @constructor + * @param {Authentication.IKeysInfo=} [properties] Properties to set + */ + function KeysInfo(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null && keys[i] !== "__proto__") + this[keys[i]] = properties[keys[i]]; + } + + /** + * KeysInfo encryptionParams. + * @member {Uint8Array} encryptionParams + * @memberof Authentication.KeysInfo + * @instance + */ + KeysInfo.prototype.encryptionParams = $util.newBuffer([]); + + /** + * KeysInfo encryptedDataKey. + * @member {Uint8Array} encryptedDataKey + * @memberof Authentication.KeysInfo + * @instance + */ + KeysInfo.prototype.encryptedDataKey = $util.newBuffer([]); + + /** + * KeysInfo dataKeyBackupDate. + * @member {number} dataKeyBackupDate + * @memberof Authentication.KeysInfo + * @instance + */ + KeysInfo.prototype.dataKeyBackupDate = 0; + + /** + * KeysInfo userAuthUid. + * @member {Uint8Array} userAuthUid + * @memberof Authentication.KeysInfo + * @instance + */ + KeysInfo.prototype.userAuthUid = $util.newBuffer([]); + + /** + * KeysInfo encryptedPrivateKey. + * @member {Uint8Array} encryptedPrivateKey + * @memberof Authentication.KeysInfo + * @instance + */ + KeysInfo.prototype.encryptedPrivateKey = $util.newBuffer([]); + + /** + * KeysInfo encryptedEccPrivateKey. + * @member {Uint8Array} encryptedEccPrivateKey + * @memberof Authentication.KeysInfo + * @instance + */ + KeysInfo.prototype.encryptedEccPrivateKey = $util.newBuffer([]); + + /** + * KeysInfo eccPublicKey. + * @member {Uint8Array} eccPublicKey + * @memberof Authentication.KeysInfo + * @instance + */ + KeysInfo.prototype.eccPublicKey = $util.newBuffer([]); + + /** + * Creates a new KeysInfo instance using the specified properties. + * @function create + * @memberof Authentication.KeysInfo + * @static + * @param {Authentication.IKeysInfo=} [properties] Properties to set + * @returns {Authentication.KeysInfo} KeysInfo instance + */ + KeysInfo.create = function create(properties) { + return new KeysInfo(properties); + }; + + /** + * Encodes the specified KeysInfo message. Does not implicitly {@link Authentication.KeysInfo.verify|verify} messages. + * @function encode + * @memberof Authentication.KeysInfo + * @static + * @param {Authentication.IKeysInfo} message KeysInfo message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + KeysInfo.encode = function encode(message, writer, q) { + if (!writer) + writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + if (message.encryptionParams != null && Object.hasOwnProperty.call(message, "encryptionParams")) + writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.encryptionParams); + if (message.encryptedDataKey != null && Object.hasOwnProperty.call(message, "encryptedDataKey")) + writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.encryptedDataKey); + if (message.dataKeyBackupDate != null && Object.hasOwnProperty.call(message, "dataKeyBackupDate")) + writer.uint32(/* id 3, wireType 1 =*/25).double(message.dataKeyBackupDate); + if (message.userAuthUid != null && Object.hasOwnProperty.call(message, "userAuthUid")) + writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.userAuthUid); + if (message.encryptedPrivateKey != null && Object.hasOwnProperty.call(message, "encryptedPrivateKey")) + writer.uint32(/* id 5, wireType 2 =*/42).bytes(message.encryptedPrivateKey); + if (message.encryptedEccPrivateKey != null && Object.hasOwnProperty.call(message, "encryptedEccPrivateKey")) + writer.uint32(/* id 6, wireType 2 =*/50).bytes(message.encryptedEccPrivateKey); + if (message.eccPublicKey != null && Object.hasOwnProperty.call(message, "eccPublicKey")) + writer.uint32(/* id 7, wireType 2 =*/58).bytes(message.eccPublicKey); + return writer; + }; + + /** + * Encodes the specified KeysInfo message, length delimited. Does not implicitly {@link Authentication.KeysInfo.verify|verify} messages. + * @function encodeDelimited + * @memberof Authentication.KeysInfo + * @static + * @param {Authentication.IKeysInfo} message KeysInfo message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + KeysInfo.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a KeysInfo message from the specified reader or buffer. + * @function decode + * @memberof Authentication.KeysInfo + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Authentication.KeysInfo} KeysInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + KeysInfo.decode = function decode(reader, length, error, long) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Authentication.KeysInfo(); + while (reader.pos < end) { + let tag = reader.uint32(); + if (tag === error) + break; + switch (tag >>> 3) { + case 1: { + message.encryptionParams = reader.bytes(); + break; + } + case 2: { + message.encryptedDataKey = reader.bytes(); + break; + } + case 3: { + message.dataKeyBackupDate = reader.double(); + break; + } + case 4: { + message.userAuthUid = reader.bytes(); + break; + } + case 5: { + message.encryptedPrivateKey = reader.bytes(); + break; + } + case 6: { + message.encryptedEccPrivateKey = reader.bytes(); + break; + } + case 7: { + message.eccPublicKey = reader.bytes(); + break; + } + default: + reader.skipType(tag & 7, long); + break; + } + } + return message; + }; + + /** + * Decodes a KeysInfo message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Authentication.KeysInfo + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Authentication.KeysInfo} KeysInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + KeysInfo.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a KeysInfo message. + * @function verify + * @memberof Authentication.KeysInfo + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + KeysInfo.verify = function verify(message, long) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.encryptionParams != null && message.hasOwnProperty("encryptionParams")) + if (!(message.encryptionParams && typeof message.encryptionParams.length === "number" || $util.isString(message.encryptionParams))) + return "encryptionParams: buffer expected"; + if (message.encryptedDataKey != null && message.hasOwnProperty("encryptedDataKey")) + if (!(message.encryptedDataKey && typeof message.encryptedDataKey.length === "number" || $util.isString(message.encryptedDataKey))) + return "encryptedDataKey: buffer expected"; + if (message.dataKeyBackupDate != null && message.hasOwnProperty("dataKeyBackupDate")) + if (typeof message.dataKeyBackupDate !== "number") + return "dataKeyBackupDate: number expected"; + if (message.userAuthUid != null && message.hasOwnProperty("userAuthUid")) + if (!(message.userAuthUid && typeof message.userAuthUid.length === "number" || $util.isString(message.userAuthUid))) + return "userAuthUid: buffer expected"; + if (message.encryptedPrivateKey != null && message.hasOwnProperty("encryptedPrivateKey")) + if (!(message.encryptedPrivateKey && typeof message.encryptedPrivateKey.length === "number" || $util.isString(message.encryptedPrivateKey))) + return "encryptedPrivateKey: buffer expected"; + if (message.encryptedEccPrivateKey != null && message.hasOwnProperty("encryptedEccPrivateKey")) + if (!(message.encryptedEccPrivateKey && typeof message.encryptedEccPrivateKey.length === "number" || $util.isString(message.encryptedEccPrivateKey))) + return "encryptedEccPrivateKey: buffer expected"; + if (message.eccPublicKey != null && message.hasOwnProperty("eccPublicKey")) + if (!(message.eccPublicKey && typeof message.eccPublicKey.length === "number" || $util.isString(message.eccPublicKey))) + return "eccPublicKey: buffer expected"; + return null; + }; + + /** + * Creates a KeysInfo message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Authentication.KeysInfo + * @static + * @param {Object.} object Plain object + * @returns {Authentication.KeysInfo} KeysInfo + */ + KeysInfo.fromObject = function fromObject(object, long) { + if (object instanceof $root.Authentication.KeysInfo) + return object; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let message = new $root.Authentication.KeysInfo(); + if (object.encryptionParams != null) + if (typeof object.encryptionParams === "string") + $util.base64.decode(object.encryptionParams, message.encryptionParams = $util.newBuffer($util.base64.length(object.encryptionParams)), 0); + else if (object.encryptionParams.length >= 0) + message.encryptionParams = object.encryptionParams; + if (object.encryptedDataKey != null) + if (typeof object.encryptedDataKey === "string") + $util.base64.decode(object.encryptedDataKey, message.encryptedDataKey = $util.newBuffer($util.base64.length(object.encryptedDataKey)), 0); + else if (object.encryptedDataKey.length >= 0) + message.encryptedDataKey = object.encryptedDataKey; + if (object.dataKeyBackupDate != null) + message.dataKeyBackupDate = Number(object.dataKeyBackupDate); + if (object.userAuthUid != null) + if (typeof object.userAuthUid === "string") + $util.base64.decode(object.userAuthUid, message.userAuthUid = $util.newBuffer($util.base64.length(object.userAuthUid)), 0); + else if (object.userAuthUid.length >= 0) + message.userAuthUid = object.userAuthUid; + if (object.encryptedPrivateKey != null) + if (typeof object.encryptedPrivateKey === "string") + $util.base64.decode(object.encryptedPrivateKey, message.encryptedPrivateKey = $util.newBuffer($util.base64.length(object.encryptedPrivateKey)), 0); + else if (object.encryptedPrivateKey.length >= 0) + message.encryptedPrivateKey = object.encryptedPrivateKey; + if (object.encryptedEccPrivateKey != null) + if (typeof object.encryptedEccPrivateKey === "string") + $util.base64.decode(object.encryptedEccPrivateKey, message.encryptedEccPrivateKey = $util.newBuffer($util.base64.length(object.encryptedEccPrivateKey)), 0); + else if (object.encryptedEccPrivateKey.length >= 0) + message.encryptedEccPrivateKey = object.encryptedEccPrivateKey; + if (object.eccPublicKey != null) + if (typeof object.eccPublicKey === "string") + $util.base64.decode(object.eccPublicKey, message.eccPublicKey = $util.newBuffer($util.base64.length(object.eccPublicKey)), 0); + else if (object.eccPublicKey.length >= 0) + message.eccPublicKey = object.eccPublicKey; + return message; + }; + + /** + * Creates a plain object from a KeysInfo message. Also converts values to other types if specified. + * @function toObject + * @memberof Authentication.KeysInfo + * @static + * @param {Authentication.KeysInfo} message KeysInfo + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + KeysInfo.toObject = function toObject(message, options, q) { + if (!options) + options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + let object = {}; + if (options.defaults) { + if (options.bytes === String) + object.encryptionParams = ""; + else { + object.encryptionParams = []; + if (options.bytes !== Array) + object.encryptionParams = $util.newBuffer(object.encryptionParams); + } + if (options.bytes === String) + object.encryptedDataKey = ""; + else { + object.encryptedDataKey = []; + if (options.bytes !== Array) + object.encryptedDataKey = $util.newBuffer(object.encryptedDataKey); + } + object.dataKeyBackupDate = 0; + if (options.bytes === String) + object.userAuthUid = ""; + else { + object.userAuthUid = []; + if (options.bytes !== Array) + object.userAuthUid = $util.newBuffer(object.userAuthUid); + } + if (options.bytes === String) + object.encryptedPrivateKey = ""; + else { + object.encryptedPrivateKey = []; + if (options.bytes !== Array) + object.encryptedPrivateKey = $util.newBuffer(object.encryptedPrivateKey); + } + if (options.bytes === String) + object.encryptedEccPrivateKey = ""; + else { + object.encryptedEccPrivateKey = []; + if (options.bytes !== Array) + object.encryptedEccPrivateKey = $util.newBuffer(object.encryptedEccPrivateKey); + } + if (options.bytes === String) + object.eccPublicKey = ""; + else { + object.eccPublicKey = []; + if (options.bytes !== Array) + object.eccPublicKey = $util.newBuffer(object.eccPublicKey); + } + } + if (message.encryptionParams != null && message.hasOwnProperty("encryptionParams")) + object.encryptionParams = options.bytes === String ? $util.base64.encode(message.encryptionParams, 0, message.encryptionParams.length) : options.bytes === Array ? Array.prototype.slice.call(message.encryptionParams) : message.encryptionParams; + if (message.encryptedDataKey != null && message.hasOwnProperty("encryptedDataKey")) + object.encryptedDataKey = options.bytes === String ? $util.base64.encode(message.encryptedDataKey, 0, message.encryptedDataKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.encryptedDataKey) : message.encryptedDataKey; + if (message.dataKeyBackupDate != null && message.hasOwnProperty("dataKeyBackupDate")) + object.dataKeyBackupDate = options.json && !isFinite(message.dataKeyBackupDate) ? String(message.dataKeyBackupDate) : message.dataKeyBackupDate; + if (message.userAuthUid != null && message.hasOwnProperty("userAuthUid")) + object.userAuthUid = options.bytes === String ? $util.base64.encode(message.userAuthUid, 0, message.userAuthUid.length) : options.bytes === Array ? Array.prototype.slice.call(message.userAuthUid) : message.userAuthUid; + if (message.encryptedPrivateKey != null && message.hasOwnProperty("encryptedPrivateKey")) + object.encryptedPrivateKey = options.bytes === String ? $util.base64.encode(message.encryptedPrivateKey, 0, message.encryptedPrivateKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.encryptedPrivateKey) : message.encryptedPrivateKey; + if (message.encryptedEccPrivateKey != null && message.hasOwnProperty("encryptedEccPrivateKey")) + object.encryptedEccPrivateKey = options.bytes === String ? $util.base64.encode(message.encryptedEccPrivateKey, 0, message.encryptedEccPrivateKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.encryptedEccPrivateKey) : message.encryptedEccPrivateKey; + if (message.eccPublicKey != null && message.hasOwnProperty("eccPublicKey")) + object.eccPublicKey = options.bytes === String ? $util.base64.encode(message.eccPublicKey, 0, message.eccPublicKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.eccPublicKey) : message.eccPublicKey; + return object; + }; + + /** + * Converts this KeysInfo to JSON. + * @function toJSON + * @memberof Authentication.KeysInfo + * @instance + * @returns {Object.} JSON object + */ + KeysInfo.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for KeysInfo + * @function getTypeUrl + * @memberof Authentication.KeysInfo + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + KeysInfo.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/Authentication.KeysInfo"; + }; + + return KeysInfo; + })(); + Authentication.LoginResponse = (function() { /** @@ -4961,6 +5379,8 @@ export const Authentication = $root.Authentication = (() => { * @property {string|null} [stateSpecificValue] LoginResponse stateSpecificValue * @property {string|null} [ssoClientVersion] LoginResponse ssoClientVersion * @property {string|null} [sessionTokenTypeModifier] LoginResponse sessionTokenTypeModifier + * @property {Authentication.IKeysInfo|null} [keysInfo] LoginResponse keysInfo + * @property {Uint8Array|null} [clientKey] LoginResponse clientKey */ /** @@ -5108,6 +5528,22 @@ export const Authentication = $root.Authentication = (() => { */ LoginResponse.prototype.sessionTokenTypeModifier = ""; + /** + * LoginResponse keysInfo. + * @member {Authentication.IKeysInfo|null|undefined} keysInfo + * @memberof Authentication.LoginResponse + * @instance + */ + LoginResponse.prototype.keysInfo = null; + + /** + * LoginResponse clientKey. + * @member {Uint8Array} clientKey + * @memberof Authentication.LoginResponse + * @instance + */ + LoginResponse.prototype.clientKey = $util.newBuffer([]); + /** * Creates a new LoginResponse instance using the specified properties. * @function create @@ -5170,6 +5606,10 @@ export const Authentication = $root.Authentication = (() => { writer.uint32(/* id 15, wireType 2 =*/122).string(message.ssoClientVersion); if (message.sessionTokenTypeModifier != null && Object.hasOwnProperty.call(message, "sessionTokenTypeModifier")) writer.uint32(/* id 16, wireType 2 =*/130).string(message.sessionTokenTypeModifier); + if (message.keysInfo != null && Object.hasOwnProperty.call(message, "keysInfo")) + $root.Authentication.KeysInfo.encode(message.keysInfo, writer.uint32(/* id 17, wireType 2 =*/138).fork(), q + 1).ldelim(); + if (message.clientKey != null && Object.hasOwnProperty.call(message, "clientKey")) + writer.uint32(/* id 18, wireType 2 =*/146).bytes(message.clientKey); return writer; }; @@ -5278,6 +5718,14 @@ export const Authentication = $root.Authentication = (() => { message.sessionTokenTypeModifier = reader.string(); break; } + case 17: { + message.keysInfo = $root.Authentication.KeysInfo.decode(reader, reader.uint32(), undefined, long + 1); + break; + } + case 18: { + message.clientKey = reader.bytes(); + break; + } default: reader.skipType(tag & 7, long); break; @@ -5426,6 +5874,14 @@ export const Authentication = $root.Authentication = (() => { if (message.sessionTokenTypeModifier != null && message.hasOwnProperty("sessionTokenTypeModifier")) if (!$util.isString(message.sessionTokenTypeModifier)) return "sessionTokenTypeModifier: string expected"; + if (message.keysInfo != null && message.hasOwnProperty("keysInfo")) { + let error = $root.Authentication.KeysInfo.verify(message.keysInfo, long + 1); + if (error) + return "keysInfo." + error; + } + if (message.clientKey != null && message.hasOwnProperty("clientKey")) + if (!(message.clientKey && typeof message.clientKey.length === "number" || $util.isString(message.clientKey))) + return "clientKey: buffer expected"; return null; }; @@ -5686,6 +6142,16 @@ export const Authentication = $root.Authentication = (() => { message.ssoClientVersion = String(object.ssoClientVersion); if (object.sessionTokenTypeModifier != null) message.sessionTokenTypeModifier = String(object.sessionTokenTypeModifier); + if (object.keysInfo != null) { + if (typeof object.keysInfo !== "object") + throw TypeError(".Authentication.LoginResponse.keysInfo: object expected"); + message.keysInfo = $root.Authentication.KeysInfo.fromObject(object.keysInfo, long + 1); + } + if (object.clientKey != null) + if (typeof object.clientKey === "string") + $util.base64.decode(object.clientKey, message.clientKey = $util.newBuffer($util.base64.length(object.clientKey)), 0); + else if (object.clientKey.length >= 0) + message.clientKey = object.clientKey; return message; }; @@ -5755,6 +6221,14 @@ export const Authentication = $root.Authentication = (() => { object.stateSpecificValue = ""; object.ssoClientVersion = ""; object.sessionTokenTypeModifier = ""; + object.keysInfo = null; + if (options.bytes === String) + object.clientKey = ""; + else { + object.clientKey = []; + if (options.bytes !== Array) + object.clientKey = $util.newBuffer(object.clientKey); + } } if (message.loginState != null && message.hasOwnProperty("loginState")) object.loginState = options.enums === String ? $root.Authentication.LoginState[message.loginState] === undefined ? message.loginState : $root.Authentication.LoginState[message.loginState] : message.loginState; @@ -5794,6 +6268,10 @@ export const Authentication = $root.Authentication = (() => { object.ssoClientVersion = message.ssoClientVersion; if (message.sessionTokenTypeModifier != null && message.hasOwnProperty("sessionTokenTypeModifier")) object.sessionTokenTypeModifier = message.sessionTokenTypeModifier; + if (message.keysInfo != null && message.hasOwnProperty("keysInfo")) + object.keysInfo = $root.Authentication.KeysInfo.toObject(message.keysInfo, options, q + 1); + if (message.clientKey != null && message.hasOwnProperty("clientKey")) + object.clientKey = options.bytes === String ? $util.base64.encode(message.clientKey, 0, message.clientKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.clientKey) : message.clientKey; return object; }; @@ -255936,6 +256414,997 @@ export const record = $root.record = (() => { return sharing; })(); + v3.RecordsAddRequest = (function() { + + /** + * Properties of a RecordsAddRequest. + * @memberof record.v3 + * @interface IRecordsAddRequest + * @property {Array.|null} [records] RecordsAddRequest records + * @property {number|null} [clientTime] RecordsAddRequest clientTime + * @property {Records.RecordKeyType|null} [securityDataKeyType] RecordsAddRequest securityDataKeyType + */ + + /** + * Constructs a new RecordsAddRequest. + * @memberof record.v3 + * @classdesc Represents a RecordsAddRequest. + * @implements IRecordsAddRequest + * @constructor + * @param {record.v3.IRecordsAddRequest=} [properties] Properties to set + */ + function RecordsAddRequest(properties) { + this.records = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null && keys[i] !== "__proto__") + this[keys[i]] = properties[keys[i]]; + } + + /** + * RecordsAddRequest records. + * @member {Array.} records + * @memberof record.v3.RecordsAddRequest + * @instance + */ + RecordsAddRequest.prototype.records = $util.emptyArray; + + /** + * RecordsAddRequest clientTime. + * @member {number} clientTime + * @memberof record.v3.RecordsAddRequest + * @instance + */ + RecordsAddRequest.prototype.clientTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * RecordsAddRequest securityDataKeyType. + * @member {Records.RecordKeyType} securityDataKeyType + * @memberof record.v3.RecordsAddRequest + * @instance + */ + RecordsAddRequest.prototype.securityDataKeyType = 0; + + /** + * Creates a new RecordsAddRequest instance using the specified properties. + * @function create + * @memberof record.v3.RecordsAddRequest + * @static + * @param {record.v3.IRecordsAddRequest=} [properties] Properties to set + * @returns {record.v3.RecordsAddRequest} RecordsAddRequest instance + */ + RecordsAddRequest.create = function create(properties) { + return new RecordsAddRequest(properties); + }; + + /** + * Encodes the specified RecordsAddRequest message. Does not implicitly {@link record.v3.RecordsAddRequest.verify|verify} messages. + * @function encode + * @memberof record.v3.RecordsAddRequest + * @static + * @param {record.v3.IRecordsAddRequest} message RecordsAddRequest message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RecordsAddRequest.encode = function encode(message, writer, q) { + if (!writer) + writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + if (message.records != null && message.records.length) + for (let i = 0; i < message.records.length; ++i) + $root.record.v3.RecordAdd.encode(message.records[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); + if (message.clientTime != null && Object.hasOwnProperty.call(message, "clientTime")) + writer.uint32(/* id 2, wireType 0 =*/16).int64(message.clientTime); + if (message.securityDataKeyType != null && Object.hasOwnProperty.call(message, "securityDataKeyType")) + writer.uint32(/* id 3, wireType 0 =*/24).int32(message.securityDataKeyType); + return writer; + }; + + /** + * Encodes the specified RecordsAddRequest message, length delimited. Does not implicitly {@link record.v3.RecordsAddRequest.verify|verify} messages. + * @function encodeDelimited + * @memberof record.v3.RecordsAddRequest + * @static + * @param {record.v3.IRecordsAddRequest} message RecordsAddRequest message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RecordsAddRequest.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a RecordsAddRequest message from the specified reader or buffer. + * @function decode + * @memberof record.v3.RecordsAddRequest + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {record.v3.RecordsAddRequest} RecordsAddRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RecordsAddRequest.decode = function decode(reader, length, error, long) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.record.v3.RecordsAddRequest(); + while (reader.pos < end) { + let tag = reader.uint32(); + if (tag === error) + break; + switch (tag >>> 3) { + case 1: { + if (!(message.records && message.records.length)) + message.records = []; + message.records.push($root.record.v3.RecordAdd.decode(reader, reader.uint32(), undefined, long + 1)); + break; + } + case 2: { + message.clientTime = reader.int64(); + break; + } + case 3: { + message.securityDataKeyType = reader.int32(); + break; + } + default: + reader.skipType(tag & 7, long); + break; + } + } + return message; + }; + + /** + * Decodes a RecordsAddRequest message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof record.v3.RecordsAddRequest + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {record.v3.RecordsAddRequest} RecordsAddRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RecordsAddRequest.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a RecordsAddRequest message. + * @function verify + * @memberof record.v3.RecordsAddRequest + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + RecordsAddRequest.verify = function verify(message, long) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.records != null && message.hasOwnProperty("records")) { + if (!Array.isArray(message.records)) + return "records: array expected"; + for (let i = 0; i < message.records.length; ++i) { + let error = $root.record.v3.RecordAdd.verify(message.records[i], long + 1); + if (error) + return "records." + error; + } + } + if (message.clientTime != null && message.hasOwnProperty("clientTime")) + if (!$util.isInteger(message.clientTime) && !(message.clientTime && $util.isInteger(message.clientTime.low) && $util.isInteger(message.clientTime.high))) + return "clientTime: integer|Long expected"; + if (message.securityDataKeyType != null && message.hasOwnProperty("securityDataKeyType")) + switch (message.securityDataKeyType) { + default: + return "securityDataKeyType: enum value expected"; + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + break; + } + return null; + }; + + /** + * Creates a RecordsAddRequest message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof record.v3.RecordsAddRequest + * @static + * @param {Object.} object Plain object + * @returns {record.v3.RecordsAddRequest} RecordsAddRequest + */ + RecordsAddRequest.fromObject = function fromObject(object, long) { + if (object instanceof $root.record.v3.RecordsAddRequest) + return object; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let message = new $root.record.v3.RecordsAddRequest(); + if (object.records) { + if (!Array.isArray(object.records)) + throw TypeError(".record.v3.RecordsAddRequest.records: array expected"); + message.records = []; + for (let i = 0; i < object.records.length; ++i) { + if (typeof object.records[i] !== "object") + throw TypeError(".record.v3.RecordsAddRequest.records: object expected"); + message.records[i] = $root.record.v3.RecordAdd.fromObject(object.records[i], long + 1); + } + } + if (object.clientTime != null) + if ($util.Long) + message.clientTime = $util.Long.fromValue(object.clientTime, false); + else if (typeof object.clientTime === "string") + message.clientTime = parseInt(object.clientTime, 10); + else if (typeof object.clientTime === "number") + message.clientTime = object.clientTime; + else if (typeof object.clientTime === "object") + message.clientTime = new $util.LongBits(object.clientTime.low >>> 0, object.clientTime.high >>> 0).toNumber(); + switch (object.securityDataKeyType) { + default: + if (typeof object.securityDataKeyType === "number") { + message.securityDataKeyType = object.securityDataKeyType; + break; + } + break; + case "NO_KEY": + case 0: + message.securityDataKeyType = 0; + break; + case "ENCRYPTED_BY_DATA_KEY": + case 1: + message.securityDataKeyType = 1; + break; + case "ENCRYPTED_BY_PUBLIC_KEY": + case 2: + message.securityDataKeyType = 2; + break; + case "ENCRYPTED_BY_DATA_KEY_GCM": + case 3: + message.securityDataKeyType = 3; + break; + case "ENCRYPTED_BY_PUBLIC_KEY_ECC": + case 4: + message.securityDataKeyType = 4; + break; + case "ENCRYPTED_BY_ROOT_KEY_CBC": + case 5: + message.securityDataKeyType = 5; + break; + case "ENCRYPTED_BY_ROOT_KEY_GCM": + case 6: + message.securityDataKeyType = 6; + break; + } + return message; + }; + + /** + * Creates a plain object from a RecordsAddRequest message. Also converts values to other types if specified. + * @function toObject + * @memberof record.v3.RecordsAddRequest + * @static + * @param {record.v3.RecordsAddRequest} message RecordsAddRequest + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + RecordsAddRequest.toObject = function toObject(message, options, q) { + if (!options) + options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + let object = {}; + if (options.arrays || options.defaults) + object.records = []; + if (options.defaults) { + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.clientTime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; + } else + object.clientTime = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; + object.securityDataKeyType = options.enums === String ? "NO_KEY" : 0; + } + if (message.records && message.records.length) { + object.records = []; + for (let j = 0; j < message.records.length; ++j) + object.records[j] = $root.record.v3.RecordAdd.toObject(message.records[j], options, q + 1); + } + if (message.clientTime != null && message.hasOwnProperty("clientTime")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.clientTime = typeof message.clientTime === "number" ? BigInt(message.clientTime) : $util.Long.fromBits(message.clientTime.low >>> 0, message.clientTime.high >>> 0, false).toBigInt(); + else if (typeof message.clientTime === "number") + object.clientTime = options.longs === String ? String(message.clientTime) : message.clientTime; + else + object.clientTime = options.longs === String ? $util.Long.prototype.toString.call(message.clientTime) : options.longs === Number ? new $util.LongBits(message.clientTime.low >>> 0, message.clientTime.high >>> 0).toNumber() : message.clientTime; + if (message.securityDataKeyType != null && message.hasOwnProperty("securityDataKeyType")) + object.securityDataKeyType = options.enums === String ? $root.Records.RecordKeyType[message.securityDataKeyType] === undefined ? message.securityDataKeyType : $root.Records.RecordKeyType[message.securityDataKeyType] : message.securityDataKeyType; + return object; + }; + + /** + * Converts this RecordsAddRequest to JSON. + * @function toJSON + * @memberof record.v3.RecordsAddRequest + * @instance + * @returns {Object.} JSON object + */ + RecordsAddRequest.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for RecordsAddRequest + * @function getTypeUrl + * @memberof record.v3.RecordsAddRequest + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + RecordsAddRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/record.v3.RecordsAddRequest"; + }; + + return RecordsAddRequest; + })(); + + v3.RecordAdd = (function() { + + /** + * Properties of a RecordAdd. + * @memberof record.v3 + * @interface IRecordAdd + * @property {Uint8Array|null} [recordUid] RecordAdd recordUid + * @property {Uint8Array|null} [recordKey] RecordAdd recordKey + * @property {Folder.EncryptedKeyType|null} [recordKeyType] RecordAdd recordKeyType + * @property {Folder.FolderKeyEncryptionType|null} [recordKeyEncryptedBy] Record creates in root folder is encrypted by user key. + * Record creates in non-root folder is encrypted by folder key. + * @property {number|null} [clientModifiedTime] RecordAdd clientModifiedTime + * @property {Uint8Array|null} [data] RecordAdd data + * @property {Uint8Array|null} [nonSharedData] RecordAdd nonSharedData + * @property {Uint8Array|null} [folderUid] RecordAdd folderUid + * @property {Array.|null} [recordLinks] RecordAdd recordLinks + * @property {Records.IRecordAudit|null} [audit] RecordAdd audit + * @property {Records.ISecurityData|null} [securityData] RecordAdd securityData + * @property {Records.ISecurityScoreData|null} [securityScoreData] RecordAdd securityScoreData + */ + + /** + * Constructs a new RecordAdd. + * @memberof record.v3 + * @classdesc Represents a RecordAdd. + * @implements IRecordAdd + * @constructor + * @param {record.v3.IRecordAdd=} [properties] Properties to set + */ + function RecordAdd(properties) { + this.recordLinks = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null && keys[i] !== "__proto__") + this[keys[i]] = properties[keys[i]]; + } + + /** + * RecordAdd recordUid. + * @member {Uint8Array} recordUid + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.recordUid = $util.newBuffer([]); + + /** + * RecordAdd recordKey. + * @member {Uint8Array} recordKey + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.recordKey = $util.newBuffer([]); + + /** + * RecordAdd recordKeyType. + * @member {Folder.EncryptedKeyType} recordKeyType + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.recordKeyType = 0; + + /** + * Record creates in root folder is encrypted by user key. + * Record creates in non-root folder is encrypted by folder key. + * @member {Folder.FolderKeyEncryptionType} recordKeyEncryptedBy + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.recordKeyEncryptedBy = 0; + + /** + * RecordAdd clientModifiedTime. + * @member {number} clientModifiedTime + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.clientModifiedTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * RecordAdd data. + * @member {Uint8Array} data + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.data = $util.newBuffer([]); + + /** + * RecordAdd nonSharedData. + * @member {Uint8Array} nonSharedData + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.nonSharedData = $util.newBuffer([]); + + /** + * RecordAdd folderUid. + * @member {Uint8Array} folderUid + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.folderUid = $util.newBuffer([]); + + /** + * RecordAdd recordLinks. + * @member {Array.} recordLinks + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.recordLinks = $util.emptyArray; + + /** + * RecordAdd audit. + * @member {Records.IRecordAudit|null|undefined} audit + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.audit = null; + + /** + * RecordAdd securityData. + * @member {Records.ISecurityData|null|undefined} securityData + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.securityData = null; + + /** + * RecordAdd securityScoreData. + * @member {Records.ISecurityScoreData|null|undefined} securityScoreData + * @memberof record.v3.RecordAdd + * @instance + */ + RecordAdd.prototype.securityScoreData = null; + + /** + * Creates a new RecordAdd instance using the specified properties. + * @function create + * @memberof record.v3.RecordAdd + * @static + * @param {record.v3.IRecordAdd=} [properties] Properties to set + * @returns {record.v3.RecordAdd} RecordAdd instance + */ + RecordAdd.create = function create(properties) { + return new RecordAdd(properties); + }; + + /** + * Encodes the specified RecordAdd message. Does not implicitly {@link record.v3.RecordAdd.verify|verify} messages. + * @function encode + * @memberof record.v3.RecordAdd + * @static + * @param {record.v3.IRecordAdd} message RecordAdd message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RecordAdd.encode = function encode(message, writer, q) { + if (!writer) + writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + if (message.recordUid != null && Object.hasOwnProperty.call(message, "recordUid")) + writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.recordUid); + if (message.recordKey != null && Object.hasOwnProperty.call(message, "recordKey")) + writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.recordKey); + if (message.recordKeyType != null && Object.hasOwnProperty.call(message, "recordKeyType")) + writer.uint32(/* id 3, wireType 0 =*/24).int32(message.recordKeyType); + if (message.recordKeyEncryptedBy != null && Object.hasOwnProperty.call(message, "recordKeyEncryptedBy")) + writer.uint32(/* id 4, wireType 0 =*/32).int32(message.recordKeyEncryptedBy); + if (message.clientModifiedTime != null && Object.hasOwnProperty.call(message, "clientModifiedTime")) + writer.uint32(/* id 5, wireType 0 =*/40).int64(message.clientModifiedTime); + if (message.data != null && Object.hasOwnProperty.call(message, "data")) + writer.uint32(/* id 6, wireType 2 =*/50).bytes(message.data); + if (message.nonSharedData != null && Object.hasOwnProperty.call(message, "nonSharedData")) + writer.uint32(/* id 7, wireType 2 =*/58).bytes(message.nonSharedData); + if (message.folderUid != null && Object.hasOwnProperty.call(message, "folderUid")) + writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.folderUid); + if (message.recordLinks != null && message.recordLinks.length) + for (let i = 0; i < message.recordLinks.length; ++i) + $root.Records.RecordLink.encode(message.recordLinks[i], writer.uint32(/* id 9, wireType 2 =*/74).fork(), q + 1).ldelim(); + if (message.audit != null && Object.hasOwnProperty.call(message, "audit")) + $root.Records.RecordAudit.encode(message.audit, writer.uint32(/* id 10, wireType 2 =*/82).fork(), q + 1).ldelim(); + if (message.securityData != null && Object.hasOwnProperty.call(message, "securityData")) + $root.Records.SecurityData.encode(message.securityData, writer.uint32(/* id 11, wireType 2 =*/90).fork(), q + 1).ldelim(); + if (message.securityScoreData != null && Object.hasOwnProperty.call(message, "securityScoreData")) + $root.Records.SecurityScoreData.encode(message.securityScoreData, writer.uint32(/* id 12, wireType 2 =*/98).fork(), q + 1).ldelim(); + return writer; + }; + + /** + * Encodes the specified RecordAdd message, length delimited. Does not implicitly {@link record.v3.RecordAdd.verify|verify} messages. + * @function encodeDelimited + * @memberof record.v3.RecordAdd + * @static + * @param {record.v3.IRecordAdd} message RecordAdd message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RecordAdd.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a RecordAdd message from the specified reader or buffer. + * @function decode + * @memberof record.v3.RecordAdd + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {record.v3.RecordAdd} RecordAdd + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RecordAdd.decode = function decode(reader, length, error, long) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.record.v3.RecordAdd(); + while (reader.pos < end) { + let tag = reader.uint32(); + if (tag === error) + break; + switch (tag >>> 3) { + case 1: { + message.recordUid = reader.bytes(); + break; + } + case 2: { + message.recordKey = reader.bytes(); + break; + } + case 3: { + message.recordKeyType = reader.int32(); + break; + } + case 4: { + message.recordKeyEncryptedBy = reader.int32(); + break; + } + case 5: { + message.clientModifiedTime = reader.int64(); + break; + } + case 6: { + message.data = reader.bytes(); + break; + } + case 7: { + message.nonSharedData = reader.bytes(); + break; + } + case 8: { + message.folderUid = reader.bytes(); + break; + } + case 9: { + if (!(message.recordLinks && message.recordLinks.length)) + message.recordLinks = []; + message.recordLinks.push($root.Records.RecordLink.decode(reader, reader.uint32(), undefined, long + 1)); + break; + } + case 10: { + message.audit = $root.Records.RecordAudit.decode(reader, reader.uint32(), undefined, long + 1); + break; + } + case 11: { + message.securityData = $root.Records.SecurityData.decode(reader, reader.uint32(), undefined, long + 1); + break; + } + case 12: { + message.securityScoreData = $root.Records.SecurityScoreData.decode(reader, reader.uint32(), undefined, long + 1); + break; + } + default: + reader.skipType(tag & 7, long); + break; + } + } + return message; + }; + + /** + * Decodes a RecordAdd message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof record.v3.RecordAdd + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {record.v3.RecordAdd} RecordAdd + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RecordAdd.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a RecordAdd message. + * @function verify + * @memberof record.v3.RecordAdd + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + RecordAdd.verify = function verify(message, long) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.recordUid != null && message.hasOwnProperty("recordUid")) + if (!(message.recordUid && typeof message.recordUid.length === "number" || $util.isString(message.recordUid))) + return "recordUid: buffer expected"; + if (message.recordKey != null && message.hasOwnProperty("recordKey")) + if (!(message.recordKey && typeof message.recordKey.length === "number" || $util.isString(message.recordKey))) + return "recordKey: buffer expected"; + if (message.recordKeyType != null && message.hasOwnProperty("recordKeyType")) + switch (message.recordKeyType) { + default: + return "recordKeyType: enum value expected"; + case 0: + case 1: + case 2: + case 3: + case 4: + break; + } + if (message.recordKeyEncryptedBy != null && message.hasOwnProperty("recordKeyEncryptedBy")) + switch (message.recordKeyEncryptedBy) { + default: + return "recordKeyEncryptedBy: enum value expected"; + case 0: + case 1: + case 2: + break; + } + if (message.clientModifiedTime != null && message.hasOwnProperty("clientModifiedTime")) + if (!$util.isInteger(message.clientModifiedTime) && !(message.clientModifiedTime && $util.isInteger(message.clientModifiedTime.low) && $util.isInteger(message.clientModifiedTime.high))) + return "clientModifiedTime: integer|Long expected"; + if (message.data != null && message.hasOwnProperty("data")) + if (!(message.data && typeof message.data.length === "number" || $util.isString(message.data))) + return "data: buffer expected"; + if (message.nonSharedData != null && message.hasOwnProperty("nonSharedData")) + if (!(message.nonSharedData && typeof message.nonSharedData.length === "number" || $util.isString(message.nonSharedData))) + return "nonSharedData: buffer expected"; + if (message.folderUid != null && message.hasOwnProperty("folderUid")) + if (!(message.folderUid && typeof message.folderUid.length === "number" || $util.isString(message.folderUid))) + return "folderUid: buffer expected"; + if (message.recordLinks != null && message.hasOwnProperty("recordLinks")) { + if (!Array.isArray(message.recordLinks)) + return "recordLinks: array expected"; + for (let i = 0; i < message.recordLinks.length; ++i) { + let error = $root.Records.RecordLink.verify(message.recordLinks[i], long + 1); + if (error) + return "recordLinks." + error; + } + } + if (message.audit != null && message.hasOwnProperty("audit")) { + let error = $root.Records.RecordAudit.verify(message.audit, long + 1); + if (error) + return "audit." + error; + } + if (message.securityData != null && message.hasOwnProperty("securityData")) { + let error = $root.Records.SecurityData.verify(message.securityData, long + 1); + if (error) + return "securityData." + error; + } + if (message.securityScoreData != null && message.hasOwnProperty("securityScoreData")) { + let error = $root.Records.SecurityScoreData.verify(message.securityScoreData, long + 1); + if (error) + return "securityScoreData." + error; + } + return null; + }; + + /** + * Creates a RecordAdd message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof record.v3.RecordAdd + * @static + * @param {Object.} object Plain object + * @returns {record.v3.RecordAdd} RecordAdd + */ + RecordAdd.fromObject = function fromObject(object, long) { + if (object instanceof $root.record.v3.RecordAdd) + return object; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let message = new $root.record.v3.RecordAdd(); + if (object.recordUid != null) + if (typeof object.recordUid === "string") + $util.base64.decode(object.recordUid, message.recordUid = $util.newBuffer($util.base64.length(object.recordUid)), 0); + else if (object.recordUid.length >= 0) + message.recordUid = object.recordUid; + if (object.recordKey != null) + if (typeof object.recordKey === "string") + $util.base64.decode(object.recordKey, message.recordKey = $util.newBuffer($util.base64.length(object.recordKey)), 0); + else if (object.recordKey.length >= 0) + message.recordKey = object.recordKey; + switch (object.recordKeyType) { + default: + if (typeof object.recordKeyType === "number") { + message.recordKeyType = object.recordKeyType; + break; + } + break; + case "no_key": + case 0: + message.recordKeyType = 0; + break; + case "encrypted_by_data_key": + case 1: + message.recordKeyType = 1; + break; + case "encrypted_by_public_key": + case 2: + message.recordKeyType = 2; + break; + case "encrypted_by_data_key_gcm": + case 3: + message.recordKeyType = 3; + break; + case "encrypted_by_public_key_ecc": + case 4: + message.recordKeyType = 4; + break; + } + switch (object.recordKeyEncryptedBy) { + default: + if (typeof object.recordKeyEncryptedBy === "number") { + message.recordKeyEncryptedBy = object.recordKeyEncryptedBy; + break; + } + break; + case "ENCRYPTED_BY_USER_KEY": + case 0: + message.recordKeyEncryptedBy = 0; + break; + case "ENCRYPTED_BY_PARENT_KEY": + case 1: + message.recordKeyEncryptedBy = 1; + break; + case "ENCRYPTED_BY_TEAM_KEY": + case 2: + message.recordKeyEncryptedBy = 2; + break; + } + if (object.clientModifiedTime != null) + if ($util.Long) + message.clientModifiedTime = $util.Long.fromValue(object.clientModifiedTime, false); + else if (typeof object.clientModifiedTime === "string") + message.clientModifiedTime = parseInt(object.clientModifiedTime, 10); + else if (typeof object.clientModifiedTime === "number") + message.clientModifiedTime = object.clientModifiedTime; + else if (typeof object.clientModifiedTime === "object") + message.clientModifiedTime = new $util.LongBits(object.clientModifiedTime.low >>> 0, object.clientModifiedTime.high >>> 0).toNumber(); + if (object.data != null) + if (typeof object.data === "string") + $util.base64.decode(object.data, message.data = $util.newBuffer($util.base64.length(object.data)), 0); + else if (object.data.length >= 0) + message.data = object.data; + if (object.nonSharedData != null) + if (typeof object.nonSharedData === "string") + $util.base64.decode(object.nonSharedData, message.nonSharedData = $util.newBuffer($util.base64.length(object.nonSharedData)), 0); + else if (object.nonSharedData.length >= 0) + message.nonSharedData = object.nonSharedData; + if (object.folderUid != null) + if (typeof object.folderUid === "string") + $util.base64.decode(object.folderUid, message.folderUid = $util.newBuffer($util.base64.length(object.folderUid)), 0); + else if (object.folderUid.length >= 0) + message.folderUid = object.folderUid; + if (object.recordLinks) { + if (!Array.isArray(object.recordLinks)) + throw TypeError(".record.v3.RecordAdd.recordLinks: array expected"); + message.recordLinks = []; + for (let i = 0; i < object.recordLinks.length; ++i) { + if (typeof object.recordLinks[i] !== "object") + throw TypeError(".record.v3.RecordAdd.recordLinks: object expected"); + message.recordLinks[i] = $root.Records.RecordLink.fromObject(object.recordLinks[i], long + 1); + } + } + if (object.audit != null) { + if (typeof object.audit !== "object") + throw TypeError(".record.v3.RecordAdd.audit: object expected"); + message.audit = $root.Records.RecordAudit.fromObject(object.audit, long + 1); + } + if (object.securityData != null) { + if (typeof object.securityData !== "object") + throw TypeError(".record.v3.RecordAdd.securityData: object expected"); + message.securityData = $root.Records.SecurityData.fromObject(object.securityData, long + 1); + } + if (object.securityScoreData != null) { + if (typeof object.securityScoreData !== "object") + throw TypeError(".record.v3.RecordAdd.securityScoreData: object expected"); + message.securityScoreData = $root.Records.SecurityScoreData.fromObject(object.securityScoreData, long + 1); + } + return message; + }; + + /** + * Creates a plain object from a RecordAdd message. Also converts values to other types if specified. + * @function toObject + * @memberof record.v3.RecordAdd + * @static + * @param {record.v3.RecordAdd} message RecordAdd + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + RecordAdd.toObject = function toObject(message, options, q) { + if (!options) + options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + let object = {}; + if (options.arrays || options.defaults) + object.recordLinks = []; + if (options.defaults) { + if (options.bytes === String) + object.recordUid = ""; + else { + object.recordUid = []; + if (options.bytes !== Array) + object.recordUid = $util.newBuffer(object.recordUid); + } + if (options.bytes === String) + object.recordKey = ""; + else { + object.recordKey = []; + if (options.bytes !== Array) + object.recordKey = $util.newBuffer(object.recordKey); + } + object.recordKeyType = options.enums === String ? "no_key" : 0; + object.recordKeyEncryptedBy = options.enums === String ? "ENCRYPTED_BY_USER_KEY" : 0; + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.clientModifiedTime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; + } else + object.clientModifiedTime = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; + if (options.bytes === String) + object.data = ""; + else { + object.data = []; + if (options.bytes !== Array) + object.data = $util.newBuffer(object.data); + } + if (options.bytes === String) + object.nonSharedData = ""; + else { + object.nonSharedData = []; + if (options.bytes !== Array) + object.nonSharedData = $util.newBuffer(object.nonSharedData); + } + if (options.bytes === String) + object.folderUid = ""; + else { + object.folderUid = []; + if (options.bytes !== Array) + object.folderUid = $util.newBuffer(object.folderUid); + } + object.audit = null; + object.securityData = null; + object.securityScoreData = null; + } + if (message.recordUid != null && message.hasOwnProperty("recordUid")) + object.recordUid = options.bytes === String ? $util.base64.encode(message.recordUid, 0, message.recordUid.length) : options.bytes === Array ? Array.prototype.slice.call(message.recordUid) : message.recordUid; + if (message.recordKey != null && message.hasOwnProperty("recordKey")) + object.recordKey = options.bytes === String ? $util.base64.encode(message.recordKey, 0, message.recordKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.recordKey) : message.recordKey; + if (message.recordKeyType != null && message.hasOwnProperty("recordKeyType")) + object.recordKeyType = options.enums === String ? $root.Folder.EncryptedKeyType[message.recordKeyType] === undefined ? message.recordKeyType : $root.Folder.EncryptedKeyType[message.recordKeyType] : message.recordKeyType; + if (message.recordKeyEncryptedBy != null && message.hasOwnProperty("recordKeyEncryptedBy")) + object.recordKeyEncryptedBy = options.enums === String ? $root.Folder.FolderKeyEncryptionType[message.recordKeyEncryptedBy] === undefined ? message.recordKeyEncryptedBy : $root.Folder.FolderKeyEncryptionType[message.recordKeyEncryptedBy] : message.recordKeyEncryptedBy; + if (message.clientModifiedTime != null && message.hasOwnProperty("clientModifiedTime")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.clientModifiedTime = typeof message.clientModifiedTime === "number" ? BigInt(message.clientModifiedTime) : $util.Long.fromBits(message.clientModifiedTime.low >>> 0, message.clientModifiedTime.high >>> 0, false).toBigInt(); + else if (typeof message.clientModifiedTime === "number") + object.clientModifiedTime = options.longs === String ? String(message.clientModifiedTime) : message.clientModifiedTime; + else + object.clientModifiedTime = options.longs === String ? $util.Long.prototype.toString.call(message.clientModifiedTime) : options.longs === Number ? new $util.LongBits(message.clientModifiedTime.low >>> 0, message.clientModifiedTime.high >>> 0).toNumber() : message.clientModifiedTime; + if (message.data != null && message.hasOwnProperty("data")) + object.data = options.bytes === String ? $util.base64.encode(message.data, 0, message.data.length) : options.bytes === Array ? Array.prototype.slice.call(message.data) : message.data; + if (message.nonSharedData != null && message.hasOwnProperty("nonSharedData")) + object.nonSharedData = options.bytes === String ? $util.base64.encode(message.nonSharedData, 0, message.nonSharedData.length) : options.bytes === Array ? Array.prototype.slice.call(message.nonSharedData) : message.nonSharedData; + if (message.folderUid != null && message.hasOwnProperty("folderUid")) + object.folderUid = options.bytes === String ? $util.base64.encode(message.folderUid, 0, message.folderUid.length) : options.bytes === Array ? Array.prototype.slice.call(message.folderUid) : message.folderUid; + if (message.recordLinks && message.recordLinks.length) { + object.recordLinks = []; + for (let j = 0; j < message.recordLinks.length; ++j) + object.recordLinks[j] = $root.Records.RecordLink.toObject(message.recordLinks[j], options, q + 1); + } + if (message.audit != null && message.hasOwnProperty("audit")) + object.audit = $root.Records.RecordAudit.toObject(message.audit, options, q + 1); + if (message.securityData != null && message.hasOwnProperty("securityData")) + object.securityData = $root.Records.SecurityData.toObject(message.securityData, options, q + 1); + if (message.securityScoreData != null && message.hasOwnProperty("securityScoreData")) + object.securityScoreData = $root.Records.SecurityScoreData.toObject(message.securityScoreData, options, q + 1); + return object; + }; + + /** + * Converts this RecordAdd to JSON. + * @function toJSON + * @memberof record.v3.RecordAdd + * @instance + * @returns {Object.} JSON object + */ + RecordAdd.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for RecordAdd + * @function getTypeUrl + * @memberof record.v3.RecordAdd + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + RecordAdd.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/record.v3.RecordAdd"; + }; + + return RecordAdd; + })(); + return v3; })(); @@ -301184,6 +302653,8 @@ export const Router = $root.Router = (() => { * @property {number|null} [clientVersionId] RouterRecordRotationRequest clientVersionId * @property {boolean|null} [noop] RouterRecordRotationRequest noop * @property {Uint8Array|null} [saasConfiguration] RouterRecordRotationRequest saasConfiguration + * @property {boolean|null} [updateServices] RouterRecordRotationRequest updateServices + * @property {PAM.IUidList|null} [serviceResources] RouterRecordRotationRequest serviceResources */ /** @@ -301297,6 +302768,22 @@ export const Router = $root.Router = (() => { */ RouterRecordRotationRequest.prototype.saasConfiguration = null; + /** + * RouterRecordRotationRequest updateServices. + * @member {boolean|null|undefined} updateServices + * @memberof Router.RouterRecordRotationRequest + * @instance + */ + RouterRecordRotationRequest.prototype.updateServices = null; + + /** + * RouterRecordRotationRequest serviceResources. + * @member {PAM.IUidList|null|undefined} serviceResources + * @memberof Router.RouterRecordRotationRequest + * @instance + */ + RouterRecordRotationRequest.prototype.serviceResources = null; + // OneOf field names bound to virtual getters and setters let $oneOfFields; @@ -301306,6 +302793,18 @@ export const Router = $root.Router = (() => { set: $util.oneOfSetter($oneOfFields) }); + // Virtual OneOf for proto3 optional field + Object.defineProperty(RouterRecordRotationRequest.prototype, "_updateServices", { + get: $util.oneOfGetter($oneOfFields = ["updateServices"]), + set: $util.oneOfSetter($oneOfFields) + }); + + // Virtual OneOf for proto3 optional field + Object.defineProperty(RouterRecordRotationRequest.prototype, "_serviceResources", { + get: $util.oneOfGetter($oneOfFields = ["serviceResources"]), + set: $util.oneOfSetter($oneOfFields) + }); + /** * Creates a new RouterRecordRotationRequest instance using the specified properties. * @function create @@ -301358,6 +302857,10 @@ export const Router = $root.Router = (() => { writer.uint32(/* id 11, wireType 0 =*/88).bool(message.noop); if (message.saasConfiguration != null && Object.hasOwnProperty.call(message, "saasConfiguration")) writer.uint32(/* id 12, wireType 2 =*/98).bytes(message.saasConfiguration); + if (message.updateServices != null && Object.hasOwnProperty.call(message, "updateServices")) + writer.uint32(/* id 13, wireType 0 =*/104).bool(message.updateServices); + if (message.serviceResources != null && Object.hasOwnProperty.call(message, "serviceResources")) + $root.PAM.UidList.encode(message.serviceResources, writer.uint32(/* id 14, wireType 2 =*/114).fork(), q + 1).ldelim(); return writer; }; @@ -301446,6 +302949,14 @@ export const Router = $root.Router = (() => { message.saasConfiguration = reader.bytes(); break; } + case 13: { + message.updateServices = reader.bool(); + break; + } + case 14: { + message.serviceResources = $root.PAM.UidList.decode(reader, reader.uint32(), undefined, long + 1); + break; + } default: reader.skipType(tag & 7, long); break; @@ -301524,6 +303035,19 @@ export const Router = $root.Router = (() => { if (!(message.saasConfiguration && typeof message.saasConfiguration.length === "number" || $util.isString(message.saasConfiguration))) return "saasConfiguration: buffer expected"; } + if (message.updateServices != null && message.hasOwnProperty("updateServices")) { + properties._updateServices = 1; + if (typeof message.updateServices !== "boolean") + return "updateServices: boolean expected"; + } + if (message.serviceResources != null && message.hasOwnProperty("serviceResources")) { + properties._serviceResources = 1; + { + let error = $root.PAM.UidList.verify(message.serviceResources, long + 1); + if (error) + return "serviceResources." + error; + } + } return null; }; @@ -301596,6 +303120,13 @@ export const Router = $root.Router = (() => { $util.base64.decode(object.saasConfiguration, message.saasConfiguration = $util.newBuffer($util.base64.length(object.saasConfiguration)), 0); else if (object.saasConfiguration.length >= 0) message.saasConfiguration = object.saasConfiguration; + if (object.updateServices != null) + message.updateServices = Boolean(object.updateServices); + if (object.serviceResources != null) { + if (typeof object.serviceResources !== "object") + throw TypeError(".Router.RouterRecordRotationRequest.serviceResources: object expected"); + message.serviceResources = $root.PAM.UidList.fromObject(object.serviceResources, long + 1); + } return message; }; @@ -301698,6 +303229,16 @@ export const Router = $root.Router = (() => { if (options.oneofs) object._saasConfiguration = "saasConfiguration"; } + if (message.updateServices != null && message.hasOwnProperty("updateServices")) { + object.updateServices = message.updateServices; + if (options.oneofs) + object._updateServices = "updateServices"; + } + if (message.serviceResources != null && message.hasOwnProperty("serviceResources")) { + object.serviceResources = $root.PAM.UidList.toObject(message.serviceResources, options, q + 1); + if (options.oneofs) + object._serviceResources = "serviceResources"; + } return object; }; @@ -308256,6 +309797,8 @@ export const Router = $root.Router = (() => { * @memberof Router * @interface IPAMNetworkSettings * @property {Uint8Array|null} [allowedSettings] PAMNetworkSettings allowedSettings + * @property {Uint8Array|null} [idpConfigUid] PAMNetworkSettings idpConfigUid + * @property {Uint8Array|null} [adminUid] PAMNetworkSettings adminUid */ /** @@ -308281,6 +309824,37 @@ export const Router = $root.Router = (() => { */ PAMNetworkSettings.prototype.allowedSettings = $util.newBuffer([]); + /** + * PAMNetworkSettings idpConfigUid. + * @member {Uint8Array|null|undefined} idpConfigUid + * @memberof Router.PAMNetworkSettings + * @instance + */ + PAMNetworkSettings.prototype.idpConfigUid = null; + + /** + * PAMNetworkSettings adminUid. + * @member {Uint8Array|null|undefined} adminUid + * @memberof Router.PAMNetworkSettings + * @instance + */ + PAMNetworkSettings.prototype.adminUid = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + // Virtual OneOf for proto3 optional field + Object.defineProperty(PAMNetworkSettings.prototype, "_idpConfigUid", { + get: $util.oneOfGetter($oneOfFields = ["idpConfigUid"]), + set: $util.oneOfSetter($oneOfFields) + }); + + // Virtual OneOf for proto3 optional field + Object.defineProperty(PAMNetworkSettings.prototype, "_adminUid", { + get: $util.oneOfGetter($oneOfFields = ["adminUid"]), + set: $util.oneOfSetter($oneOfFields) + }); + /** * Creates a new PAMNetworkSettings instance using the specified properties. * @function create @@ -308311,6 +309885,10 @@ export const Router = $root.Router = (() => { throw Error("max depth exceeded"); if (message.allowedSettings != null && Object.hasOwnProperty.call(message, "allowedSettings")) writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.allowedSettings); + if (message.idpConfigUid != null && Object.hasOwnProperty.call(message, "idpConfigUid")) + writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.idpConfigUid); + if (message.adminUid != null && Object.hasOwnProperty.call(message, "adminUid")) + writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.adminUid); return writer; }; @@ -308355,6 +309933,14 @@ export const Router = $root.Router = (() => { message.allowedSettings = reader.bytes(); break; } + case 2: { + message.idpConfigUid = reader.bytes(); + break; + } + case 3: { + message.adminUid = reader.bytes(); + break; + } default: reader.skipType(tag & 7, long); break; @@ -308394,9 +309980,20 @@ export const Router = $root.Router = (() => { long = 0; if (long > $util.recursionLimit) return "maximum nesting depth exceeded"; + let properties = {}; if (message.allowedSettings != null && message.hasOwnProperty("allowedSettings")) if (!(message.allowedSettings && typeof message.allowedSettings.length === "number" || $util.isString(message.allowedSettings))) return "allowedSettings: buffer expected"; + if (message.idpConfigUid != null && message.hasOwnProperty("idpConfigUid")) { + properties._idpConfigUid = 1; + if (!(message.idpConfigUid && typeof message.idpConfigUid.length === "number" || $util.isString(message.idpConfigUid))) + return "idpConfigUid: buffer expected"; + } + if (message.adminUid != null && message.hasOwnProperty("adminUid")) { + properties._adminUid = 1; + if (!(message.adminUid && typeof message.adminUid.length === "number" || $util.isString(message.adminUid))) + return "adminUid: buffer expected"; + } return null; }; @@ -308421,6 +310018,16 @@ export const Router = $root.Router = (() => { $util.base64.decode(object.allowedSettings, message.allowedSettings = $util.newBuffer($util.base64.length(object.allowedSettings)), 0); else if (object.allowedSettings.length >= 0) message.allowedSettings = object.allowedSettings; + if (object.idpConfigUid != null) + if (typeof object.idpConfigUid === "string") + $util.base64.decode(object.idpConfigUid, message.idpConfigUid = $util.newBuffer($util.base64.length(object.idpConfigUid)), 0); + else if (object.idpConfigUid.length >= 0) + message.idpConfigUid = object.idpConfigUid; + if (object.adminUid != null) + if (typeof object.adminUid === "string") + $util.base64.decode(object.adminUid, message.adminUid = $util.newBuffer($util.base64.length(object.adminUid)), 0); + else if (object.adminUid.length >= 0) + message.adminUid = object.adminUid; return message; }; @@ -308451,6 +310058,16 @@ export const Router = $root.Router = (() => { } if (message.allowedSettings != null && message.hasOwnProperty("allowedSettings")) object.allowedSettings = options.bytes === String ? $util.base64.encode(message.allowedSettings, 0, message.allowedSettings.length) : options.bytes === Array ? Array.prototype.slice.call(message.allowedSettings) : message.allowedSettings; + if (message.idpConfigUid != null && message.hasOwnProperty("idpConfigUid")) { + object.idpConfigUid = options.bytes === String ? $util.base64.encode(message.idpConfigUid, 0, message.idpConfigUid.length) : options.bytes === Array ? Array.prototype.slice.call(message.idpConfigUid) : message.idpConfigUid; + if (options.oneofs) + object._idpConfigUid = "idpConfigUid"; + } + if (message.adminUid != null && message.hasOwnProperty("adminUid")) { + object.adminUid = options.bytes === String ? $util.base64.encode(message.adminUid, 0, message.adminUid.length) : options.bytes === Array ? Array.prototype.slice.call(message.adminUid) : message.adminUid; + if (options.oneofs) + object._adminUid = "adminUid"; + } return object; }; @@ -320768,6 +322385,7 @@ export const PAM = $root.PAM = (() => { * @property {Uint8Array|null} [domainUid] PAMResourceConfig domainUid * @property {Uint8Array|null} [jitSettings] PAMResourceConfig jitSettings * @property {Uint8Array|null} [keeperAiSettings] PAMResourceConfig keeperAiSettings + * @property {boolean|null} [updateServices] PAMResourceConfig updateServices */ /** @@ -320857,6 +322475,14 @@ export const PAM = $root.PAM = (() => { */ PAMResourceConfig.prototype.keeperAiSettings = null; + /** + * PAMResourceConfig updateServices. + * @member {boolean|null|undefined} updateServices + * @memberof PAM.PAMResourceConfig + * @instance + */ + PAMResourceConfig.prototype.updateServices = null; + // OneOf field names bound to virtual getters and setters let $oneOfFields; @@ -320908,6 +322534,12 @@ export const PAM = $root.PAM = (() => { set: $util.oneOfSetter($oneOfFields) }); + // Virtual OneOf for proto3 optional field + Object.defineProperty(PAMResourceConfig.prototype, "_updateServices", { + get: $util.oneOfGetter($oneOfFields = ["updateServices"]), + set: $util.oneOfSetter($oneOfFields) + }); + /** * Creates a new PAMResourceConfig instance using the specified properties. * @function create @@ -320954,6 +322586,8 @@ export const PAM = $root.PAM = (() => { writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.jitSettings); if (message.keeperAiSettings != null && Object.hasOwnProperty.call(message, "keeperAiSettings")) writer.uint32(/* id 9, wireType 2 =*/74).bytes(message.keeperAiSettings); + if (message.updateServices != null && Object.hasOwnProperty.call(message, "updateServices")) + writer.uint32(/* id 10, wireType 0 =*/80).bool(message.updateServices); return writer; }; @@ -321030,6 +322664,10 @@ export const PAM = $root.PAM = (() => { message.keeperAiSettings = reader.bytes(); break; } + case 10: { + message.updateServices = reader.bool(); + break; + } default: reader.skipType(tag & 7, long); break; @@ -321116,6 +322754,11 @@ export const PAM = $root.PAM = (() => { if (!(message.keeperAiSettings && typeof message.keeperAiSettings.length === "number" || $util.isString(message.keeperAiSettings))) return "keeperAiSettings: buffer expected"; } + if (message.updateServices != null && message.hasOwnProperty("updateServices")) { + properties._updateServices = 1; + if (typeof message.updateServices !== "boolean") + return "updateServices: boolean expected"; + } return null; }; @@ -321180,6 +322823,8 @@ export const PAM = $root.PAM = (() => { $util.base64.decode(object.keeperAiSettings, message.keeperAiSettings = $util.newBuffer($util.base64.length(object.keeperAiSettings)), 0); else if (object.keeperAiSettings.length >= 0) message.keeperAiSettings = object.keeperAiSettings; + if (object.updateServices != null) + message.updateServices = Boolean(object.updateServices); return message; }; @@ -321250,6 +322895,11 @@ export const PAM = $root.PAM = (() => { if (options.oneofs) object._keeperAiSettings = "keeperAiSettings"; } + if (message.updateServices != null && message.hasOwnProperty("updateServices")) { + object.updateServices = message.updateServices; + if (options.oneofs) + object._updateServices = "updateServices"; + } return object; }; @@ -324547,6 +326197,787 @@ export const PAM = $root.PAM = (() => { return GetNhiUidsResponse; })(); + PAM.PAMUniversalSyncPreCheckRequest = (function() { + + /** + * Properties of a PAMUniversalSyncPreCheckRequest. + * @memberof PAM + * @interface IPAMUniversalSyncPreCheckRequest + * @property {Uint8Array|null} [networkUid] PAMUniversalSyncPreCheckRequest networkUid + * @property {Array.|null} [folderUids] PAMUniversalSyncPreCheckRequest folderUids + */ + + /** + * Constructs a new PAMUniversalSyncPreCheckRequest. + * @memberof PAM + * @classdesc Represents a PAMUniversalSyncPreCheckRequest. + * @implements IPAMUniversalSyncPreCheckRequest + * @constructor + * @param {PAM.IPAMUniversalSyncPreCheckRequest=} [properties] Properties to set + */ + function PAMUniversalSyncPreCheckRequest(properties) { + this.folderUids = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null && keys[i] !== "__proto__") + this[keys[i]] = properties[keys[i]]; + } + + /** + * PAMUniversalSyncPreCheckRequest networkUid. + * @member {Uint8Array} networkUid + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @instance + */ + PAMUniversalSyncPreCheckRequest.prototype.networkUid = $util.newBuffer([]); + + /** + * PAMUniversalSyncPreCheckRequest folderUids. + * @member {Array.} folderUids + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @instance + */ + PAMUniversalSyncPreCheckRequest.prototype.folderUids = $util.emptyArray; + + /** + * Creates a new PAMUniversalSyncPreCheckRequest instance using the specified properties. + * @function create + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {PAM.IPAMUniversalSyncPreCheckRequest=} [properties] Properties to set + * @returns {PAM.PAMUniversalSyncPreCheckRequest} PAMUniversalSyncPreCheckRequest instance + */ + PAMUniversalSyncPreCheckRequest.create = function create(properties) { + return new PAMUniversalSyncPreCheckRequest(properties); + }; + + /** + * Encodes the specified PAMUniversalSyncPreCheckRequest message. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckRequest.verify|verify} messages. + * @function encode + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {PAM.IPAMUniversalSyncPreCheckRequest} message PAMUniversalSyncPreCheckRequest message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PAMUniversalSyncPreCheckRequest.encode = function encode(message, writer, q) { + if (!writer) + writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + if (message.networkUid != null && Object.hasOwnProperty.call(message, "networkUid")) + writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.networkUid); + if (message.folderUids != null && message.folderUids.length) + for (let i = 0; i < message.folderUids.length; ++i) + writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.folderUids[i]); + return writer; + }; + + /** + * Encodes the specified PAMUniversalSyncPreCheckRequest message, length delimited. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckRequest.verify|verify} messages. + * @function encodeDelimited + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {PAM.IPAMUniversalSyncPreCheckRequest} message PAMUniversalSyncPreCheckRequest message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PAMUniversalSyncPreCheckRequest.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a PAMUniversalSyncPreCheckRequest message from the specified reader or buffer. + * @function decode + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {PAM.PAMUniversalSyncPreCheckRequest} PAMUniversalSyncPreCheckRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PAMUniversalSyncPreCheckRequest.decode = function decode(reader, length, error, long) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.PAM.PAMUniversalSyncPreCheckRequest(); + while (reader.pos < end) { + let tag = reader.uint32(); + if (tag === error) + break; + switch (tag >>> 3) { + case 1: { + message.networkUid = reader.bytes(); + break; + } + case 2: { + if (!(message.folderUids && message.folderUids.length)) + message.folderUids = []; + message.folderUids.push(reader.bytes()); + break; + } + default: + reader.skipType(tag & 7, long); + break; + } + } + return message; + }; + + /** + * Decodes a PAMUniversalSyncPreCheckRequest message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {PAM.PAMUniversalSyncPreCheckRequest} PAMUniversalSyncPreCheckRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PAMUniversalSyncPreCheckRequest.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a PAMUniversalSyncPreCheckRequest message. + * @function verify + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + PAMUniversalSyncPreCheckRequest.verify = function verify(message, long) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.networkUid != null && message.hasOwnProperty("networkUid")) + if (!(message.networkUid && typeof message.networkUid.length === "number" || $util.isString(message.networkUid))) + return "networkUid: buffer expected"; + if (message.folderUids != null && message.hasOwnProperty("folderUids")) { + if (!Array.isArray(message.folderUids)) + return "folderUids: array expected"; + for (let i = 0; i < message.folderUids.length; ++i) + if (!(message.folderUids[i] && typeof message.folderUids[i].length === "number" || $util.isString(message.folderUids[i]))) + return "folderUids: buffer[] expected"; + } + return null; + }; + + /** + * Creates a PAMUniversalSyncPreCheckRequest message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {Object.} object Plain object + * @returns {PAM.PAMUniversalSyncPreCheckRequest} PAMUniversalSyncPreCheckRequest + */ + PAMUniversalSyncPreCheckRequest.fromObject = function fromObject(object, long) { + if (object instanceof $root.PAM.PAMUniversalSyncPreCheckRequest) + return object; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let message = new $root.PAM.PAMUniversalSyncPreCheckRequest(); + if (object.networkUid != null) + if (typeof object.networkUid === "string") + $util.base64.decode(object.networkUid, message.networkUid = $util.newBuffer($util.base64.length(object.networkUid)), 0); + else if (object.networkUid.length >= 0) + message.networkUid = object.networkUid; + if (object.folderUids) { + if (!Array.isArray(object.folderUids)) + throw TypeError(".PAM.PAMUniversalSyncPreCheckRequest.folderUids: array expected"); + message.folderUids = []; + for (let i = 0; i < object.folderUids.length; ++i) + if (typeof object.folderUids[i] === "string") + $util.base64.decode(object.folderUids[i], message.folderUids[i] = $util.newBuffer($util.base64.length(object.folderUids[i])), 0); + else if (object.folderUids[i].length >= 0) + message.folderUids[i] = object.folderUids[i]; + } + return message; + }; + + /** + * Creates a plain object from a PAMUniversalSyncPreCheckRequest message. Also converts values to other types if specified. + * @function toObject + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {PAM.PAMUniversalSyncPreCheckRequest} message PAMUniversalSyncPreCheckRequest + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + PAMUniversalSyncPreCheckRequest.toObject = function toObject(message, options, q) { + if (!options) + options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + let object = {}; + if (options.arrays || options.defaults) + object.folderUids = []; + if (options.defaults) + if (options.bytes === String) + object.networkUid = ""; + else { + object.networkUid = []; + if (options.bytes !== Array) + object.networkUid = $util.newBuffer(object.networkUid); + } + if (message.networkUid != null && message.hasOwnProperty("networkUid")) + object.networkUid = options.bytes === String ? $util.base64.encode(message.networkUid, 0, message.networkUid.length) : options.bytes === Array ? Array.prototype.slice.call(message.networkUid) : message.networkUid; + if (message.folderUids && message.folderUids.length) { + object.folderUids = []; + for (let j = 0; j < message.folderUids.length; ++j) + object.folderUids[j] = options.bytes === String ? $util.base64.encode(message.folderUids[j], 0, message.folderUids[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.folderUids[j]) : message.folderUids[j]; + } + return object; + }; + + /** + * Converts this PAMUniversalSyncPreCheckRequest to JSON. + * @function toJSON + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @instance + * @returns {Object.} JSON object + */ + PAMUniversalSyncPreCheckRequest.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for PAMUniversalSyncPreCheckRequest + * @function getTypeUrl + * @memberof PAM.PAMUniversalSyncPreCheckRequest + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + PAMUniversalSyncPreCheckRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/PAM.PAMUniversalSyncPreCheckRequest"; + }; + + return PAMUniversalSyncPreCheckRequest; + })(); + + PAM.PAMUniversalSyncPreCheckResult = (function() { + + /** + * Properties of a PAMUniversalSyncPreCheckResult. + * @memberof PAM + * @interface IPAMUniversalSyncPreCheckResult + * @property {Uint8Array|null} [folderUid] PAMUniversalSyncPreCheckResult folderUid + * @property {boolean|null} [isUsed] PAMUniversalSyncPreCheckResult isUsed + */ + + /** + * Constructs a new PAMUniversalSyncPreCheckResult. + * @memberof PAM + * @classdesc Represents a PAMUniversalSyncPreCheckResult. + * @implements IPAMUniversalSyncPreCheckResult + * @constructor + * @param {PAM.IPAMUniversalSyncPreCheckResult=} [properties] Properties to set + */ + function PAMUniversalSyncPreCheckResult(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null && keys[i] !== "__proto__") + this[keys[i]] = properties[keys[i]]; + } + + /** + * PAMUniversalSyncPreCheckResult folderUid. + * @member {Uint8Array} folderUid + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @instance + */ + PAMUniversalSyncPreCheckResult.prototype.folderUid = $util.newBuffer([]); + + /** + * PAMUniversalSyncPreCheckResult isUsed. + * @member {boolean} isUsed + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @instance + */ + PAMUniversalSyncPreCheckResult.prototype.isUsed = false; + + /** + * Creates a new PAMUniversalSyncPreCheckResult instance using the specified properties. + * @function create + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {PAM.IPAMUniversalSyncPreCheckResult=} [properties] Properties to set + * @returns {PAM.PAMUniversalSyncPreCheckResult} PAMUniversalSyncPreCheckResult instance + */ + PAMUniversalSyncPreCheckResult.create = function create(properties) { + return new PAMUniversalSyncPreCheckResult(properties); + }; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResult message. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResult.verify|verify} messages. + * @function encode + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {PAM.IPAMUniversalSyncPreCheckResult} message PAMUniversalSyncPreCheckResult message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PAMUniversalSyncPreCheckResult.encode = function encode(message, writer, q) { + if (!writer) + writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + if (message.folderUid != null && Object.hasOwnProperty.call(message, "folderUid")) + writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.folderUid); + if (message.isUsed != null && Object.hasOwnProperty.call(message, "isUsed")) + writer.uint32(/* id 2, wireType 0 =*/16).bool(message.isUsed); + return writer; + }; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResult message, length delimited. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResult.verify|verify} messages. + * @function encodeDelimited + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {PAM.IPAMUniversalSyncPreCheckResult} message PAMUniversalSyncPreCheckResult message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PAMUniversalSyncPreCheckResult.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a PAMUniversalSyncPreCheckResult message from the specified reader or buffer. + * @function decode + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {PAM.PAMUniversalSyncPreCheckResult} PAMUniversalSyncPreCheckResult + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PAMUniversalSyncPreCheckResult.decode = function decode(reader, length, error, long) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.PAM.PAMUniversalSyncPreCheckResult(); + while (reader.pos < end) { + let tag = reader.uint32(); + if (tag === error) + break; + switch (tag >>> 3) { + case 1: { + message.folderUid = reader.bytes(); + break; + } + case 2: { + message.isUsed = reader.bool(); + break; + } + default: + reader.skipType(tag & 7, long); + break; + } + } + return message; + }; + + /** + * Decodes a PAMUniversalSyncPreCheckResult message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {PAM.PAMUniversalSyncPreCheckResult} PAMUniversalSyncPreCheckResult + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PAMUniversalSyncPreCheckResult.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a PAMUniversalSyncPreCheckResult message. + * @function verify + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + PAMUniversalSyncPreCheckResult.verify = function verify(message, long) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.folderUid != null && message.hasOwnProperty("folderUid")) + if (!(message.folderUid && typeof message.folderUid.length === "number" || $util.isString(message.folderUid))) + return "folderUid: buffer expected"; + if (message.isUsed != null && message.hasOwnProperty("isUsed")) + if (typeof message.isUsed !== "boolean") + return "isUsed: boolean expected"; + return null; + }; + + /** + * Creates a PAMUniversalSyncPreCheckResult message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {Object.} object Plain object + * @returns {PAM.PAMUniversalSyncPreCheckResult} PAMUniversalSyncPreCheckResult + */ + PAMUniversalSyncPreCheckResult.fromObject = function fromObject(object, long) { + if (object instanceof $root.PAM.PAMUniversalSyncPreCheckResult) + return object; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let message = new $root.PAM.PAMUniversalSyncPreCheckResult(); + if (object.folderUid != null) + if (typeof object.folderUid === "string") + $util.base64.decode(object.folderUid, message.folderUid = $util.newBuffer($util.base64.length(object.folderUid)), 0); + else if (object.folderUid.length >= 0) + message.folderUid = object.folderUid; + if (object.isUsed != null) + message.isUsed = Boolean(object.isUsed); + return message; + }; + + /** + * Creates a plain object from a PAMUniversalSyncPreCheckResult message. Also converts values to other types if specified. + * @function toObject + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {PAM.PAMUniversalSyncPreCheckResult} message PAMUniversalSyncPreCheckResult + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + PAMUniversalSyncPreCheckResult.toObject = function toObject(message, options, q) { + if (!options) + options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + let object = {}; + if (options.defaults) { + if (options.bytes === String) + object.folderUid = ""; + else { + object.folderUid = []; + if (options.bytes !== Array) + object.folderUid = $util.newBuffer(object.folderUid); + } + object.isUsed = false; + } + if (message.folderUid != null && message.hasOwnProperty("folderUid")) + object.folderUid = options.bytes === String ? $util.base64.encode(message.folderUid, 0, message.folderUid.length) : options.bytes === Array ? Array.prototype.slice.call(message.folderUid) : message.folderUid; + if (message.isUsed != null && message.hasOwnProperty("isUsed")) + object.isUsed = message.isUsed; + return object; + }; + + /** + * Converts this PAMUniversalSyncPreCheckResult to JSON. + * @function toJSON + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @instance + * @returns {Object.} JSON object + */ + PAMUniversalSyncPreCheckResult.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for PAMUniversalSyncPreCheckResult + * @function getTypeUrl + * @memberof PAM.PAMUniversalSyncPreCheckResult + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + PAMUniversalSyncPreCheckResult.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/PAM.PAMUniversalSyncPreCheckResult"; + }; + + return PAMUniversalSyncPreCheckResult; + })(); + + PAM.PAMUniversalSyncPreCheckResponse = (function() { + + /** + * Properties of a PAMUniversalSyncPreCheckResponse. + * @memberof PAM + * @interface IPAMUniversalSyncPreCheckResponse + * @property {Array.|null} [results] PAMUniversalSyncPreCheckResponse results + */ + + /** + * Constructs a new PAMUniversalSyncPreCheckResponse. + * @memberof PAM + * @classdesc Represents a PAMUniversalSyncPreCheckResponse. + * @implements IPAMUniversalSyncPreCheckResponse + * @constructor + * @param {PAM.IPAMUniversalSyncPreCheckResponse=} [properties] Properties to set + */ + function PAMUniversalSyncPreCheckResponse(properties) { + this.results = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null && keys[i] !== "__proto__") + this[keys[i]] = properties[keys[i]]; + } + + /** + * PAMUniversalSyncPreCheckResponse results. + * @member {Array.} results + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @instance + */ + PAMUniversalSyncPreCheckResponse.prototype.results = $util.emptyArray; + + /** + * Creates a new PAMUniversalSyncPreCheckResponse instance using the specified properties. + * @function create + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {PAM.IPAMUniversalSyncPreCheckResponse=} [properties] Properties to set + * @returns {PAM.PAMUniversalSyncPreCheckResponse} PAMUniversalSyncPreCheckResponse instance + */ + PAMUniversalSyncPreCheckResponse.create = function create(properties) { + return new PAMUniversalSyncPreCheckResponse(properties); + }; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResponse message. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResponse.verify|verify} messages. + * @function encode + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {PAM.IPAMUniversalSyncPreCheckResponse} message PAMUniversalSyncPreCheckResponse message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PAMUniversalSyncPreCheckResponse.encode = function encode(message, writer, q) { + if (!writer) + writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + if (message.results != null && message.results.length) + for (let i = 0; i < message.results.length; ++i) + $root.PAM.PAMUniversalSyncPreCheckResult.encode(message.results[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); + return writer; + }; + + /** + * Encodes the specified PAMUniversalSyncPreCheckResponse message, length delimited. Does not implicitly {@link PAM.PAMUniversalSyncPreCheckResponse.verify|verify} messages. + * @function encodeDelimited + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {PAM.IPAMUniversalSyncPreCheckResponse} message PAMUniversalSyncPreCheckResponse message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + PAMUniversalSyncPreCheckResponse.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a PAMUniversalSyncPreCheckResponse message from the specified reader or buffer. + * @function decode + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {PAM.PAMUniversalSyncPreCheckResponse} PAMUniversalSyncPreCheckResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PAMUniversalSyncPreCheckResponse.decode = function decode(reader, length, error, long) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.PAM.PAMUniversalSyncPreCheckResponse(); + while (reader.pos < end) { + let tag = reader.uint32(); + if (tag === error) + break; + switch (tag >>> 3) { + case 1: { + if (!(message.results && message.results.length)) + message.results = []; + message.results.push($root.PAM.PAMUniversalSyncPreCheckResult.decode(reader, reader.uint32(), undefined, long + 1)); + break; + } + default: + reader.skipType(tag & 7, long); + break; + } + } + return message; + }; + + /** + * Decodes a PAMUniversalSyncPreCheckResponse message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {PAM.PAMUniversalSyncPreCheckResponse} PAMUniversalSyncPreCheckResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + PAMUniversalSyncPreCheckResponse.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a PAMUniversalSyncPreCheckResponse message. + * @function verify + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + PAMUniversalSyncPreCheckResponse.verify = function verify(message, long) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.results != null && message.hasOwnProperty("results")) { + if (!Array.isArray(message.results)) + return "results: array expected"; + for (let i = 0; i < message.results.length; ++i) { + let error = $root.PAM.PAMUniversalSyncPreCheckResult.verify(message.results[i], long + 1); + if (error) + return "results." + error; + } + } + return null; + }; + + /** + * Creates a PAMUniversalSyncPreCheckResponse message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {Object.} object Plain object + * @returns {PAM.PAMUniversalSyncPreCheckResponse} PAMUniversalSyncPreCheckResponse + */ + PAMUniversalSyncPreCheckResponse.fromObject = function fromObject(object, long) { + if (object instanceof $root.PAM.PAMUniversalSyncPreCheckResponse) + return object; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); + let message = new $root.PAM.PAMUniversalSyncPreCheckResponse(); + if (object.results) { + if (!Array.isArray(object.results)) + throw TypeError(".PAM.PAMUniversalSyncPreCheckResponse.results: array expected"); + message.results = []; + for (let i = 0; i < object.results.length; ++i) { + if (typeof object.results[i] !== "object") + throw TypeError(".PAM.PAMUniversalSyncPreCheckResponse.results: object expected"); + message.results[i] = $root.PAM.PAMUniversalSyncPreCheckResult.fromObject(object.results[i], long + 1); + } + } + return message; + }; + + /** + * Creates a plain object from a PAMUniversalSyncPreCheckResponse message. Also converts values to other types if specified. + * @function toObject + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {PAM.PAMUniversalSyncPreCheckResponse} message PAMUniversalSyncPreCheckResponse + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + PAMUniversalSyncPreCheckResponse.toObject = function toObject(message, options, q) { + if (!options) + options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + let object = {}; + if (options.arrays || options.defaults) + object.results = []; + if (message.results && message.results.length) { + object.results = []; + for (let j = 0; j < message.results.length; ++j) + object.results[j] = $root.PAM.PAMUniversalSyncPreCheckResult.toObject(message.results[j], options, q + 1); + } + return object; + }; + + /** + * Converts this PAMUniversalSyncPreCheckResponse to JSON. + * @function toJSON + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @instance + * @returns {Object.} JSON object + */ + PAMUniversalSyncPreCheckResponse.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for PAMUniversalSyncPreCheckResponse + * @function getTypeUrl + * @memberof PAM.PAMUniversalSyncPreCheckResponse + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + PAMUniversalSyncPreCheckResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/PAM.PAMUniversalSyncPreCheckResponse"; + }; + + return PAMUniversalSyncPreCheckResponse; + })(); + return PAM; })(); diff --git a/keeperapi/src/restMessages.ts b/keeperapi/src/restMessages.ts index bd5e2574..2a36bef4 100644 --- a/keeperapi/src/restMessages.ts +++ b/keeperapi/src/restMessages.ts @@ -17,6 +17,7 @@ import { Vault, Tokens, NotificationCenter, + record, } from './proto' // generated protobuf has all properties optional and nullable, while this is not an issue for KeeperApp, this type fixes it @@ -957,3 +958,13 @@ export const pamGetLeafsMessage = ( export const pamGetOnlineControllersMessage = (): RestOutMessage => createOutMessage('api/user/get_controllers', PAM.PAMOnlineControllers) + +export const keeperDriveRecordsAdd = ( + data: record.v3.IRecordsAddRequest +): RestMessage => + createMessage(data, '/vault/records/v3/add', record.v3.RecordsAddRequest, Records.RecordsModifyResponse) + +export const keeperDriveRecordsUpdate = ( + data: Records.IRecordsUpdateRequest +): RestMessage => + createMessage(data, '/vault/records/v3/update', Records.RecordsUpdateRequest, Records.RecordsModifyResponse) diff --git a/keeperapi/src/syncDown/index.ts b/keeperapi/src/syncDown/index.ts new file mode 100644 index 00000000..ce4acb57 --- /dev/null +++ b/keeperapi/src/syncDown/index.ts @@ -0,0 +1,2 @@ +export * from './types' +export * from './utils' diff --git a/keeperapi/src/syncDown/types.ts b/keeperapi/src/syncDown/types.ts new file mode 100644 index 00000000..00fc7cad --- /dev/null +++ b/keeperapi/src/syncDown/types.ts @@ -0,0 +1,80 @@ +import { Folder, common } from '../proto' + +export type DKdFolder = { + kind: 'keeper_drive_folder' + uid: string + data: { + name: string + } + parentUid?: string + ownerInfo: { + accountUid?: string + username?: string + } + lastModified?: number + type?: Folder.FolderUsageType + inheritUserPermissions?: Folder.SetBooleanValue +} + +export type DKdFolderAccess = { + kind: 'keeper_drive_folder_access' + accessUid: string + folderUid: string + accessTypeUid: string + accessType: Folder.AccessType + accessRoleType: Folder.AccessRoleType + permission: Folder.IFolderPermissions + inherited?: boolean + hidden?: boolean +} + +export type DKdFolderSharingState = { + kind: 'keeper_drive_folder_sharing_state' + folderUid: string + count?: number + shared?: boolean +} + +export type DKdFolderRecord = { + kind: 'keeper_drive_folder_record' + folderUid: string + recordUid: string +} + +export type DKdRecordAccess = { + kind: 'keeper_drive_record_access' + accessUid: string + accessTypeUid: string + accessType: Folder.AccessType + recordUid: string + accessRoleType: Folder.AccessRoleType + owner?: boolean + inherited?: boolean + hidden?: boolean + deniedAccess?: boolean + canEdit?: boolean + canView?: boolean + canListAccess?: boolean + canUpdateAccess?: boolean + canDelete?: boolean + canChangeOwnership?: boolean + canRequestAccess?: boolean + canApproveAccess?: boolean + dateCreated?: number + lastModified?: number + tlaProperties?: common.tla.ITLAProperties +} + +export type DKdRecordSharingState = { + kind: 'keeper_drive_record_sharing_state' + recordUid: string + isDirectlyShared?: boolean + isIndirectlyShared?: boolean + isShared?: boolean +} + +export type DKdRecordLink = { + kind: 'keeper_drive_record_link' + parentRecordUid: string + childRecordUid: string +} diff --git a/keeperapi/src/syncDown/utils.ts b/keeperapi/src/syncDown/utils.ts new file mode 100644 index 00000000..62cc8d9e --- /dev/null +++ b/keeperapi/src/syncDown/utils.ts @@ -0,0 +1,30 @@ +import { Folder } from '../proto' +import { EncryptionType } from '../platform' + +export const createKdRecordAccessCompositeKey = (actorUid: string, recordUid: string) => `${actorUid}:${recordUid}` + +export const createKdFolderAccessCompositeKey = (actorUid: string, folderUid: string) => `${folderUid}:${actorUid}` + +export const mapTeamKeyType = (keyType: Folder.EncryptedKeyType, teamUid: string) => { + let keyId: string + let encryptionType: EncryptionType + const unwrappedType = 'aes' + switch (keyType) { + case Folder.EncryptedKeyType.encrypted_by_data_key: + keyId = teamUid + encryptionType = 'cbc' + break + case Folder.EncryptedKeyType.encrypted_by_public_key: + keyId = `${teamUid}_priv` + encryptionType = 'rsa' + break + case Folder.EncryptedKeyType.encrypted_by_public_key_ecc: + keyId = `${teamUid}_ecc` + encryptionType = 'ecc' + break + default: + console.error('Unknown key type: ' + keyType) + return null + } + return { keyId, encryptionType, unwrappedType } +} diff --git a/keeperapi/src/utils.ts b/keeperapi/src/utils.ts index 19719f26..e0b4e4a8 100644 --- a/keeperapi/src/utils.ts +++ b/keeperapi/src/utils.ts @@ -243,3 +243,11 @@ export function resolvablePromise(): { promise: Promise; resolve: () => vo resolve: resolver, } } + +export const isNil = (value: T | null | undefined): value is null | undefined => { + return value == null +} + +export const toOptional = (value: T | null | undefined): T | undefined => { + return value ?? undefined +} diff --git a/keeperapi/src/vault.ts b/keeperapi/src/vault.ts index f744ff47..7ea8b9bc 100644 --- a/keeperapi/src/vault.ts +++ b/keeperapi/src/vault.ts @@ -1,8 +1,8 @@ import { Auth } from './auth' import { NN, syncDownMessage } from './restMessages' import { CryptoWorkerOptions, EncryptionType, KeyStorage, platform } from './platform' -import { Records, Tokens, Vault } from './proto' -import { formatTimeDiff, webSafe64FromBytes } from './utils' +import { Folder, record, Records, Tokens, Vault } from './proto' +import { formatTimeDiff, isNil, toOptional, webSafe64FromBytes } from './utils' import { logger } from './log' import CacheStatus = Vault.CacheStatus import RecordKeyType = Records.RecordKeyType @@ -26,6 +26,22 @@ import IProfile = Vault.IProfile import IBreachWatchRecord = Vault.IBreachWatchRecord import IBreachWatchSecurityData = Vault.IBreachWatchSecurityData import type { UnwrapKeyMap } from './platform' +import { + createKdRecordAccessCompositeKey, + DKdFolderRecord, + DKdRecordAccess, + DKdRecordSharingState, + DKdFolder, + DKdFolderAccess, + DKdFolderSharingState, + mapTeamKeyType, + DKdRecordLink, + createKdFolderAccessCompositeKey, +} from './syncDown' + +export type VaultStorageDeleteOption = + | { kind: 'keeper_drive_record_access'; actorUid: string; recordUid: string } + | { kind: 'keeper_drive_folder_access'; folderUid: string; actorUid: string } export type VaultStorage = KeyStorage & { put(data: VaultStorageData): Promise @@ -34,7 +50,7 @@ export type VaultStorage = KeyStorage & { removeDependencies(dependencies: RemovedDependencies): Promise clear(): Promise get(kind: T, uid?: string): Promise> - delete(kind: VaultStorageKind, uid: string | Uint8Array): Promise + delete(kind: VaultStorageKind, uid: string | Uint8Array, option?: VaultStorageDeleteOption): Promise } export type VaultStorageData = @@ -57,27 +73,15 @@ export type VaultStorageData = | DSecurityScoreData | DUser | DRecordRotation + | DKdFolderRecord + | DKdRecordAccess + | DKdRecordSharingState + | DKdFolder + | DKdFolderSharingState + | DKdFolderAccess + | DKdRecordLink -export type VaultStorageKind = - | 'profilePic' - | 'record' - | 'metadata' - | 'non_shared_data' - | 'team' - | 'shared_folder' - | 'shared_folder_user' - | 'shared_folder_team' - | 'shared_folder_record' - | 'shared_folder_folder' - | 'user_folder' - | 'profile' - | 'continuationToken' - | 'reused_passwords' - | 'bw_record' - | 'bw_security_data' - | 'security_score_data' - | 'user' - | 'record_rotation' +export type VaultStorageKind = VaultStorageData['kind'] export type VaultStorageResult = | (T extends 'continuationToken' ? DContinuationToken : T extends 'record' ? DRecord : never) @@ -87,7 +91,9 @@ type MappedCounts = { [Property in keyof Type]: number } -type SyncResponseCounts = MappedCounts +type SyncResponseCounts = Partial< + MappedCounts & Vault.IKeeperDriveData> +> export type SyncResult = { started: Date @@ -115,6 +121,7 @@ export type DRecord = { clientModifiedTime: number extra?: any udata?: Udata + isKeeperDriveData?: boolean } export type DRecordMetadata = { @@ -285,9 +292,14 @@ export type Dependency = { parentUid: string uid: string } +export type RemovedDependency = { + parentKind: VaultStorageKind + childKind: VaultStorageKind + childUid: string +} export type DependencyMap = Record export type Dependencies = Record> -export type RemovedDependencies = Record | '*'> +export type RemovedDependencies = Record | '*'> const addDependencies = (dependencies: Dependencies, parentUid: string, childUid: string, kind: VaultStorageKind) => { let children = dependencies[parentUid] @@ -302,13 +314,17 @@ const addDependencies = (dependencies: Dependencies, parentUid: string, childUid }) } -const addRemovedDependencies = (dependencies: RemovedDependencies, parentUid: string, childUid: string) => { +const addRemovedDependencies = ( + dependencies: RemovedDependencies, + parentUid: string, + childUid: string | RemovedDependency +) => { let children = dependencies[parentUid] if (children === '*') { return } if (!children) { - children = new Set() + children = new Set() dependencies[parentUid] = children } children.add(childUid) @@ -331,26 +347,33 @@ const getDependencies = async (folderUid: string, storage: VaultStorage, results } } -const mapKeyType = (keyType: Records.RecordKeyType): { keyId: string; encryptionType: EncryptionType } | null => { +const mapKeyType = ( + keyType: Records.RecordKeyType | Folder.EncryptedKeyType +): { keyId: string; encryptionType: EncryptionType } | null => { let keyId: string let encryptionType: EncryptionType switch (keyType) { case RecordKeyType.NO_KEY: + case Folder.EncryptedKeyType.no_key: return null case RecordKeyType.ENCRYPTED_BY_DATA_KEY: + case Folder.EncryptedKeyType.encrypted_by_data_key: keyId = 'data' encryptionType = 'cbc' break case RecordKeyType.ENCRYPTED_BY_DATA_KEY_GCM: + case Folder.EncryptedKeyType.encrypted_by_data_key_gcm: keyId = 'data' encryptionType = 'gcm' break // RSA TAGGED - might have to fallback to ecc or force ecc - dont make a change here, rely on keeperapp to provide the correct keyType case RecordKeyType.ENCRYPTED_BY_PUBLIC_KEY: + case Folder.EncryptedKeyType.encrypted_by_public_key: keyId = 'pk_rsa' encryptionType = 'rsa' break case RecordKeyType.ENCRYPTED_BY_PUBLIC_KEY_ECC: + case Folder.EncryptedKeyType.encrypted_by_public_key_ecc: keyId = 'pk_ecc' encryptionType = 'ecc' break @@ -751,7 +774,8 @@ const processRecords = async (records: IRecord[], storage: VaultStorage) => { } } -const processNonSharedData = async (nonSharedData: INonSharedData[], storage: VaultStorage) => { +const processNonSharedData = async (storage: VaultStorage, nonSharedData?: Vault.INonSharedData[] | null) => { + if (!nonSharedData) return for (const nsData of nonSharedData as NN[]) { const recUid = webSafe64FromBytes(nsData.recordUid) try { @@ -988,7 +1012,8 @@ const processMetadata = async (recordMetaData: IRecordMetaData[], storage: Vault await platform.unwrapKeys(recordKeys, storage) } -const processBreachWatchRecords = async (bwRecords: IBreachWatchRecord[], storage: VaultStorage) => { +const processBreachWatchRecords = async (storage: VaultStorage, bwRecords?: IBreachWatchRecord[] | null) => { + if (!bwRecords) return for (const bwRecord of bwRecords as NN[]) { if (!bwRecord.recordUid) continue @@ -1016,7 +1041,11 @@ const processBreachWatchRecords = async (bwRecords: IBreachWatchRecord[], storag } } -const processBreachWatchSecurityData = async (securityData: IBreachWatchSecurityData[], storage: VaultStorage) => { +const processBreachWatchSecurityData = async ( + storage: VaultStorage, + securityData?: IBreachWatchSecurityData[] | null +) => { + if (!securityData) return for (const bwSecurityData of securityData as NN[]) { const uid = webSafe64FromBytes(bwSecurityData.recordUid) @@ -1032,7 +1061,11 @@ const processBreachWatchSecurityData = async (securityData: IBreachWatchSecurity } } -const processSecurityScoreData = async (securityScoreDataList: Vault.ISecurityScoreData[], storage: VaultStorage) => { +const processSecurityScoreData = async ( + storage: VaultStorage, + securityScoreDataList?: Vault.ISecurityScoreData[] | null +) => { + if (!securityScoreDataList) return for (const securityScoreData of securityScoreDataList) { if (!securityScoreData.recordUid || typeof securityScoreData.revision !== 'number') continue @@ -1058,6 +1091,388 @@ const processSecurityScoreData = async (securityScoreDataList: Vault.ISecuritySc } } +// Keeper Drive Processors Start + +const processKdRemovedRecordLinks = async ( + removedDependencies: RemovedDependencies, + keeperDriveRemovedRecordLinks?: Vault.IRecordLink[] | null +) => { + if (!keeperDriveRemovedRecordLinks) return + for (const link of keeperDriveRemovedRecordLinks) { + if (!link.childRecordUid || !link.parentRecordUid) continue + const childRecordUid = webSafe64FromBytes(link.childRecordUid) + const parentRecordUid = webSafe64FromBytes(link.parentRecordUid) + addRemovedDependencies(removedDependencies, parentRecordUid, childRecordUid) + } +} + +const processKdRecordLinks = async (storage: VaultStorage, keeperDriveRecordLinks?: Vault.IRecordLink[] | null) => { + if (!keeperDriveRecordLinks) return + for (const link of keeperDriveRecordLinks) { + if (!link.childRecordUid || !link.parentRecordUid || !link.recordKey) continue + const childRecordUid = webSafe64FromBytes(link.childRecordUid) + const parentRecordUid = webSafe64FromBytes(link.parentRecordUid) + + try { + await platform.unwrapKey(link.recordKey, childRecordUid, parentRecordUid, 'gcm', 'aes', storage, true) + await storage.put({ + kind: 'keeper_drive_record_link', + childRecordUid, + parentRecordUid, + }) + } catch (e: any) { + console.error( + `[ks] The record link for ${childRecordUid} cannot be decrypted by ${parentRecordUid} (${e.message})` + ) + } + } +} + +const processKdRevokedFolderAccesses = async ( + storage: VaultStorage, + keeperDriveRevokedFolderAccesses?: Folder.IRevokedAccess[] | null +) => { + if (!keeperDriveRevokedFolderAccesses) return + for (const revokedAccess of keeperDriveRevokedFolderAccesses) { + if (!revokedAccess.actorUid || !revokedAccess.folderUid) continue + const actorUid = webSafe64FromBytes(revokedAccess.actorUid) + const folderUid = webSafe64FromBytes(revokedAccess.folderUid) + await storage.delete('keeper_drive_folder_access', createKdFolderAccessCompositeKey(actorUid, folderUid), { + kind: 'keeper_drive_folder_access', + actorUid, + folderUid, + }) + } +} + +const processKdRemovedFolders = async ( + storage: VaultStorage, + keeperDriveRemovedFolders?: Folder.IFolderRemoved[] | null +) => { + if (!keeperDriveRemovedFolders) return + for (const removedFolder of keeperDriveRemovedFolders) { + if (!removedFolder.folderUid) continue + const folderUid = webSafe64FromBytes(removedFolder.folderUid) + await storage.delete('keeper_drive_folder', folderUid) + } +} + +const processKdFolderKeys = async (storage: VaultStorage, folderKeys?: Folder.IFolderKey[] | null) => { + if (!folderKeys) return + const encryptedByDataKeyMap: UnwrapKeyMap = {} + const encryptedByParentKeyMap: UnwrapKeyMap = {} + const encryptedByDataKey = folderKeys.filter( + (key) => key.encryptedBy === Folder.FolderKeyEncryptionType.ENCRYPTED_BY_USER_KEY + ) + const encryptedByParentKey = folderKeys.filter( + (key) => key.encryptedBy === Folder.FolderKeyEncryptionType.ENCRYPTED_BY_PARENT_KEY + ) + for (const key of encryptedByDataKey) { + if (!key.folderUid || !key.folderKey || !key.parentUid || isNil(key.encryptedBy)) continue + const folderUid = webSafe64FromBytes(key.folderUid) + const parentUid = webSafe64FromBytes(key.parentUid) + encryptedByDataKeyMap[folderUid] = { + data: key.folderKey, + dataId: folderUid, + keyId: 'data', + encryptionType: 'gcm', + unwrappedType: 'aes', + } + } + await platform.unwrapKeys(encryptedByDataKeyMap, storage) + for (const key of encryptedByParentKey) { + if (!key.folderUid || !key.folderKey || !key.parentUid || isNil(key.encryptedBy)) continue + const folderUid = webSafe64FromBytes(key.folderUid) + const parentUid = webSafe64FromBytes(key.parentUid) + encryptedByParentKeyMap[folderUid] = { + data: key.folderKey, + dataId: folderUid, + keyId: parentUid, + encryptionType: 'gcm', + unwrappedType: 'aes', + } + } + await platform.unwrapKeys(encryptedByParentKeyMap, storage) +} + +const processKdFolderAccesses = async ( + storage: VaultStorage, + keeperDriveFolderAccesses?: Folder.IFolderAccessData[] | null +) => { + if (!keeperDriveFolderAccesses) return + const folderKeyMap: UnwrapKeyMap = {} + for (const folderAccess of keeperDriveFolderAccesses) { + const folderUid = webSafe64FromBytes(folderAccess.folderUid!) + if ( + !folderAccess.folderUid || + !folderAccess.accessTypeUid || + !folderAccess.accessRoleType || + !folderAccess.accessType || + !folderAccess.permissions + ) + continue + const accessTypeUid = webSafe64FromBytes(folderAccess.accessTypeUid) + const permission = folderAccess.permissions + // for child folders, they're only encrypted by their parent folder key + if ( + folderAccess.folderKey && + folderAccess.folderKey.encryptedKey && + !isNil(folderAccess.folderKey.encryptedKeyType) + ) { + const keyInfo = + folderAccess.accessType === Folder.AccessType.AT_USER + ? mapKeyType(folderAccess.folderKey.encryptedKeyType) + : folderAccess.accessType === Folder.AccessType.AT_TEAM + ? mapTeamKeyType(folderAccess.folderKey.encryptedKeyType, accessTypeUid) + : null + if (!keyInfo) continue + folderKeyMap[folderUid] = { + data: folderAccess.folderKey.encryptedKey, + dataId: folderUid, + keyId: keyInfo.keyId, + encryptionType: keyInfo.encryptionType, + unwrappedType: 'aes', + } + } + await storage.put({ + kind: 'keeper_drive_folder_access', + accessUid: createKdFolderAccessCompositeKey(accessTypeUid, folderUid), + folderUid, + accessTypeUid, + accessType: folderAccess.accessType, + accessRoleType: folderAccess.accessRoleType, + permission, + }) + } + await platform.unwrapKeys(folderKeyMap, storage) +} + +const processKdFolderSharingState = async ( + storage: VaultStorage, + keeperDriveFolderSharingStates?: Vault.IFolderSharingState[] | null +) => { + if (!keeperDriveFolderSharingStates) return + for (const folderSharingState of keeperDriveFolderSharingStates) { + if (!folderSharingState.folderUid) continue + await storage.put({ + kind: 'keeper_drive_folder_sharing_state', + folderUid: webSafe64FromBytes(folderSharingState.folderUid), + shared: toOptional(folderSharingState.shared), + count: toOptional(folderSharingState.count), + }) + } +} + +const processKdFolders = async (storage: VaultStorage, keeperDriveFolders?: Folder.IFolderData[] | null) => { + if (!keeperDriveFolders) return + for (const folder of keeperDriveFolders || []) { + if ( + !folder.folderUid || + !folder.folderKey || + !folder.data || + !folder.ownerInfo || + folder.type !== Folder.FolderUsageType.UT_NORMAL + ) + continue + const folderUid = webSafe64FromBytes(folder.folderUid) + const parentUid = + folder.parentUid && folder.parentUid.length > 0 ? webSafe64FromBytes(folder.parentUid) : undefined + try { + const folderData = JSON.parse( + platform.bytesToString(await platform.decrypt(folder.data, folderUid, 'gcm', storage)) + ) + await storage.put({ + kind: 'keeper_drive_folder', + uid: folderUid, + data: folderData, + parentUid, + ownerInfo: { + accountUid: folder.ownerInfo.accountUid + ? webSafe64FromBytes(folder.ownerInfo.accountUid) + : undefined, + username: toOptional(folder.ownerInfo.username), + }, + lastModified: toOptional(folder.lastModified), + type: toOptional(folder.type), + inheritUserPermissions: toOptional(folder.inheritUserPermissions), + }) + } catch (err: any) { + console.error(`[ks] folder ${folderUid} cannot be decrypted (${err.message})`) + } + } +} + +const processKdRecordAccess = async (storage: VaultStorage, kdRecordAccesses?: Folder.IRecordAccessData[] | null) => { + if (!kdRecordAccesses) return + for (const recordAccess of kdRecordAccesses) { + if ( + !recordAccess.recordUid || + !recordAccess.accessTypeUid || + isNil(recordAccess.accessType) || + isNil(recordAccess.accessRoleType) + ) + continue + const recordUid = webSafe64FromBytes(recordAccess.recordUid) + const accessTypeUid = webSafe64FromBytes(recordAccess.accessTypeUid) + await storage.put({ + kind: 'keeper_drive_record_access', + accessUid: createKdRecordAccessCompositeKey(accessTypeUid, recordUid), + accessTypeUid, + accessType: recordAccess.accessType, + recordUid, + accessRoleType: recordAccess.accessRoleType, + owner: toOptional(recordAccess.owner), + inherited: toOptional(recordAccess.inherited), + hidden: toOptional(recordAccess.hidden), + deniedAccess: toOptional(recordAccess.deniedAccess), + canEdit: toOptional(recordAccess.canEdit), + canView: toOptional(recordAccess.canView), + canListAccess: toOptional(recordAccess.canListAccess), + canUpdateAccess: toOptional(recordAccess.canUpdateAccess), + canDelete: toOptional(recordAccess.canDelete), + canChangeOwnership: toOptional(recordAccess.canChangeOwnership), + canRequestAccess: toOptional(recordAccess.canRequestAccess), + canApproveAccess: toOptional(recordAccess.canApproveAccess), + dateCreated: toOptional(recordAccess.dateCreated), + lastModified: toOptional(recordAccess.lastModified), + tlaProperties: toOptional(recordAccess.tlaProperties), + }) + } +} + +const processKdFolderRecords = async ( + storage: VaultStorage, + dependencies: Dependencies, + kdFolderRecords?: Folder.IFolderRecord[] | null +) => { + if (!kdFolderRecords) return + const recordKeyMap: UnwrapKeyMap = {} + for (const folderRecord of kdFolderRecords) { + if ( + !folderRecord.folderUid || + !folderRecord.recordMetadata || + !folderRecord.recordMetadata.recordUid || + !folderRecord.recordMetadata.encryptedRecordKey || + isNil(folderRecord.recordMetadata.encryptedRecordKeyType) || + isNil(folderRecord.folderKeyEncryptionType) + ) + continue + const folderUid = webSafe64FromBytes(folderRecord.folderUid) + const recordUid = webSafe64FromBytes(folderRecord.recordMetadata.recordUid) + const keyInfo = mapKeyType(folderRecord.recordMetadata.encryptedRecordKeyType) + if (!keyInfo) continue + recordKeyMap[recordUid] = { + data: folderRecord.recordMetadata.encryptedRecordKey, + dataId: recordUid, + keyId: + folderRecord.folderKeyEncryptionType === Folder.FolderKeyEncryptionType.ENCRYPTED_BY_PARENT_KEY + ? folderUid + : keyInfo.keyId, + encryptionType: keyInfo?.encryptionType, + unwrappedType: 'aes', + } + if (folderUid) { + addDependencies(dependencies, folderUid, recordUid, 'record') + await storage.put({ + kind: 'keeper_drive_folder_record', + folderUid, + recordUid, + }) + } + } + await platform.unwrapKeys(recordKeyMap, storage) +} + +const processKdRecordSharingStates = async ( + storage: VaultStorage, + kdRecordSharingStates?: record.v3.sharing.IRecordSharingState[] | null +) => { + if (!kdRecordSharingStates) return + for (const sharingState of kdRecordSharingStates) { + if (!sharingState.recordUid) continue + await storage.put({ + kind: 'keeper_drive_record_sharing_state', + recordUid: webSafe64FromBytes(sharingState.recordUid), + isDirectlyShared: toOptional(sharingState.isDirectlyShared), + isIndirectlyShared: toOptional(sharingState.isIndirectlyShared), + isShared: toOptional(sharingState.isShared), + }) + } +} + +const processKdRecords = async ( + storage: VaultStorage, + kdRecordData?: Folder.IRecordData[] | null, + kdRecords?: Vault.IDriveRecord[] | null +) => { + if (!kdRecordData || !kdRecords) return + const kdRecordMap: { + [key in string]: Vault.IDriveRecord + } = {} + for (const record of kdRecords) { + if (!record.recordUid || !record.revision) continue + kdRecordMap[webSafe64FromBytes(record.recordUid)] = record + } + for (const record of kdRecordData) { + if (!record.recordUid || !record.data) continue + const recordUid = webSafe64FromBytes(record.recordUid) + const metadata = kdRecordMap[recordUid] || {} + if (!metadata.version) continue + try { + const decryptedData = await platform.decrypt(record.data, recordUid, 'gcm', storage) + const recordData = JSON.parse(platform.bytesToString(decryptedData)) + await storage.put({ + kind: 'record', + uid: recordUid, + data: recordData, + version: metadata.version, + revision: metadata.revision as number, + shared: !!metadata.shared, + clientModifiedTime: metadata.clientModifiedTime as number, + isKeeperDriveData: true, + }) + } catch (err: any) { + console.error(`[kd] record ${recordUid} cannot be decrypted: ${err.message}`) + } + } +} + +const processKdRemovedFolderRecords = ( + removedDependencies: RemovedDependencies, + keeperDriveRemovedFolderRecords?: Records.IFolderRecordKey[] | null +) => { + if (!keeperDriveRemovedFolderRecords) return + for (const folderRecord of keeperDriveRemovedFolderRecords) { + if (!folderRecord.recordUid || !folderRecord.folderUid) continue + const recordUid = webSafe64FromBytes(folderRecord.recordUid) + const folderUid = webSafe64FromBytes(folderRecord.folderUid) + addRemovedDependencies(removedDependencies, folderUid, { + parentKind: 'keeper_drive_folder', + childKind: 'record', + childUid: recordUid, + }) + } +} + +const processKdRevokedRecordAccesses = async ( + storage: VaultStorage, + kdRevokedAccesses?: record.v3.sharing.IRevokedAccess[] | null +) => { + if (!kdRevokedAccesses) return + for (const revokedAccess of kdRevokedAccesses) { + if (!revokedAccess.actorUid || !revokedAccess.recordUid) continue + const actorUid = webSafe64FromBytes(revokedAccess.actorUid) + const recordUid = webSafe64FromBytes(revokedAccess.recordUid) + await storage.delete('keeper_drive_record_access', createKdRecordAccessCompositeKey(actorUid, recordUid), { + kind: 'keeper_drive_record_access', + actorUid, + recordUid, + }) + } +} + +// Keeper Drive Processors End + export type SyncLogFormat = '!' | 'raw' | 'obj' | 'str' | 'cnt' | 'cnt_t' const logProtobuf = (data: any, format: SyncLogFormat, seqNo: number, counts: any) => { @@ -1087,15 +1502,20 @@ const logProtobuf = (data: any, format: SyncLogFormat, seqNo: number, counts: an } const getCounts = (obj: Vault.ISyncDownResponse): SyncResponseCounts => { - const results = {} - for (const prop in obj) { - if (['continuationToken', 'constructor'].includes(prop)) { - continue - } - if (obj[prop]?.length) { - results[prop] = obj[prop].length + const results: Record = {} + const collect = (source: any) => { + if (!source) return + for (const prop in source) { + if (['continuationToken', 'constructor', 'keeperDriveData'].includes(prop)) { + continue + } + if (source[prop]?.length) { + results[prop] = (results[prop] || 0) + source[prop].length + } } } + collect(obj) + collect(obj.keeperDriveData) return results } @@ -1221,6 +1641,7 @@ export const syncDown = async (options: SyncDownOptions): Promise => } result.pageCount += 1 networkTime += requestTime + const keeperDriveData = resp.keeperDriveData ?? {} const dependencies = {} await processUsers(resp.users, storage) @@ -1251,7 +1672,7 @@ export const syncDown = async (options: SyncDownOptions): Promise => await processRecordRotations(resp.recordRotations, storage) - await processNonSharedData(resp.nonSharedData, storage) + await processNonSharedData(storage, resp.nonSharedData) await processSharedFolderFolders(resp.sharedFolderFolders, storage, dependencies) @@ -1261,11 +1682,37 @@ export const syncDown = async (options: SyncDownOptions): Promise => await processProfilePic(resp.profilePic, storage) - await processBreachWatchRecords(resp.breachWatchRecords, storage) + await processBreachWatchRecords(storage, resp.breachWatchRecords) - await processBreachWatchSecurityData(resp.breachWatchSecurityData, storage) + await processBreachWatchSecurityData(storage, resp.breachWatchSecurityData) - await processSecurityScoreData(resp.securityScoreData, storage) + await processSecurityScoreData(storage, resp.securityScoreData) + + await processKdFolderAccesses(storage, keeperDriveData.folderAccesses) + + await processKdFolderKeys(storage, keeperDriveData.folderKeys) + + await processKdFolders(storage, keeperDriveData.folders) + + await processKdFolderSharingState(storage, keeperDriveData.folderSharingState) + + await processKdRecordAccess(storage, keeperDriveData.recordAccesses) + + await processKdFolderRecords(storage, dependencies, keeperDriveData.folderRecords) + + await processKdRecordLinks(storage, keeperDriveData.recordLinks) + + await processKdRecords(storage, keeperDriveData.recordData, keeperDriveData.records) + + await processNonSharedData(storage, keeperDriveData.nonSharedData) + + await processKdRecordSharingStates(storage, keeperDriveData.recordSharingStates) + + await processBreachWatchRecords(storage, keeperDriveData.breachWatchRecords) + + await processBreachWatchSecurityData(storage, keeperDriveData.breachWatchSecurityData) + + await processSecurityScoreData(storage, keeperDriveData.securityScoreData) await storage.addDependencies(dependencies) @@ -1325,6 +1772,16 @@ export const syncDown = async (options: SyncDownOptions): Promise => await storage.delete('user', user) } + await processKdRemovedFolders(storage, keeperDriveData.removedFolders) + + await processKdRevokedFolderAccesses(storage, keeperDriveData.revokedFolderAccesses) + + processKdRemovedFolderRecords(removedDependencies, keeperDriveData.removedFolderRecords) + + await processKdRevokedRecordAccesses(storage, keeperDriveData.revokedRecordAccesses) + + await processKdRemovedRecordLinks(removedDependencies, keeperDriveData.removedRecordLinks) + await storage.removeDependencies(removedDependencies) continuationToken = resp.continuationToken || undefined