chore: Update from Typescript

The way that fields were emitted by Typescript changed.
`declare` will make Typescript not emit the field.
This means that `readOnlyProperty` will correctly add the filed.

See:
https://www.typescriptlang.org/tsconfig#useDefineForClassFields

Author: seebees

modules/caching-materials-manager-browser/src/caching_materials_manager_browser.ts

@@ -32,12 +32,12 @@ const cacheKeyHelpers = buildCryptographicMaterialsCacheKeyHelpers(
 
 export class WebCryptoCachingMaterialsManager
   implements CachingMaterialsManager<WebCryptoAlgorithmSuite> {
-  readonly _cache!: CryptographicMaterialsCache<WebCryptoAlgorithmSuite>
-  readonly _backingMaterialsManager!: WebCryptoMaterialsManager
-  readonly _partition!: string
-  readonly _maxBytesEncrypted!: number
-  readonly _maxMessagesEncrypted!: number
-  readonly _maxAge!: number
+  declare readonly _cache: CryptographicMaterialsCache<WebCryptoAlgorithmSuite>
+  declare readonly _backingMaterialsManager: WebCryptoMaterialsManager
+  declare readonly _partition: string
+  declare readonly _maxBytesEncrypted: number
+  declare readonly _maxMessagesEncrypted: number
+  declare readonly _maxAge: number
 
   constructor(input: CachingMaterialsManagerInput<WebCryptoAlgorithmSuite>) {
     const backingMaterialsManager =

modules/caching-materials-manager-browser/test/caching_materials_manager_browser.test.ts

@@ -43,11 +43,36 @@ describe('WebCryptoCachingMaterialsManager', () => {
     expect(test._backingMaterialsManager).to.be.instanceOf(
       WebCryptoDefaultCryptographicMaterialsManager
     )
-    expect(test._cache).to.equal(cache)
-    expect(test._partition).to.equal(partition)
-    expect(test._maxAge).to.equal(maxAge)
-    expect(test._maxBytesEncrypted).to.equal(maxBytesEncrypted)
-    expect(test._maxMessagesEncrypted).to.equal(maxMessagesEncrypted)
+    expect(test).to.haveOwnPropertyDescriptor('_cache', {
+      value: cache,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_partition', {
+      value: partition,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_maxAge', {
+      value: maxAge,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_maxBytesEncrypted', {
+      value: maxBytesEncrypted,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_maxMessagesEncrypted', {
+      value: maxMessagesEncrypted,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
   })
 
   it('Precondition: A partition value must exist for WebCryptoCachingMaterialsManager.', () => {

modules/caching-materials-manager-node/src/caching_materials_manager_node.ts

@@ -33,12 +33,12 @@ const cacheKeyHelpers = buildCryptographicMaterialsCacheKeyHelpers(
 
 export class NodeCachingMaterialsManager
   implements CachingMaterialsManager<NodeAlgorithmSuite> {
-  readonly _cache!: CryptographicMaterialsCache<NodeAlgorithmSuite>
-  readonly _backingMaterialsManager!: NodeMaterialsManager
-  readonly _partition!: string
-  readonly _maxBytesEncrypted!: number
-  readonly _maxMessagesEncrypted!: number
-  readonly _maxAge!: number
+  declare readonly _cache: CryptographicMaterialsCache<NodeAlgorithmSuite>
+  declare readonly _backingMaterialsManager: NodeMaterialsManager
+  declare readonly _partition: string
+  declare readonly _maxBytesEncrypted: number
+  declare readonly _maxMessagesEncrypted: number
+  declare readonly _maxAge: number
 
   constructor(input: CachingMaterialsManagerInput<NodeAlgorithmSuite>) {
     const backingMaterialsManager =

modules/caching-materials-manager-node/test/caching_materials_manager_node.test.ts

@@ -42,11 +42,36 @@ describe('NodeCachingMaterialsManager', () => {
     expect(test._backingMaterialsManager).to.be.instanceOf(
       NodeDefaultCryptographicMaterialsManager
     )
-    expect(test._cache).to.equal(cache)
-    expect(test._partition).to.equal(partition)
-    expect(test._maxAge).to.equal(maxAge)
-    expect(test._maxBytesEncrypted).to.equal(maxBytesEncrypted)
-    expect(test._maxMessagesEncrypted).to.equal(maxMessagesEncrypted)
+    expect(test).to.haveOwnPropertyDescriptor('_cache', {
+      value: cache,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_partition', {
+      value: partition,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_maxAge', {
+      value: maxAge,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_maxBytesEncrypted', {
+      value: maxBytesEncrypted,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+    expect(test).to.haveOwnPropertyDescriptor('_maxMessagesEncrypted', {
+      value: maxMessagesEncrypted,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
   })
 
   it('Precondition: A partition value must exist for NodeCachingMaterialsManager.', () => {

modules/kms-keyring-browser/src/kms_mrk_discovery_keyring_browser.ts

@@ -24,7 +24,7 @@ export class AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser extends AwsKmsMrkAwa
   WebCryptoAlgorithmSuite,
   KMS
 >(KeyringWebCrypto as Newable<KeyringWebCrypto>) {
-  readonly client!: KMS
+  declare client: KMS
 
   constructor({
     client,

modules/kms-keyring-browser/src/kms_mrk_keyring_browser.ts

@@ -24,9 +24,9 @@ export class AwsKmsMrkAwareSymmetricKeyringBrowser extends AwsKmsMrkAwareSymmetr
   WebCryptoAlgorithmSuite,
   KMS
 >(KeyringWebCrypto as Newable<KeyringWebCrypto>) {
-  readonly client!: KMS
-  readonly keyId!: string
-  readonly grantTokens?: string[]
+  declare client: KMS
+  declare keyId: string
+  declare grantTokens?: string[]
 
   constructor({
     client,

modules/kms-keyring/src/kms_keyring.ts

@@ -70,12 +70,12 @@ export function KmsKeyringClass<
   Client extends AwsEsdkKMSInterface
 >(BaseKeyring: Newable<Keyring<S>>): KmsKeyRingConstructible<S, Client> {
   class KmsKeyring extends BaseKeyring implements KmsKeyRing<S, Client> {
-    public keyIds!: ReadonlyArray<string>
-    public generatorKeyId?: string
-    public clientProvider!: KmsClientSupplier<Client>
-    public grantTokens?: string[]
-    public isDiscovery!: boolean
-    public discoveryFilter?: Readonly<{
+    public declare keyIds: ReadonlyArray<string>
+    public declare generatorKeyId?: string
+    public declare clientProvider: KmsClientSupplier<Client>
+    public declare grantTokens?: string[]
+    public declare isDiscovery: boolean
+    public declare discoveryFilter?: Readonly<{
       accountIDs: readonly string[]
       partition: string
     }>

modules/kms-keyring/src/kms_mrk_discovery_keyring.ts

@@ -71,11 +71,12 @@ export function AwsKmsMrkAwareSymmetricDiscoveryKeyringClass<
     //# MUST implement that AWS Encryption SDK Keyring interface (../keyring-
     //# interface.md#interface)
     extends BaseKeyring
-    implements IAwsKmsMrkAwareSymmetricDiscoveryKeyring<S, Client> {
-    public client!: Client
-    public clientRegion!: string
-    public grantTokens?: string[]
-    public discoveryFilter?: Readonly<{
+    implements IAwsKmsMrkAwareSymmetricDiscoveryKeyring<S, Client>
+  {
+    public declare client: Client
+    public declare clientRegion: string
+    public declare grantTokens?: string[]
+    public declare discoveryFilter?: Readonly<{
       accountIDs: readonly string[]
       partition: string
     }>

modules/material-management-browser/src/browser_cryptographic_materials_manager.ts

@@ -41,7 +41,7 @@ export type WebCryptoGetDecryptMaterials = GetDecryptMaterials<WebCryptoAlgorith
  */
 export class WebCryptoDefaultCryptographicMaterialsManager
   implements WebCryptoMaterialsManager {
-  readonly keyring!: KeyringWebCrypto
+  declare readonly keyring: KeyringWebCrypto
   constructor(keyring: KeyringWebCrypto) {
     /* Precondition: keyrings must be a KeyringWebCrypto. */
     needs(keyring instanceof KeyringWebCrypto, 'Unsupported type.')

modules/material-management-node/src/node_cryptographic_materials_manager.ts

@@ -36,7 +36,7 @@ export type NodeGetDecryptMaterials = GetDecryptMaterials<NodeAlgorithmSuite>
  */
 export class NodeDefaultCryptographicMaterialsManager
   implements NodeMaterialsManager {
-  readonly keyring!: KeyringNode
+  declare readonly keyring: KeyringNode
   constructor(keyring: KeyringNode) {
     /* Precondition: keyrings must be a KeyringNode. */
     needs(keyring instanceof KeyringNode, 'Unsupported type.')

modules/material-management/src/algorithm_suites.ts

@@ -332,25 +332,25 @@ type AlgorithmSuiteValues = AesGcm &
   Partial<Omit<AlgCommittedSigned, keyof AesGcm>>
 
 export abstract class AlgorithmSuite implements AlgorithmSuiteValues {
-  id!: AlgorithmSuiteIdentifier
-  name!: AlgorithmSuiteName
-  messageFormat!: MessageFormat
-  encryption!: NodeEncryption | WebCryptoEncryption
-  keyLength!: KeyLength
-  keyLengthBytes!: number
-  ivLength!: IvLength
-  tagLength!: TagLength
-  cacheSafe!: boolean
-  kdf?: KDF
-  kdfHash?: NodeHash | WebCryptoHash
-  signatureCurve?: NodeECDHCurve | WebCryptoECDHCurve
-  signatureHash?: NodeHash | WebCryptoHash
-  type!: AlgorithmSuiteTypeNode | AlgorithmSuiteTypeWebCrypto
-  suiteDataLength?: SuiteDataLength
-  commitmentHash?: NodeHash | WebCryptoHash
-  commitmentLength?: CommitmentLength
-  saltLengthBytes?: HKDFSaltLengthBytes
-  commitment!: Commitment
+  declare id: AlgorithmSuiteIdentifier
+  declare name: AlgorithmSuiteName
+  declare messageFormat: MessageFormat
+  declare encryption: NodeEncryption | WebCryptoEncryption
+  declare keyLength: KeyLength
+  declare keyLengthBytes: number
+  declare ivLength: IvLength
+  declare tagLength: TagLength
+  declare cacheSafe: boolean
+  declare kdf?: KDF
+  declare kdfHash?: NodeHash | WebCryptoHash
+  declare signatureCurve?: NodeECDHCurve | WebCryptoECDHCurve
+  declare signatureHash?: NodeHash | WebCryptoHash
+  declare type: AlgorithmSuiteTypeNode | AlgorithmSuiteTypeWebCrypto
+  declare suiteDataLength?: SuiteDataLength
+  declare commitmentHash?: NodeHash | WebCryptoHash
+  declare commitmentLength?: CommitmentLength
+  declare saltLengthBytes?: HKDFSaltLengthBytes
+  declare commitment: Commitment
   constructor(suiteValues: AlgUnion) {
     needs(
       this.constructor !== AlgorithmSuite,

modules/material-management/src/encrypted_data_key.ts

@@ -39,10 +39,10 @@ export interface IEncryptedDataKey
   }> {}
 
 export class EncryptedDataKey {
-  readonly providerInfo!: string
-  readonly providerId!: string
-  readonly encryptedDataKey!: Uint8Array
-  readonly rawInfo?: Uint8Array
+  declare readonly providerInfo: string
+  declare readonly providerId: string
+  declare readonly encryptedDataKey: Uint8Array
+  declare readonly rawInfo?: Uint8Array
 
   constructor(edkInput: IEncryptedDataKey) {
     const { providerInfo, providerId, encryptedDataKey, rawInfo } = edkInput

modules/material-management/src/multi_keyring.ts

@@ -30,8 +30,8 @@ immutableClass(MultiKeyringNode)
 export class MultiKeyringWebCrypto
   extends KeyringWebCrypto
   implements MultiKeyring<WebCryptoAlgorithmSuite> {
-  public readonly generator?: KeyringWebCrypto
-  public readonly children!: ReadonlyArray<KeyringWebCrypto>
+  public declare readonly generator?: KeyringWebCrypto
+  public declare readonly children: ReadonlyArray<KeyringWebCrypto>
 
   constructor(input: MultiKeyringInput<WebCryptoAlgorithmSuite>) {
     super()

modules/material-management/src/node_algorithms.ts

@@ -268,15 +268,16 @@ const nodeAlgorithms: NodeAlgorithms = Object.freeze({
 
 export class NodeAlgorithmSuite
   extends AlgorithmSuite
-  implements NodeAlgorithmSuiteValues {
-  messageFormat!: MessageFormat
-  encryption!: NodeEncryption
-  commitment!: Commitment
-  kdfHash?: NodeHash
-  signatureCurve?: NodeECDHCurve
-  signatureHash?: NodeHash
+  implements NodeAlgorithmSuiteValues
+{
+  declare messageFormat: MessageFormat
+  declare encryption: NodeEncryption
+  declare commitment: Commitment
+  declare kdfHash?: NodeHash
+  declare signatureCurve?: NodeECDHCurve
+  declare signatureHash?: NodeHash
   type: AlgorithmSuiteTypeNode = 'node'
-  commitmentHash?: NodeHash
+  declare commitmentHash?: NodeHash
   constructor(id: AlgorithmSuiteIdentifier) {
     super(nodeAlgorithms[id])
     Object.setPrototypeOf(this, NodeAlgorithmSuite.prototype)

modules/material-management/src/signature_key.ts

@@ -24,9 +24,9 @@ import { AwsEsdkJsCryptoKey } from './types'
  */
 
 export class SignatureKey {
-  public readonly privateKey!: string | AwsEsdkJsCryptoKey
-  public readonly compressPoint!: Uint8Array
-  public readonly signatureCurve!: NodeECDHCurve | WebCryptoECDHCurve
+  public declare readonly privateKey: string | AwsEsdkJsCryptoKey
+  public declare readonly compressPoint: Uint8Array
+  public declare readonly signatureCurve: NodeECDHCurve | WebCryptoECDHCurve
   constructor(
     privateKey: Uint8Array | AwsEsdkJsCryptoKey,
     compressPoint: Uint8Array,

modules/material-management/src/web_crypto_algorithms.ts

@@ -321,15 +321,16 @@ const supportedWebCryptoAlgorithms: SupportedWebCryptoAlgorithms = Object.freeze
 
 export class WebCryptoAlgorithmSuite
   extends AlgorithmSuite
-  implements WebCryptoAlgorithmSuiteValues {
-  messageFormat!: MessageFormat
-  encryption!: WebCryptoEncryption
-  commitment!: Commitment
-  kdfHash?: WebCryptoHash
-  signatureCurve?: WebCryptoECDHCurve
-  signatureHash?: WebCryptoHash
+  implements WebCryptoAlgorithmSuiteValues
+{
+  declare messageFormat: MessageFormat
+  declare encryption: WebCryptoEncryption
+  declare commitment: Commitment
+  declare kdfHash?: WebCryptoHash
+  declare signatureCurve?: WebCryptoECDHCurve
+  declare signatureHash?: WebCryptoHash
   type: AlgorithmSuiteTypeWebCrypto = 'webCrypto'
-  commitmentHash?: WebCryptoHash
+  declare commitmentHash?: WebCryptoHash
   constructor(id: AlgorithmSuiteIdentifier) {
     super(webCryptoAlgorithms[id])
     /* Precondition: Browsers do not support 192 bit keys so the AlgorithmSuiteIdentifier is removed.

modules/raw-aes-keyring-browser/src/raw_aes_keyring_browser.ts

@@ -56,10 +56,10 @@ export type RawAesKeyringWebCryptoInput = {
 }
 
 export class RawAesKeyringWebCrypto extends KeyringWebCrypto {
-  public keyNamespace!: string
-  public keyName!: string
-  _wrapKey!: WrapKey<WebCryptoAlgorithmSuite>
-  _unwrapKey!: UnwrapKey<WebCryptoAlgorithmSuite>
+  public declare keyNamespace: string
+  public declare keyName: string
+  declare _wrapKey: WrapKey<WebCryptoAlgorithmSuite>
+  declare _unwrapKey: UnwrapKey<WebCryptoAlgorithmSuite>
 
   constructor(input: RawAesKeyringWebCryptoInput) {
     super()

modules/raw-aes-keyring-node/src/raw_aes_keyring_node.ts

@@ -43,10 +43,10 @@ export type RawAesKeyringNodeInput = {
 }
 
 export class RawAesKeyringNode extends KeyringNode {
-  public keyNamespace!: string
-  public keyName!: string
-  _wrapKey!: WrapKey<NodeAlgorithmSuite>
-  _unwrapKey!: UnwrapKey<NodeAlgorithmSuite>
+  public declare keyNamespace: string
+  public declare keyName: string
+  declare _wrapKey: WrapKey<NodeAlgorithmSuite>
+  declare _unwrapKey: UnwrapKey<NodeAlgorithmSuite>
 
   constructor(input: RawAesKeyringNodeInput) {
     super()

modules/raw-rsa-keyring-browser/src/raw_rsa_keyring_web_crypto.ts

@@ -40,10 +40,10 @@ import {
 } from './get_import_options'
 
 export class RawRsaKeyringWebCrypto extends KeyringWebCrypto {
-  public keyNamespace!: string
-  public keyName!: string
-  _wrapKey!: WrapKey<WebCryptoAlgorithmSuite>
-  _unwrapKey!: UnwrapKey<WebCryptoAlgorithmSuite>
+  public declare keyNamespace: string
+  public declare keyName: string
+  declare _wrapKey: WrapKey<WebCryptoAlgorithmSuite>
+  declare _unwrapKey: UnwrapKey<WebCryptoAlgorithmSuite>
 
   constructor(input: RawRsaKeyringWebCryptoInput) {
     super()

modules/raw-rsa-keyring-node/src/raw_rsa_keyring_node.ts

@@ -67,10 +67,10 @@ export type RawRsaKeyringNodeInput = {
 }
 
 export class RawRsaKeyringNode extends KeyringNode {
-  public keyNamespace!: string
-  public keyName!: string
-  _wrapKey!: WrapKey<NodeAlgorithmSuite>
-  _unwrapKey!: UnwrapKey<NodeAlgorithmSuite>
+  public declare keyNamespace: string
+  public declare keyName: string
+  declare _wrapKey: WrapKey<NodeAlgorithmSuite>
+  declare _unwrapKey: UnwrapKey<NodeAlgorithmSuite>
 
   constructor(input: RawRsaKeyringNodeInput) {
     super()