@ontemper/sdk 0.7.1-postgresql.2 → 0.7.1-postgresql.4

package/README.md

@@ -353,6 +353,49 @@ WebSocket tunnel. Each physical connection reads the current runtime token, and
 connection without a TCP fallback. `createPostgresqlPool` registers the password in the process-wide secret
 registry; inside a workflow handler, prefer `makePostgresqlPool`, which registers it in the workflow's own.
 
+## Resource records and Kafka
+
+`@temper/workflow/resources` gives Effect workflows what `@ontemper/resources` gives legacy ones: record schemas
+(`KafkaResource`, `S3Resource`, `AzureBlobResource`, `SftpResource`, `PostgresqlResource`), `kafkaConfig`, and a promise
+`env` for code that cannot run an Effect. Declare the Resource with `Resource` from the root; its secrets arrive as
+`Redacted` values, and `kafkaConfig` unwraps them itself. It loads the optional peers `@aws-sdk/credential-providers` and
+`aws-msk-iam-sasl-signer-js` only for AWS MSK IAM.
+
+```ts
+import { Resource } from '@temper/workflow';
+import { KafkaResource, kafkaConfig } from '@temper/workflow/resources';
+import { Kafka } from 'kafkajs';
+
+class Events extends Resource<Events>()('events', { type: 'kafka', schema: KafkaResource }) {}
+
+// In an Effect: const kafka = new Kafka(kafkaConfig(yield* Events));
+```
+
+For scripts outside Effect, the subpath exports the promise-style `env`:
+
+```ts
+import { env, S3Resource } from '@temper/workflow/resources';
+
+const archive = await env.resources.resolve('archive', S3Resource);
+const metadata = await env.resources.inspect('archive');
+const { key } = await env.resources.select({ resourceTypeKey: 'http_api', match: { tenantKey } });
+const region = await env.variables.get('PARTNER_REGION');
+```
+
+Without a schema, `resolve` returns the JSON object; with one, it decodes it and keeps extension fields.
+`ResourceNotFoundError` means the key or selection has no record. A found record with a missing reference
+fails with `InvalidResourceError`; unknown closed values in a built-in schema fail with `UnknownRecordValueError`.
+Authorization failures use `ResourcesUnauthorizedError`; outages use `ResourcesUnavailableError`.
+
+Promise reads use the same runtime API and Run token as the declarations. Their cache matches the legacy
+resolver: a 30 s TTL, up to 15 min of stale reads through an outage (5 min for selections), and a separate
+10 s select-miss cache with a cap of 60 distinct misses per minute. `{ cache: false }` bypasses it;
+`{ ttlMs }` sets a read's TTL. The legacy cache environment settings still apply.
+
+The runtime API cannot list Variables, so snapshot `initialize`, `reload`, `variables.tryGet`, and
+`variables.has` have no equivalent. The legacy partners and connections APIs are also excluded.
+Existing workflows can keep `@ontemper/resources`; this entry does not modify that package.
+
 ## Versions
 
 CI publishes every version to npm as `@ontemper/sdk`; nobody publishes by hand. Workflow code keeps
@@ -369,7 +412,8 @@ version; `pnpm sdk:pin` moves them all together.
 The package has nine entry points: `@temper/workflow`, `@temper/workflow/testing`,
 `@temper/workflow/contract`, `@temper/workflow/sftp`, `@temper/workflow/sftp/testing`,
 `@temper/workflow/edi`, `@temper/workflow/as2`, `@temper/workflow/as2/testing`, and `@temper/workflow/resources`.
-Only `/sftp` loads `ssh2`, and only a `/resources` PostgreSQL pool loads `pg` and `ws` (optional peer dependencies).
+Only `/sftp` loads `ssh2`. In `/resources`, only a PostgreSQL pool loads `pg` and `ws`, and only AWS MSK IAM loads
+`@aws-sdk/credential-providers` and `aws-msk-iam-sasl-signer-js` (optional peer dependencies).
 `@temper/workflow/contract` holds the runtime Resources HttpApi and the
 manifest, trigger, and invocation schemas that the platform imports. Workflow code rarely needs it.
 

package/dist/As2Resource.d.ts

@@ -1,113 +1,468 @@
 import { Schema } from 'effect';
 /** The resolved value of the `as2_identity` system type: our AS2 ID and the key pairs that sign and decrypt. */
-export declare const As2IdentityResource: Schema.Struct<{
+export declare const As2IdentityResource: Schema.StructWithRest<Schema.Struct<{
     readonly as2Id: Schema.String;
-    readonly keys: Schema.Union<readonly [Schema.Struct<{
+    readonly keys: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
         readonly certificate: Schema.String;
         readonly privateKey: Schema.RedactedFromValue<Schema.String>;
-        readonly secondaryCertificate: Schema.optionalKey<Schema.String>;
-        readonly secondaryPrivateKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
+        readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        readonly secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
         readonly mode: Schema.Literal<"combined">;
-    }>, Schema.Struct<{
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
         readonly mode: Schema.Literal<"separate">;
-        readonly signing: Schema.Struct<{
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
             certificate: Schema.String;
             privateKey: Schema.RedactedFromValue<Schema.String>;
-            secondaryCertificate: Schema.optionalKey<Schema.String>;
-            secondaryPrivateKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-        }>;
-        readonly encryption: Schema.Struct<{
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
             certificate: Schema.String;
             privateKey: Schema.RedactedFromValue<Schema.String>;
-            secondaryCertificate: Schema.optionalKey<Schema.String>;
-            secondaryPrivateKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-        }>;
-    }>]>;
-}>;
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly mode: Schema.Literal<"separate">;
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
+            certificate: Schema.String;
+            privateKey: Schema.RedactedFromValue<Schema.String>;
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
+            certificate: Schema.String;
+            privateKey: Schema.RedactedFromValue<Schema.String>;
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+    }>, "fields" | "mapFields">]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+    readonly as2Id: Schema.String;
+    readonly keys: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly certificate: Schema.String;
+        readonly privateKey: Schema.RedactedFromValue<Schema.String>;
+        readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        readonly secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        readonly mode: Schema.Literal<"combined">;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly mode: Schema.Literal<"separate">;
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
+            certificate: Schema.String;
+            privateKey: Schema.RedactedFromValue<Schema.String>;
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
+            certificate: Schema.String;
+            privateKey: Schema.RedactedFromValue<Schema.String>;
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly mode: Schema.Literal<"separate">;
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
+            certificate: Schema.String;
+            privateKey: Schema.RedactedFromValue<Schema.String>;
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
+            certificate: Schema.String;
+            privateKey: Schema.RedactedFromValue<Schema.String>;
+            secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+    }>, "fields" | "mapFields">]>;
+}>, "fields" | "mapFields">;
 export type As2IdentityResource = typeof As2IdentityResource.Type;
 /** The resolved value of the `as2_partner` system type; the referenced identity arrives inline under `identity`. */
-export declare const As2PartnerResource: Schema.Struct<{
-    readonly identity: Schema.Struct<{
+export declare const As2PartnerResource: Schema.StructWithRest<Schema.Struct<{
+    readonly identity: Schema.StructWithRest<Schema.Struct<{
         readonly as2Id: Schema.String;
-        readonly keys: Schema.Union<readonly [Schema.Struct<{
+        readonly keys: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
             readonly certificate: Schema.String;
             readonly privateKey: Schema.RedactedFromValue<Schema.String>;
-            readonly secondaryCertificate: Schema.optionalKey<Schema.String>;
-            readonly secondaryPrivateKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            readonly secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
             readonly mode: Schema.Literal<"combined">;
-        }>, Schema.Struct<{
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+            readonly mode: Schema.Literal<"separate">;
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly mode: Schema.Literal<"separate">;
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, "fields" | "mapFields">]>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly as2Id: Schema.String;
+        readonly keys: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly privateKey: Schema.RedactedFromValue<Schema.String>;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            readonly secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            readonly mode: Schema.Literal<"combined">;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+            readonly mode: Schema.Literal<"separate">;
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
             readonly mode: Schema.Literal<"separate">;
-            readonly signing: Schema.Struct<{
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
                 certificate: Schema.String;
                 privateKey: Schema.RedactedFromValue<Schema.String>;
-                secondaryCertificate: Schema.optionalKey<Schema.String>;
-                secondaryPrivateKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-            }>;
-            readonly encryption: Schema.Struct<{
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
                 certificate: Schema.String;
                 privateKey: Schema.RedactedFromValue<Schema.String>;
-                secondaryCertificate: Schema.optionalKey<Schema.String>;
-                secondaryPrivateKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-            }>;
-        }>]>;
-    }>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, "fields" | "mapFields">]>;
+    }>, "fields" | "mapFields">;
     readonly as2Id: Schema.String;
-    readonly url: Schema.optionalKey<Schema.String>;
-    readonly certificates: Schema.Union<readonly [Schema.Struct<{
+    readonly url: Schema.optional<Schema.String>;
+    readonly certificates: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
         readonly certificate: Schema.String;
-        readonly secondaryCertificate: Schema.optionalKey<Schema.String>;
+        readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
         readonly mode: Schema.Literal<"combined">;
-    }>, Schema.Struct<{
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly certificate: Schema.String;
+        readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        readonly mode: Schema.Literal<"combined">;
+    }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
         readonly mode: Schema.Literal<"separate">;
-        readonly encryption: Schema.Struct<{
-            readonly certificate: Schema.String;
-            readonly secondaryCertificate: Schema.optionalKey<Schema.String>;
-        }>;
-        readonly signing: Schema.Struct<{
-            readonly certificate: Schema.String;
-            readonly secondaryCertificate: Schema.optionalKey<Schema.String>;
-        }>;
-    }>]>;
-    readonly signOutgoing: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
-    readonly encryptOutgoing: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
-    readonly requireSignedIncoming: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
-    readonly requireEncryptedIncoming: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
-    readonly compression: Schema.withDecodingDefaultKey<Schema.Literals<readonly ["none", "zlib"]>, never>;
-    readonly receipt: Schema.withDecodingDefaultKey<Schema.Literals<readonly ["none", "sync", "async"]>, never>;
-    readonly receiptSigningAlgorithm: Schema.withDecodingDefaultKey<Schema.Literals<readonly ["sha-1", "sha-256", "sha-384", "sha-512"]>, never>;
-    readonly digestAlgorithm: Schema.withDecodingDefaultKey<Schema.Literals<readonly ["sha-1", "sha-256", "sha-384", "sha-512"]>, never>;
-    readonly encryptionAlgorithm: Schema.withDecodingDefaultKey<Schema.Literals<readonly ["3des", "aes128-cbc", "aes192-cbc", "aes256-cbc", "aes128-gcm", "aes256-gcm"]>, never>;
-    readonly httpAuth: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Struct<{
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly mode: Schema.Literal<"separate">;
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+    }>, "fields" | "mapFields">]>;
+    readonly signOutgoing: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly encryptOutgoing: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly requireSignedIncoming: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly requireEncryptedIncoming: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly compression: Schema.withDecodingDefault<Schema.Literals<readonly ["none", "zlib"]>, never>;
+    readonly receipt: Schema.withDecodingDefault<Schema.Literals<readonly ["none", "sync", "async"]>, never>;
+    readonly receiptSigningAlgorithm: Schema.withDecodingDefault<Schema.Literals<readonly ["sha-1", "sha-256", "sha-384", "sha-512"]>, never>;
+    readonly digestAlgorithm: Schema.withDecodingDefault<Schema.Literals<readonly ["sha-1", "sha-256", "sha-384", "sha-512"]>, never>;
+    readonly encryptionAlgorithm: Schema.withDecodingDefault<Schema.Literals<readonly ["3des", "aes128-cbc", "aes192-cbc", "aes256-cbc", "aes128-gcm", "aes256-gcm"]>, never>;
+    readonly httpAuth: Schema.withDecodingDefault<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
         readonly type: Schema.Literal<"none">;
-    }>, Schema.Struct<{
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly type: Schema.Literal<"none">;
+    }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.Literal<"basic">;
+        readonly username: Schema.String;
+        readonly password: Schema.RedactedFromValue<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
         readonly type: Schema.Literal<"basic">;
         readonly username: Schema.String;
         readonly password: Schema.RedactedFromValue<Schema.String>;
-    }>]>, never>;
-    readonly tls: Schema.optionalKey<Schema.Struct<{
-        readonly caCertificate: Schema.optionalKey<Schema.String>;
-        readonly clientCertificate: Schema.optionalKey<Schema.String>;
-        readonly clientKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-        readonly clientKeyPassphrase: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-        readonly serverName: Schema.optionalKey<Schema.String>;
-    }>>;
-    readonly proxy: Schema.optionalKey<Schema.Struct<{
+    }>, "fields" | "mapFields">]>, never>;
+    readonly tls: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+        readonly caCertificate: Schema.optional<Schema.String>;
+        readonly clientCertificate: Schema.optional<Schema.String>;
+        readonly clientKey: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+        readonly clientKeyPassphrase: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+        readonly serverName: Schema.optional<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    readonly proxy: Schema.optional<Schema.StructWithRest<Schema.Struct<{
         readonly url: Schema.String;
-        readonly auth: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Struct<{
+        readonly auth: Schema.withDecodingDefault<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"none">;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
             readonly type: Schema.Literal<"none">;
-        }>, Schema.Struct<{
+        }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"basic">;
+            readonly username: Schema.String;
+            readonly password: Schema.RedactedFromValue<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly type: Schema.Literal<"basic">;
+            readonly username: Schema.String;
+            readonly password: Schema.RedactedFromValue<Schema.String>;
+        }>, "fields" | "mapFields">]>, never>;
+        readonly tls: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+            readonly caCertificate: Schema.optional<Schema.String>;
+            readonly clientCertificate: Schema.optional<Schema.String>;
+            readonly clientKey: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly clientKeyPassphrase: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly serverName: Schema.optional<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly auth: Schema.withDecodingDefault<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"none">;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly type: Schema.Literal<"none">;
+        }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"basic">;
+            readonly username: Schema.String;
+            readonly password: Schema.RedactedFromValue<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly type: Schema.Literal<"basic">;
+            readonly username: Schema.String;
+            readonly password: Schema.RedactedFromValue<Schema.String>;
+        }>, "fields" | "mapFields">]>, never>;
+        readonly tls: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+            readonly caCertificate: Schema.optional<Schema.String>;
+            readonly clientCertificate: Schema.optional<Schema.String>;
+            readonly clientKey: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly clientKeyPassphrase: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly serverName: Schema.optional<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    }>, "fields" | "mapFields">>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+    readonly identity: Schema.StructWithRest<Schema.Struct<{
+        readonly as2Id: Schema.String;
+        readonly keys: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly privateKey: Schema.RedactedFromValue<Schema.String>;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            readonly secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            readonly mode: Schema.Literal<"combined">;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+            readonly mode: Schema.Literal<"separate">;
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly mode: Schema.Literal<"separate">;
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, "fields" | "mapFields">]>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly as2Id: Schema.String;
+        readonly keys: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly privateKey: Schema.RedactedFromValue<Schema.String>;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+            readonly secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            readonly mode: Schema.Literal<"combined">;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+            readonly mode: Schema.Literal<"separate">;
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly mode: Schema.Literal<"separate">;
+            readonly signing: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+            readonly encryption: Schema.StructWithRest<Schema.Struct<{
+                certificate: Schema.String;
+                privateKey: Schema.RedactedFromValue<Schema.String>;
+                secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+                secondaryPrivateKey: Schema.compose<Schema.optional<Schema.RedactedFromValue<Schema.String>>, Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+        }>, "fields" | "mapFields">]>;
+    }>, "fields" | "mapFields">;
+    readonly as2Id: Schema.String;
+    readonly url: Schema.optional<Schema.String>;
+    readonly certificates: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly certificate: Schema.String;
+        readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        readonly mode: Schema.Literal<"combined">;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly certificate: Schema.String;
+        readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        readonly mode: Schema.Literal<"combined">;
+    }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
+        readonly mode: Schema.Literal<"separate">;
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly mode: Schema.Literal<"separate">;
+        readonly encryption: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+        readonly signing: Schema.StructWithRest<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly certificate: Schema.String;
+            readonly secondaryCertificate: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optional<Schema.String>, never, never>;
+        }>, "fields" | "mapFields">;
+    }>, "fields" | "mapFields">]>;
+    readonly signOutgoing: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly encryptOutgoing: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly requireSignedIncoming: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly requireEncryptedIncoming: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly compression: Schema.withDecodingDefault<Schema.Literals<readonly ["none", "zlib"]>, never>;
+    readonly receipt: Schema.withDecodingDefault<Schema.Literals<readonly ["none", "sync", "async"]>, never>;
+    readonly receiptSigningAlgorithm: Schema.withDecodingDefault<Schema.Literals<readonly ["sha-1", "sha-256", "sha-384", "sha-512"]>, never>;
+    readonly digestAlgorithm: Schema.withDecodingDefault<Schema.Literals<readonly ["sha-1", "sha-256", "sha-384", "sha-512"]>, never>;
+    readonly encryptionAlgorithm: Schema.withDecodingDefault<Schema.Literals<readonly ["3des", "aes128-cbc", "aes192-cbc", "aes256-cbc", "aes128-gcm", "aes256-gcm"]>, never>;
+    readonly httpAuth: Schema.withDecodingDefault<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.Literal<"none">;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly type: Schema.Literal<"none">;
+    }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.Literal<"basic">;
+        readonly username: Schema.String;
+        readonly password: Schema.RedactedFromValue<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly type: Schema.Literal<"basic">;
+        readonly username: Schema.String;
+        readonly password: Schema.RedactedFromValue<Schema.String>;
+    }>, "fields" | "mapFields">]>, never>;
+    readonly tls: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+        readonly caCertificate: Schema.optional<Schema.String>;
+        readonly clientCertificate: Schema.optional<Schema.String>;
+        readonly clientKey: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+        readonly clientKeyPassphrase: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+        readonly serverName: Schema.optional<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    readonly proxy: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly auth: Schema.withDecodingDefault<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"none">;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly type: Schema.Literal<"none">;
+        }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"basic">;
+            readonly username: Schema.String;
+            readonly password: Schema.RedactedFromValue<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly type: Schema.Literal<"basic">;
+            readonly username: Schema.String;
+            readonly password: Schema.RedactedFromValue<Schema.String>;
+        }>, "fields" | "mapFields">]>, never>;
+        readonly tls: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+            readonly caCertificate: Schema.optional<Schema.String>;
+            readonly clientCertificate: Schema.optional<Schema.String>;
+            readonly clientKey: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly clientKeyPassphrase: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly serverName: Schema.optional<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly auth: Schema.withDecodingDefault<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"none">;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
+            readonly type: Schema.Literal<"none">;
+        }>, "fields" | "mapFields">, Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.Literal<"basic">;
+            readonly username: Schema.String;
+            readonly password: Schema.RedactedFromValue<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]> & Pick<Schema.Struct<{
             readonly type: Schema.Literal<"basic">;
             readonly username: Schema.String;
             readonly password: Schema.RedactedFromValue<Schema.String>;
-        }>]>, never>;
-        readonly tls: Schema.optionalKey<Schema.Struct<{
-            readonly caCertificate: Schema.optionalKey<Schema.String>;
-            readonly clientCertificate: Schema.optionalKey<Schema.String>;
-            readonly clientKey: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-            readonly clientKeyPassphrase: Schema.optionalKey<Schema.RedactedFromValue<Schema.String>>;
-            readonly serverName: Schema.optionalKey<Schema.String>;
-        }>>;
-    }>>;
-}>;
+        }>, "fields" | "mapFields">]>, never>;
+        readonly tls: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+            readonly caCertificate: Schema.optional<Schema.String>;
+            readonly clientCertificate: Schema.optional<Schema.String>;
+            readonly clientKey: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly clientKeyPassphrase: Schema.optional<Schema.RedactedFromValue<Schema.String>>;
+            readonly serverName: Schema.optional<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    }>, "fields" | "mapFields">>;
+}>, "fields" | "mapFields">;
 export type As2PartnerResource = typeof As2PartnerResource.Type;
 //# sourceMappingURL=As2Resource.d.ts.map