@cubist-labs/cubesigner-sdk 0.4.237 → 0.4.241

package/dist/src/schema_types.js

@@ -40,4 +40,4 @@ exports.ALL_OPERATION_KINDS = Object.keys(AllOperationKinds);
 function coercePolicyInfo(p) {
     return p;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema_types.js","sourceRoot":"","sources":["../../src/schema_types.ts"],"names":[],"mappings":";;;AA+SA,4CAEC;AA1QD,QAAQ;AACR,8EAA8E;AAC9E,oFAAoF;AACpF,MAAM,iBAAiB,GAAgC;IACrD,OAAO,EAAE,IAAI;IACb,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,IAAI;IACpB,mBAAmB,EAAE,IAAI;IACzB,cAAc,EAAE,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,cAAc,EAAE,IAAI;IACpB,OAAO,EAAE,IAAI;IACb,aAAa,EAAE,IAAI;IACnB,QAAQ,EAAE,IAAI;IACd,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,IAAI;IACb,cAAc,EAAE,IAAI;IACpB,UAAU,EAAE,IAAI;CACjB,CAAC;AACW,QAAA,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAA6B,CAAC;AAsO9F;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,CAAwB;IACvD,OAAO,CAAe,CAAC;AACzB,CAAC","sourcesContent":["import type { components, operations, paths } from \"./schema\";\nimport type { JsonMap, JsonValue } from \"./util\";\n\nexport type schemas = components[\"schemas\"];\n\nexport type UserInfo = schemas[\"UserInfo\"];\nexport type UserInOrgMembership = schemas[\"UserInOrgMembership\"];\nexport type ConfiguredMfa = schemas[\"ConfiguredMfa\"];\nexport type RatchetConfig = schemas[\"RatchetConfig\"];\nexport type IdentityProof = schemas[\"IdentityProof\"];\nexport type AddIdentityRequest = schemas[\"AddIdentityRequest\"];\nexport type ListIdentityResponse = schemas[\"ListIdentitiesResponse\"];\nexport type TotpInfo = schemas[\"TotpInfo\"];\n\nexport type OidcAuthResponse = schemas[\"NewSessionResponse\"];\nexport type ApiAddFidoChallenge = schemas[\"FidoCreateChallengeResponse\"];\nexport type ApiMfaFidoChallenge = schemas[\"FidoAssertChallenge\"];\n\nexport type PublicKeyCredentialCreationOptions = schemas[\"PublicKeyCredentialCreationOptions\"];\nexport type PublicKeyCredentialRequestOptions = schemas[\"PublicKeyCredentialRequestOptions\"];\nexport type PublicKeyCredentialParameters = schemas[\"PublicKeyCredentialParameters\"];\nexport type PublicKeyCredentialDescriptor = schemas[\"PublicKeyCredentialDescriptor\"];\nexport type AuthenticatorSelectionCriteria = schemas[\"AuthenticatorSelectionCriteria\"];\nexport type PublicKeyCredentialUserEntity = schemas[\"PublicKeyCredentialUserEntity\"];\nexport type PublicKeyCredential = schemas[\"PublicKeyCredential\"];\n\nexport type OrgInfo = schemas[\"OrgInfo\"];\nexport type OrgExtData = NonNullable<OrgInfo[\"ext_data\"]>;\nexport type PublicOrgInfo = schemas[\"PublicOrgInfo\"];\nexport type UserInOrgInfo = schemas[\"UserInOrgInfo\"];\nexport type UpdateOrgRequest = schemas[\"UpdateOrgRequest\"];\nexport type OrgExtProps = NonNullable<UpdateOrgRequest[\"ext_props\"]>;\nexport type UpdateOrgResponse = schemas[\"UpdateOrgResponse\"];\nexport type UpdateUserMembershipRequest = schemas[\"UpdateUserMembershipRequest\"];\nexport type NotificationEndpointConfiguration = schemas[\"NotificationEndpointConfiguration\"];\nexport type OrgEvents = schemas[\"OrgEventDiscriminants\"];\nexport type BillingEvent = schemas[\"BillingEvent\"];\nexport type OperationKind = schemas[\"OperationKind\"];\n\n// NOTE:\n//   we use `Record<OperationKind, ...>` (instead of `OperationKind[]`) to get\n//   the type checker to complain unless this record includes every single operation\nconst AllOperationKinds: Record<OperationKind, true> = {\n  AvaSign: true,\n  AvaChainTxSign: true,\n  BabylonCovSign: true,\n  BabylonRegistration: true,\n  BabylonStaking: true,\n  BlobSign: true,\n  BtcMessageSign: true,\n  BtcSign: true,\n  DiffieHellman: true,\n  PsbtSign: true,\n  TaprootSign: true,\n  Eip191Sign: true,\n  Eip712Sign: true,\n  EotsNonces: true,\n  EotsSign: true,\n  Eth1Sign: true,\n  Eth2Sign: true,\n  Eth2Stake: true,\n  Eth2Unstake: true,\n  SolanaSign: true,\n  SuiSign: true,\n  TendermintSign: true,\n  RoleUpdate: true,\n};\nexport const ALL_OPERATION_KINDS = Object.keys(AllOperationKinds) as readonly OperationKind[];\n\nexport type OrgData = schemas[\"OrgData\"];\nexport type UserOrgsResponse = schemas[\"UserOrgsResponse\"];\n\nexport type OidcIdentity = schemas[\"OidcIdentity\"];\nexport type MemberRole = schemas[\"MemberRole\"];\n\nexport type SchemaKeyType = schemas[\"KeyType\"];\n\nexport type ListKeysResponse = schemas[\"PaginatedListKeysResponse\"];\nexport type UpdateKeyRequest = schemas[\"UpdateKeyRequest\"];\nexport type KeyProperties = schemas[\"CreateAndUpdateKeyProperties\"];\nexport type CreateKeyRequest = schemas[\"CreateKeyRequest\"];\nexport type KeyInfo = schemas[\"KeyInfo\"];\nexport type KeyInfoJwt = schemas[\"KeyInfoJwt\"];\nexport type KeyAttestationClaims = schemas[\"KeyAttestationClaims\"];\nexport type KeyAttestationQuery =\n  paths[\"/v0/org/{org_id}/keys/{key_id}/attest\"][\"get\"][\"parameters\"][\"query\"];\nexport type RoleInfoJwt = schemas[\"RoleInfoJwt\"];\nexport type RoleAttestationClaims = schemas[\"RoleAttestationClaims\"];\nexport type RoleAttestationQuery =\n  paths[\"/v0/org/{org_id}/roles/{role_id}/attest\"][\"get\"][\"parameters\"][\"query\"];\nexport type RoleAttestationVerbosity = schemas[\"RoleAttestationVerbosity\"];\nexport type KeyInRoleInfo = schemas[\"KeyInRoleInfo\"];\nexport type GetUsersInOrgResponse = schemas[\"PaginatedGetUsersInOrgResponse\"];\nexport type GetUserByEmailResponse = schemas[\"GetUserByEmailResponse\"];\nexport type GetUserByOidcResponse = schemas[\"GetUserByOidcResponse\"];\n\nexport type UserInRoleInfo = schemas[\"UserInRoleInfo\"];\nexport type KeyTypeApi = schemas[\"KeyType\"];\n\nexport type ListKeyRolesResponse = schemas[\"PaginatedListKeyRolesResponse\"];\nexport type ListRolesResponse = schemas[\"PaginatedListRolesResponse\"];\nexport type ListRoleKeysResponse = schemas[\"PaginatedListRoleKeysResponse\"];\nexport type ListRoleUsersResponse = schemas[\"PaginatedListRoleUsersResponse\"];\nexport type UpdateRoleRequest = schemas[\"UpdateRoleRequest\"];\nexport type KeyWithPoliciesInfo = schemas[\"KeyInRoleInfo\"];\nexport type RoleInfo = schemas[\"RoleInfo\"];\nexport type RoleAction = schemas[\"RoleAction\"];\nexport type RestrictedActionsMap = Partial<Record<RoleAction, MemberRole[]>>;\n\nexport type SessionInfo = schemas[\"SessionInfo\"];\nexport type ClientSessionInfo = schemas[\"ClientSessionInfo\"];\nexport type NewSessionResponse = schemas[\"NewSessionResponse\"];\nexport type SessionsResponse = schemas[\"PaginatedSessionsResponse\"];\n\nexport type EditPolicy = schemas[\"EditPolicy\"];\n\nexport type ContactInfo = schemas[\"ContactInfoResponse\"];\nexport type AddressMap = schemas[\"AddressMap\"];\nexport type BtcChain = schemas[\"BtcChain\"];\nexport type SuiChain = schemas[\"SuiChain\"];\nexport type CreateContactRequest = schemas[\"CreateContactRequest\"];\nexport type UpdateContactRequest = schemas[\"UpdateContactRequest\"];\nexport type ListContactsResponse = schemas[\"PaginatedListContactsResponse\"];\nexport type ContactLabel = schemas[\"ContactLabel\"];\nexport type ContactAddressData = schemas[\"ContactAddressData\"];\n\nexport type CreateSignerSessionRequest = schemas[\"CreateTokenRequest\"];\nexport type RefreshSignerSessionRequest = schemas[\"AuthData\"];\n\nexport type EvmSignRequest = schemas[\"Eth1SignRequest\"];\nexport type EvmSignResponse = schemas[\"Eth1SignResponse\"];\nexport type Eip191SignRequest = schemas[\"Eip191SignRequest\"];\nexport type Eip712SignRequest = schemas[\"Eip712SignRequest\"];\nexport type Eip191Or712SignResponse = schemas[\"SignResponse\"];\nexport type Eth2SignRequest = schemas[\"Eth2SignRequest\"];\nexport type Eth2SignResponse = schemas[\"SignResponse\"];\nexport type Eth2StakeRequest = schemas[\"StakeRequest\"];\nexport type Eth2StakeResponse = schemas[\"StakeResponse\"];\nexport type Eth2UnstakeRequest = schemas[\"UnstakeRequest\"];\nexport type Eth2UnstakeResponse = schemas[\"UnstakeResponse\"];\nexport type BlobSignRequest = schemas[\"BlobSignRequest\"];\nexport type BlobSignResponse = schemas[\"SignResponse\"];\nexport type BtcSignRequest = schemas[\"BtcSignRequest\"];\nexport type BtcSignResponse = schemas[\"SignResponse\"];\nexport type BtcMessageSignRequest = schemas[\"BtcMessageSignRequest\"];\nexport type BtcMessageSignResponse = schemas[\"BtcMessageSignResponse\"];\nexport type PsbtSignRequest = schemas[\"PsbtSignRequest\"];\nexport type PsbtSignResponse = schemas[\"PsbtSignResponse\"];\nexport type TaprootSignRequest = schemas[\"TaprootSignRequest\"];\nexport type TaprootSignResponse = schemas[\"SignResponse\"];\nexport type EotsSignRequest = schemas[\"EotsSignRequest\"];\nexport type EotsSignResponse = schemas[\"SignResponse\"];\nexport type EotsCreateNonceRequest = schemas[\"EotsCreateNonceRequest\"];\nexport type EotsCreateNonceResponse = schemas[\"EotsCreateNonceResponse\"];\nexport type BabylonStakingRequest = schemas[\"BabylonStakingRequest\"];\nexport type BabylonStakingResponse = schemas[\"BabylonStakingResponse\"];\nexport type BabylonStakingEarlyUnbond = schemas[\"BabylonStakingEarlyUnbond\"];\nexport type BabylonStakingWithdrawal = schemas[\"BabylonStakingWithdrawal\"];\nexport type BabylonRegistrationRequest = schemas[\"BabylonRegistrationRequest\"];\nexport type BabylonRegistrationResponse = schemas[\"BabylonRegistrationResponse\"];\nexport type SolanaSignRequest = schemas[\"SolanaSignRequest\"];\nexport type SolanaSignResponse = schemas[\"SignResponse\"];\nexport type AvaSignRequest = schemas[\"AvaSignRequest\"];\nexport type AvaSignResponse = schemas[\"SignResponse\"];\nexport type AvaSerializedTxSignRequest = schemas[\"AvaSerializedTxSignRequest\"];\nexport type SuiSignRequest = schemas[\"SuiSignRequest\"];\nexport type SuiSignResponse = schemas[\"SignResponse\"];\n\nexport type PendingMessageSignResponse = schemas[\"PendingMessageSignResponse\"];\nexport type PendingMessageInfo = schemas[\"PendingMessageInfo\"];\nexport type EvmTransaction = schemas[\"Transaction\"];\nexport type TypedTransaction = schemas[\"TypedTransaction\"];\nexport type TransactionAndStatus = schemas[\"TransactionAndStatus\"];\nexport type SignedMessage = schemas[\"SignedMessage\"];\nexport type MmiMetadata = schemas[\"MmiMetadata\"];\nexport type MmiStatus = schemas[\"MmiStatus\"];\nexport type Eip191Message = NonNullable<PendingMessageInfo[\"message_eip191\"]>;\nexport type Eip712Message = NonNullable<PendingMessageInfo[\"message_eip712\"]>;\n\nexport type JrpcResponse = schemas[\"JrpcResponse\"];\nexport type MmiJrpcMethod =\n  | \"custodian_listAccounts\"\n  | \"custodian_listAccountsSigned\"\n  | \"custodian_listAccountChainIds\"\n  | \"custodian_createTransaction\"\n  | \"custodian_sign\"\n  | \"custodian_signTypedData\"\n  | \"custodian_getSignedMessageById\"\n  | \"custodian_getTransactionById\"\n  | \"custodian_getCustomerProof\"\n  | \"custodian_replaceTransaction\"\n  | \"custodian_getTransactionLink\"\n  | \"custodian_getSignedMessageLink\";\n\nexport type AcceptedResponse = schemas[\"AcceptedResponse\"];\nexport type ErrorResponse = schemas[\"ErrorResponse\"];\nexport type BtcSignatureKind = schemas[\"BtcSignatureKind\"];\nexport type CsErrCode = schemas[\"SignerErrorCode\"];\n\nexport type MfaType =\n  | \"CubeSigner\"\n  | \"Fido\"\n  | `FidoKey#${string}`\n  | \"Totp\"\n  | \"EmailOtp\"\n  | `EmailOtp#${number}`;\nexport type MfaPolicy = Omit<schemas[\"MfaPolicy\"], \"allowed_mfa_types\"> & {\n  /** Allowed approval types. When omitted, defaults to any. */\n  allowed_mfa_types?: MfaType[] | null; // overriding to use a stronger `MfaType` type\n};\nexport type MfaVote = schemas[\"MfaVote\"];\nexport type MfaRequestInfo = schemas[\"MfaRequestInfo\"];\nexport type MfaProtectedAction = schemas[\"MfaProtectedAction\"];\nexport type MfaRequired = schemas[\"AcceptedValue\"][\"MfaRequired\"];\nexport type EvmTxCmp = schemas[\"EvmTxCmp\"];\nexport type SolanaTxCmp = schemas[\"SolanaTxCmp\"];\n\nexport type CreateOrgRequest = schemas[\"CreateOrgRequest\"];\nexport type OrgMetricName = schemas[\"MetricName\"];\nexport type QueryMetricsRequest = schemas[\"QueryMetricsRequest\"];\nexport type QueryMetricsResponse = schemas[\"QueryMetricsResponse\"];\nexport type AuditLogRequest = schemas[\"AuditLogRequest\"];\nexport type AuditLogResponse = schemas[\"PaginatedAuditLogResponse\"];\nexport type AuditLogEntry = schemas[\"AuditLogEntry\"];\n\nexport type DiffieHellmanRequest = schemas[\"DiffieHellmanRequest\"];\nexport type DiffieHellmanResponse = schemas[\"DiffieHellmanResponse\"];\n\nexport type UserExportInitRequest = schemas[\"UserExportInitRequest\"];\nexport type UserExportInitResponse = schemas[\"UserExportInitResponse\"];\nexport type UserExportCompleteRequest = schemas[\"UserExportCompleteRequest\"];\nexport type UserExportCompleteResponse = schemas[\"UserExportCompleteResponse\"];\nexport type UserExportListResponse = schemas[\"PaginatedUserExportListResponse\"];\nexport type UserExportKeyMaterial = schemas[\"JsonKeyPackage\"];\n\nexport type HistoricalTx = schemas[\"HistoricalTx\"];\nexport type ListHistoricalTxResponse = schemas[\"PaginatedListHistoricalTxResponse\"];\n\nexport type LoginRequest = schemas[\"LoginRequest\"];\nexport type PasskeyAssertChallenge = schemas[\"PasskeyAssertChallenge\"];\nexport type PasskeyAssertAnswer = schemas[\"PasskeyAssertAnswer\"];\nexport type AuthenticationRequest = schemas[\"AuthenticationRequest\"];\nexport type AuthenticationResponse = schemas[\"AuthenticationResponse\"];\nexport type PasswordResetRequest = schemas[\"PasswordResetRequest\"];\nexport type PasswordResetConfirmRequest = schemas[\"PasswordResetConfirmRequest\"];\nexport type EmailOtpResponse = schemas[\"EmailOtpResponse\"];\nexport type EmailTemplatePurpose = schemas[\"Purpose\"];\nexport type GetEmailConfigResponse = schemas[\"GetEmailConfigResponse\"];\n\nexport type Empty = schemas[\"EmptyImpl\"];\n\nexport type ExplicitScope = schemas[\"ExplicitScope\"];\nexport type Scope = schemas[\"Scope\"];\n\n/** Options for a new OIDC user */\nexport interface CreateOidcUserOptions {\n  /** Optional name */\n  name?: string | null;\n  /** The role of an OIDC user, default is \"Alien\" */\n  memberRole?: MemberRole;\n  /** Optional MFA policy to associate with the user account */\n  mfaPolicy?: MfaPolicy;\n}\n\nexport type GetRoleKeyOptions = operations[\"getRoleKey\"][\"parameters\"][\"query\"];\n\n/** Ava P- or X-chain transaction */\nexport type AvaTx = { P: AvaPChainTx } | { X: AvaXChainTx };\n\n/** Ava P-chain transaction */\nexport type AvaPChainTx =\n  | { AddPermissionlessValidator: JsonMap }\n  | { AddSubnetValidator: JsonMap }\n  | { AddValidator: JsonMap }\n  | { CreateChain: JsonMap }\n  | { CreateSubnet: JsonMap }\n  | { Export: JsonMap }\n  | { Import: JsonMap };\n\n/** Ava X-chain transaction */\nexport type AvaXChainTx = { Base: JsonMap } | { Export: JsonMap } | { Import: JsonMap };\n\n/** Ava chains */\nexport type AvaChain = \"C\" | \"X\" | \"P\";\n\n/** Key import */\nexport type CreateKeyImportKeyResponse = schemas[\"CreateKeyImportKeyResponse\"];\nexport type ImportKeyRequest = schemas[\"ImportKeyRequest\"];\nexport type ImportKeyRequestMaterial = schemas[\"ImportKeyRequestMaterial\"];\n\nexport type InvitationAcceptRequest = schemas[\"InvitationAcceptRequest\"];\n\nexport type KeyTypeAndDerivationPath = schemas[\"KeyTypeAndDerivationPath\"];\nexport type PolicyInfo = schemas[\"PolicyInfo\"] & {\n  acl?: JsonValue[];\n};\n\n/**\n * Coerce the less accurate `PolicyInfo` type from the OpenAPI schema to a more accurate {@link PolicyInfo}.\n *\n * @param p The policy info received on the wire\n * @returns The same value coerced to {@link PolicyInfo}\n */\nexport function coercePolicyInfo(p: schemas[\"PolicyInfo\"]): PolicyInfo {\n  return p as PolicyInfo;\n}\n\nexport type UpdatePolicyRequest = schemas[\"UpdatePolicyRequest\"] & {\n  rules?: JsonValue[];\n  acl?: JsonValue[];\n};\nexport type ListPoliciesResponse = schemas[\"PaginatedListPoliciesResponse\"];\nexport type PolicyType = schemas[\"PolicyType\"];\nexport type PolicyAttachedToId = schemas[\"PolicyAttachedToId\"];\n\nexport type ListBucketsResponse = schemas[\"PaginatedListBucketsResponse\"];\nexport type UpdateBucketRequest = schemas[\"UpdateBucketRequest\"];\nexport type BucketAction = schemas[\"BucketAction\"];\n\nexport type UploadWasmPolicyRequest = schemas[\"UploadWasmPolicyRequest\"];\nexport type UploadWasmPolicyResponse = schemas[\"UploadWasmPolicyResponse\"];\nexport type InvokePolicyRequest = schemas[\"InvokePolicyRequest\"];\n\nexport type WasmRule = schemas[\"WasmRule\"];\nexport type InvokeC2FResponse = InvokePolicyResponse;\nexport type InvokePolicyResponse = schemas[\"InvokePolicyResponse\"];\nexport type C2FResponse = WasmPolicyResponse;\nexport type WasmPolicyResponse = schemas[\"WasmPolicyResponse\"];\nexport type C2FConfiguration = PolicyEngineConfiguration;\nexport type PolicyEngineConfiguration = schemas[\"PolicyEngineConfiguration\"];\n\nexport type PolicyAction = schemas[\"PolicyAction\"];\nexport type SecretAction = schemas[\"SecretAction\"];\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema_types.js","sourceRoot":"","sources":["../../src/schema_types.ts"],"names":[],"mappings":";;;AA+SA,4CAEC;AA1QD,QAAQ;AACR,8EAA8E;AAC9E,oFAAoF;AACpF,MAAM,iBAAiB,GAAgC;IACrD,OAAO,EAAE,IAAI;IACb,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,IAAI;IACpB,mBAAmB,EAAE,IAAI;IACzB,cAAc,EAAE,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,cAAc,EAAE,IAAI;IACpB,OAAO,EAAE,IAAI;IACb,aAAa,EAAE,IAAI;IACnB,QAAQ,EAAE,IAAI;IACd,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,IAAI;IACb,cAAc,EAAE,IAAI;IACpB,UAAU,EAAE,IAAI;CACjB,CAAC;AACW,QAAA,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAA6B,CAAC;AAsO9F;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,CAAwB;IACvD,OAAO,CAAe,CAAC;AACzB,CAAC","sourcesContent":["import type { components, operations, paths } from \"./schema\";\nimport type { JsonMap, JsonValue } from \"./util\";\n\nexport type schemas = components[\"schemas\"];\n\nexport type UserInfo = schemas[\"UserInfo\"];\nexport type UserInOrgMembership = schemas[\"UserInOrgMembership\"];\nexport type ConfiguredMfa = schemas[\"ConfiguredMfa\"];\nexport type RatchetConfig = schemas[\"RatchetConfig\"];\nexport type IdentityProof = schemas[\"IdentityProof\"];\nexport type AddIdentityRequest = schemas[\"AddIdentityRequest\"];\nexport type ListIdentityResponse = schemas[\"ListIdentitiesResponse\"];\nexport type TotpInfo = schemas[\"TotpInfo\"];\n\nexport type OidcAuthResponse = schemas[\"NewSessionResponse\"];\nexport type ApiAddFidoChallenge = schemas[\"FidoCreateChallengeResponse\"];\nexport type ApiMfaFidoChallenge = schemas[\"FidoAssertChallenge\"];\n\nexport type PublicKeyCredentialCreationOptions = schemas[\"PublicKeyCredentialCreationOptions\"];\nexport type PublicKeyCredentialRequestOptions = schemas[\"PublicKeyCredentialRequestOptions\"];\nexport type PublicKeyCredentialParameters = schemas[\"PublicKeyCredentialParameters\"];\nexport type PublicKeyCredentialDescriptor = schemas[\"PublicKeyCredentialDescriptor\"];\nexport type AuthenticatorSelectionCriteria = schemas[\"AuthenticatorSelectionCriteria\"];\nexport type PublicKeyCredentialUserEntity = schemas[\"PublicKeyCredentialUserEntity\"];\nexport type PublicKeyCredential = schemas[\"PublicKeyCredential\"];\n\nexport type OrgInfo = schemas[\"OrgInfo\"];\nexport type OrgExtData = NonNullable<OrgInfo[\"ext_data\"]>;\nexport type PublicOrgInfo = schemas[\"PublicOrgInfo\"];\nexport type UserInOrgInfo = schemas[\"UserInOrgInfo\"];\nexport type UpdateOrgRequest = schemas[\"UpdateOrgRequest\"];\nexport type OrgExtProps = NonNullable<UpdateOrgRequest[\"ext_props\"]>;\nexport type UpdateOrgResponse = schemas[\"UpdateOrgResponse\"];\nexport type UpdateUserMembershipRequest = schemas[\"UpdateUserMembershipRequest\"];\nexport type NotificationEndpointConfiguration = schemas[\"NotificationEndpointConfiguration\"];\nexport type OrgEvents = schemas[\"OrgEventDiscriminants\"];\nexport type BillingEvent = schemas[\"BillingEvent\"];\nexport type OperationKind = schemas[\"OperationKind\"];\n\n// NOTE:\n//   we use `Record<OperationKind, ...>` (instead of `OperationKind[]`) to get\n//   the type checker to complain unless this record includes every single operation\nconst AllOperationKinds: Record<OperationKind, true> = {\n  AvaSign: true,\n  AvaChainTxSign: true,\n  BabylonCovSign: true,\n  BabylonRegistration: true,\n  BabylonStaking: true,\n  BlobSign: true,\n  BtcMessageSign: true,\n  BtcSign: true,\n  DiffieHellman: true,\n  PsbtSign: true,\n  TaprootSign: true,\n  Eip191Sign: true,\n  Eip712Sign: true,\n  EotsNonces: true,\n  EotsSign: true,\n  Eth1Sign: true,\n  Eth2Sign: true,\n  Eth2Stake: true,\n  Eth2Unstake: true,\n  SolanaSign: true,\n  SuiSign: true,\n  TendermintSign: true,\n  RoleUpdate: true,\n};\nexport const ALL_OPERATION_KINDS = Object.keys(AllOperationKinds) as readonly OperationKind[];\n\nexport type OrgData = schemas[\"OrgData\"];\nexport type UserOrgsResponse = schemas[\"UserOrgsResponse\"];\n\nexport type OidcIdentity = schemas[\"OidcIdentity\"];\nexport type MemberRole = schemas[\"MemberRole\"];\n\nexport type SchemaKeyType = schemas[\"KeyType\"];\n\nexport type ListKeysResponse = schemas[\"PaginatedListKeysResponse\"];\nexport type UpdateKeyRequest = schemas[\"UpdateKeyRequest\"];\nexport type KeyProperties = schemas[\"CreateAndUpdateKeyProperties\"];\nexport type CreateKeyRequest = schemas[\"CreateKeyRequest\"];\nexport type KeyInfo = schemas[\"KeyInfo\"];\nexport type KeyInfoJwt = schemas[\"KeyInfoJwt\"];\nexport type KeyAttestationClaims = schemas[\"KeyAttestationClaims\"];\nexport type KeyAttestationQuery =\n  paths[\"/v0/org/{org_id}/keys/{key_id}/attest\"][\"get\"][\"parameters\"][\"query\"];\nexport type RoleInfoJwt = schemas[\"RoleInfoJwt\"];\nexport type RoleAttestationClaims = schemas[\"RoleAttestationClaims\"];\nexport type RoleAttestationQuery =\n  paths[\"/v0/org/{org_id}/roles/{role_id}/attest\"][\"get\"][\"parameters\"][\"query\"];\nexport type RoleAttestationVerbosity = schemas[\"RoleAttestationVerbosity\"];\nexport type KeyInRoleInfo = schemas[\"KeyInRoleInfo\"];\nexport type GetUsersInOrgResponse = schemas[\"PaginatedGetUsersInOrgResponse\"];\nexport type GetUserByEmailResponse = schemas[\"GetUserByEmailResponse\"];\nexport type GetUserByOidcResponse = schemas[\"GetUserByOidcResponse\"];\n\nexport type UserInRoleInfo = schemas[\"UserInRoleInfo\"];\nexport type KeyTypeApi = schemas[\"KeyType\"];\n\nexport type ListKeyRolesResponse = schemas[\"PaginatedListKeyRolesResponse\"];\nexport type ListRolesResponse = schemas[\"PaginatedListRolesResponse\"];\nexport type ListRoleKeysResponse = schemas[\"PaginatedListRoleKeysResponse\"];\nexport type ListRoleUsersResponse = schemas[\"PaginatedListRoleUsersResponse\"];\nexport type UpdateRoleRequest = schemas[\"UpdateRoleRequest\"];\nexport type KeyWithPoliciesInfo = schemas[\"KeyInRoleInfo\"];\nexport type RoleInfo = schemas[\"RoleInfo\"];\nexport type RoleAction = schemas[\"RoleAction\"];\nexport type RestrictedActionsMap = Partial<Record<RoleAction, MemberRole[]>>;\n\nexport type SessionInfo = schemas[\"SessionInfo\"];\nexport type ClientSessionInfo = schemas[\"ClientSessionInfo\"];\nexport type NewSessionResponse = schemas[\"NewSessionResponse\"];\nexport type SessionsResponse = schemas[\"PaginatedSessionsResponse\"];\n\nexport type EditPolicy = schemas[\"EditPolicy\"];\n\nexport type ContactInfo = schemas[\"ContactInfoResponse\"];\nexport type AddressMap = schemas[\"AddressMap\"];\nexport type BtcChain = schemas[\"BtcChain\"];\nexport type SuiChain = schemas[\"SuiChain\"];\nexport type CreateContactRequest = schemas[\"CreateContactRequest\"];\nexport type UpdateContactRequest = schemas[\"UpdateContactRequest\"];\nexport type ListContactsResponse = schemas[\"PaginatedListContactsResponse\"];\nexport type ContactLabel = schemas[\"ContactLabel\"];\nexport type ContactAddressData = schemas[\"ContactAddressData\"];\n\nexport type CreateSignerSessionRequest = schemas[\"CreateTokenRequest\"];\nexport type RefreshSignerSessionRequest = schemas[\"AuthData\"];\n\nexport type EvmSignRequest = schemas[\"Eth1SignRequest\"];\nexport type EvmSignResponse = schemas[\"Eth1SignResponse\"];\nexport type Eip191SignRequest = schemas[\"Eip191SignRequest\"];\nexport type Eip712SignRequest = schemas[\"Eip712SignRequest\"];\nexport type Eip191Or712SignResponse = schemas[\"SignResponse\"];\nexport type Eth2SignRequest = schemas[\"Eth2SignRequest\"];\nexport type Eth2SignResponse = schemas[\"SignResponse\"];\nexport type Eth2StakeRequest = schemas[\"StakeRequest\"];\nexport type Eth2StakeResponse = schemas[\"StakeResponse\"];\nexport type Eth2UnstakeRequest = schemas[\"UnstakeRequest\"];\nexport type Eth2UnstakeResponse = schemas[\"UnstakeResponse\"];\nexport type BlobSignRequest = schemas[\"BlobSignRequest\"];\nexport type BlobSignResponse = schemas[\"SignResponse\"];\nexport type BtcSignRequest = schemas[\"BtcSignRequest\"];\nexport type BtcSignResponse = schemas[\"SignResponse\"];\nexport type BtcMessageSignRequest = schemas[\"BtcMessageSignRequest\"];\nexport type BtcMessageSignResponse = schemas[\"BtcMessageSignResponse\"];\nexport type PsbtSignRequest = schemas[\"PsbtSignRequest\"];\nexport type PsbtSignResponse = schemas[\"PsbtSignResponse\"];\nexport type TaprootSignRequest = schemas[\"TaprootSignRequest\"];\nexport type TaprootSignResponse = schemas[\"SignResponse\"];\nexport type EotsSignRequest = schemas[\"EotsSignRequest\"];\nexport type EotsSignResponse = schemas[\"SignResponse\"];\nexport type EotsCreateNonceRequest = schemas[\"EotsCreateNonceRequest\"];\nexport type EotsCreateNonceResponse = schemas[\"EotsCreateNonceResponse\"];\nexport type BabylonStakingRequest = schemas[\"BabylonStakingRequest\"];\nexport type BabylonStakingResponse = schemas[\"BabylonStakingResponse\"];\nexport type BabylonStakingEarlyUnbond = schemas[\"BabylonStakingEarlyUnbond\"];\nexport type BabylonStakingWithdrawal = schemas[\"BabylonStakingWithdrawal\"];\nexport type BabylonRegistrationRequest = schemas[\"BabylonRegistrationRequest\"];\nexport type BabylonRegistrationResponse = schemas[\"BabylonRegistrationResponse\"];\nexport type SolanaSignRequest = schemas[\"SolanaSignRequest\"];\nexport type SolanaSignResponse = schemas[\"SignResponse\"];\nexport type AvaSignRequest = schemas[\"AvaSignRequest\"];\nexport type AvaSignResponse = schemas[\"SignResponse\"];\nexport type AvaSerializedTxSignRequest = schemas[\"AvaSerializedTxSignRequest\"];\nexport type SuiSignRequest = schemas[\"SuiSignRequest\"];\nexport type SuiSignResponse = schemas[\"SignResponse\"];\n\nexport type PendingMessageSignResponse = schemas[\"PendingMessageSignResponse\"];\nexport type PendingMessageInfo = schemas[\"PendingMessageInfo\"];\nexport type EvmTransaction = schemas[\"Transaction\"];\nexport type TypedTransaction = schemas[\"TypedTransaction\"];\nexport type TransactionAndStatus = schemas[\"TransactionAndStatus\"];\nexport type SignedMessage = schemas[\"SignedMessage\"];\nexport type MmiMetadata = schemas[\"MmiMetadata\"];\nexport type MmiStatus = schemas[\"MmiStatus\"];\nexport type Eip191Message = NonNullable<PendingMessageInfo[\"message_eip191\"]>;\nexport type Eip712Message = NonNullable<PendingMessageInfo[\"message_eip712\"]>;\n\nexport type JrpcResponse = schemas[\"JrpcResponse\"];\nexport type MmiJrpcMethod =\n  | \"custodian_listAccounts\"\n  | \"custodian_listAccountsSigned\"\n  | \"custodian_listAccountChainIds\"\n  | \"custodian_createTransaction\"\n  | \"custodian_sign\"\n  | \"custodian_signTypedData\"\n  | \"custodian_getSignedMessageById\"\n  | \"custodian_getTransactionById\"\n  | \"custodian_getCustomerProof\"\n  | \"custodian_replaceTransaction\"\n  | \"custodian_getTransactionLink\"\n  | \"custodian_getSignedMessageLink\";\n\nexport type AcceptedResponse = schemas[\"AcceptedResponse\"];\nexport type ErrorResponse = schemas[\"ErrorResponse\"];\nexport type BtcSignatureKind = schemas[\"BtcSignatureKind\"];\nexport type CsErrCode = schemas[\"SignerErrorCode\"];\n\nexport type MfaType =\n  | \"CubeSigner\"\n  | \"Fido\"\n  | `FidoKey#${string}`\n  | \"Totp\"\n  | \"EmailOtp\"\n  | `EmailOtp#${number}`;\nexport type MfaPolicy = Omit<schemas[\"MfaPolicy\"], \"allowed_mfa_types\"> & {\n  /** Allowed approval types. When omitted, defaults to any. */\n  allowed_mfa_types?: MfaType[] | null; // overriding to use a stronger `MfaType` type\n};\nexport type MfaVote = schemas[\"MfaVote\"];\nexport type MfaRequestInfo = schemas[\"MfaRequestInfo\"];\nexport type MfaProtectedAction = schemas[\"MfaProtectedAction\"];\nexport type MfaRequired = schemas[\"AcceptedValue\"][\"MfaRequired\"];\nexport type EvmTxCmp = schemas[\"EvmTxCmp\"];\nexport type SolanaTxCmp = schemas[\"SolanaTxCmp\"];\n\nexport type CreateOrgRequest = schemas[\"CreateOrgRequest\"];\nexport type OrgMetricName = schemas[\"MetricName\"];\nexport type QueryMetricsRequest = schemas[\"QueryMetricsRequest\"];\nexport type QueryMetricsResponse = schemas[\"QueryMetricsResponse\"];\nexport type AuditLogRequest = schemas[\"AuditLogRequest\"];\nexport type AuditLogResponse = schemas[\"PaginatedAuditLogResponse\"];\nexport type { AuditLogEntry } from \"./audit_log\";\n\nexport type DiffieHellmanRequest = schemas[\"DiffieHellmanRequest\"];\nexport type DiffieHellmanResponse = schemas[\"DiffieHellmanResponse\"];\n\nexport type UserExportInitRequest = schemas[\"UserExportInitRequest\"];\nexport type UserExportInitResponse = schemas[\"UserExportInitResponse\"];\nexport type UserExportCompleteRequest = schemas[\"UserExportCompleteRequest\"];\nexport type UserExportCompleteResponse = schemas[\"UserExportCompleteResponse\"];\nexport type UserExportListResponse = schemas[\"PaginatedUserExportListResponse\"];\nexport type UserExportKeyMaterial = schemas[\"JsonKeyPackage\"];\n\nexport type HistoricalTx = schemas[\"HistoricalTx\"];\nexport type ListHistoricalTxResponse = schemas[\"PaginatedListHistoricalTxResponse\"];\n\nexport type LoginRequest = schemas[\"LoginRequest\"];\nexport type PasskeyAssertChallenge = schemas[\"PasskeyAssertChallenge\"];\nexport type PasskeyAssertAnswer = schemas[\"PasskeyAssertAnswer\"];\nexport type AuthenticationRequest = schemas[\"AuthenticationRequest\"];\nexport type AuthenticationResponse = schemas[\"AuthenticationResponse\"];\nexport type PasswordResetRequest = schemas[\"PasswordResetRequest\"];\nexport type PasswordResetConfirmRequest = schemas[\"PasswordResetConfirmRequest\"];\nexport type EmailOtpResponse = schemas[\"EmailOtpResponse\"];\nexport type EmailTemplatePurpose = schemas[\"Purpose\"];\nexport type GetEmailConfigResponse = schemas[\"GetEmailConfigResponse\"];\n\nexport type Empty = schemas[\"EmptyImpl\"];\n\nexport type ExplicitScope = schemas[\"ExplicitScope\"];\nexport type Scope = schemas[\"Scope\"];\n\n/** Options for a new OIDC user */\nexport interface CreateOidcUserOptions {\n  /** Optional name */\n  name?: string | null;\n  /** The role of an OIDC user, default is \"Alien\" */\n  memberRole?: MemberRole;\n  /** Optional MFA policy to associate with the user account */\n  mfaPolicy?: MfaPolicy;\n}\n\nexport type GetRoleKeyOptions = operations[\"getRoleKey\"][\"parameters\"][\"query\"];\n\n/** Ava P- or X-chain transaction */\nexport type AvaTx = { P: AvaPChainTx } | { X: AvaXChainTx };\n\n/** Ava P-chain transaction */\nexport type AvaPChainTx =\n  | { AddPermissionlessValidator: JsonMap }\n  | { AddSubnetValidator: JsonMap }\n  | { AddValidator: JsonMap }\n  | { CreateChain: JsonMap }\n  | { CreateSubnet: JsonMap }\n  | { Export: JsonMap }\n  | { Import: JsonMap };\n\n/** Ava X-chain transaction */\nexport type AvaXChainTx = { Base: JsonMap } | { Export: JsonMap } | { Import: JsonMap };\n\n/** Ava chains */\nexport type AvaChain = \"C\" | \"X\" | \"P\";\n\n/** Key import */\nexport type CreateKeyImportKeyResponse = schemas[\"CreateKeyImportKeyResponse\"];\nexport type ImportKeyRequest = schemas[\"ImportKeyRequest\"];\nexport type ImportKeyRequestMaterial = schemas[\"ImportKeyRequestMaterial\"];\n\nexport type InvitationAcceptRequest = schemas[\"InvitationAcceptRequest\"];\n\nexport type KeyTypeAndDerivationPath = schemas[\"KeyTypeAndDerivationPath\"];\nexport type PolicyInfo = schemas[\"PolicyInfo\"] & {\n  acl?: JsonValue[];\n};\n\n/**\n * Coerce the less accurate `PolicyInfo` type from the OpenAPI schema to a more accurate {@link PolicyInfo}.\n *\n * @param p The policy info received on the wire\n * @returns The same value coerced to {@link PolicyInfo}\n */\nexport function coercePolicyInfo(p: schemas[\"PolicyInfo\"]): PolicyInfo {\n  return p as PolicyInfo;\n}\n\nexport type UpdatePolicyRequest = schemas[\"UpdatePolicyRequest\"] & {\n  rules?: JsonValue[];\n  acl?: JsonValue[];\n};\nexport type ListPoliciesResponse = schemas[\"PaginatedListPoliciesResponse\"];\nexport type PolicyType = schemas[\"PolicyType\"];\nexport type PolicyAttachedToId = schemas[\"PolicyAttachedToId\"];\n\nexport type ListBucketsResponse = schemas[\"PaginatedListBucketsResponse\"];\nexport type UpdateBucketRequest = schemas[\"UpdateBucketRequest\"];\nexport type BucketAction = schemas[\"BucketAction\"];\n\nexport type UploadWasmPolicyRequest = schemas[\"UploadWasmPolicyRequest\"];\nexport type UploadWasmPolicyResponse = schemas[\"UploadWasmPolicyResponse\"];\nexport type InvokePolicyRequest = schemas[\"InvokePolicyRequest\"];\n\nexport type WasmRule = schemas[\"WasmRule\"];\nexport type InvokeC2FResponse = InvokePolicyResponse;\nexport type InvokePolicyResponse = schemas[\"InvokePolicyResponse\"];\nexport type C2FResponse = WasmPolicyResponse;\nexport type WasmPolicyResponse = schemas[\"WasmPolicyResponse\"];\nexport type C2FConfiguration = PolicyEngineConfiguration;\nexport type PolicyEngineConfiguration = schemas[\"PolicyEngineConfiguration\"];\n\nexport type PolicyAction = schemas[\"PolicyAction\"];\nexport type SecretAction = schemas[\"SecretAction\"];\n"]}

package/package.json

@@ -5,7 +5,7 @@
     "url": "git+https://github.com/cubist-labs/CubeSigner-TypeScript-SDK.git",
     "directory": "packages/sdk"
   },
-  "version": "0.4.237",
+  "version": "0.4.241",
   "description": "CubeSigner TypeScript SDK",
   "license": "MIT OR Apache-2.0",
   "author": "Cubist, Inc.",
@@ -26,7 +26,8 @@
     "typedoc": "typedoc"
   },
   "dependencies": {
-    "openapi-fetch": "0.8.2"
+    "openapi-fetch": "0.8.2",
+    "zod": "^4.3.6"
   },
   "optionalDependencies": {
     "@hpke/core": "^1.2.7"

package/src/audit_log.ts

@@ -0,0 +1,195 @@
+import { z } from "zod/mini";
+import type { components } from "./schema";
+
+type OrgEventDiscriminants = components["schemas"]["OrgEventDiscriminants"];
+type BillingEvent = components["schemas"]["BillingEvent"];
+type MemberRole = components["schemas"]["MemberRole"];
+type OperationKind = components["schemas"]["OperationKind"];
+type KeyType = components["schemas"]["KeyType"];
+
+const schemaString = <T extends string>() => z.custom<T>((val) => typeof val === "string");
+
+const baseFields = {
+  /** The type of org event. */
+  event: z.string(),
+  /** UUID uniquely identifying this event across all events. */
+  event_id: z.string(),
+  /** The org in which this event occurred. */
+  org_id: z.string(),
+  /** ID of the HTTP request that triggered this event (one request can trigger multiple events). */
+  request_id: z.string(),
+  /** Timestamp of when the event was logged, formatted like YYYY-MM-DD HH:MM:SS.NNNNNNNNN */
+  time: z.string(),
+  /** ID of the user or role that triggered the event; absent for unauthenticated endpoints. */
+  triggered_by: z.nullable(z.string()),
+};
+
+export const auditLogEntrySchema = z.discriminatedUnion("event", [
+  z.object({
+    ...baseFields,
+    event: z.literal("Billing"),
+    kind: schemaString<BillingEvent>(),
+    user_id: z.optional(z.string()),
+    role_id: z.optional(z.string()),
+    key_id: z.optional(z.string()),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Response"),
+    kind: schemaString<BillingEvent>(),
+    status: z.coerce.number(),
+    duration_ms: z.coerce.number(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("OidcAuth"),
+    issuer: z.string(),
+    membership: schemaString<MemberRole>(),
+    email: z.optional(z.string()),
+    username: z.optional(z.string()),
+    scopes: z.array(z.string()),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Signed"),
+    kind: schemaString<OperationKind>(),
+    key_type: schemaString<KeyType>(),
+    key_id: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("BabylonEotsConcurrentSigning"),
+    key_id: z.string(),
+    chain_id: z.string(),
+    prev_block_height: z.coerce.number(),
+    prev_signing_hash: z.string(),
+    req_block_height: z.coerce.number(),
+    req_signing_hash: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Eth2ConcurrentAttestationSigning"),
+    key_id: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Eth2ConcurrentBlockSigning"),
+    key_id: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Eth2InvalidBlockProposerSlotTooLow"),
+    slot: z.coerce.number(),
+    signing_root: z.string(),
+    last_slot: z.coerce.number(),
+    last_signing_root: z.string(),
+    enforced: z.coerce.boolean(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Eth2InvalidAttestationSourceEpochTooLow"),
+    source_epoch: z.coerce.number(),
+    signing_root: z.string(),
+    last_target_epoch: z.coerce.number(),
+    last_signing_root: z.string(),
+    enforced: z.coerce.boolean(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Eth2InvalidAttestationTargetEpochTooLow"),
+    target_epoch: z.coerce.number(),
+    signing_root: z.string(),
+    last_target_epoch: z.coerce.number(),
+    last_signing_root: z.string(),
+    enforced: z.coerce.boolean(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Eth2Unstake"),
+    key_id: z.string(),
+    validator_index: z.coerce.number(),
+    daily_unstake_count: z.coerce.number(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("Eth2ExceededMaxUnstake"),
+    max: z.coerce.number(),
+    date: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("KeyCreated"),
+    key_type: schemaString<KeyType>(),
+    owner_id: z.string(),
+    count: z.coerce.number(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("MfaApproved"),
+    mfa_id: z.string(),
+    meets_approval_criteria: z.coerce.boolean(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("MfaRejected"),
+    mfa_id: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("PolicyChanged"),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("TendermintConcurrentSigning"),
+    key_id: z.string(),
+    chain_id: z.string(),
+    last_state: z.string(),
+    current_state: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("InvitationCreated"),
+    email: z.string(),
+    role: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("InvitationCanceled"),
+    email: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("UserExportInit"),
+    key_id: z.string(),
+    valid_epoch: z.coerce.number(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("UserExportComplete"),
+    key_id: z.string(),
+  }),
+  z.object({
+    ...baseFields,
+    event: z.literal("WasmPolicyExecuted"),
+    source: z.string(),
+    key_id: z.optional(z.string()),
+    policy: z.string(),
+    policy_hash: z.string(),
+    stdout: z.string(),
+    stderr: z.string(),
+    response: z.string(),
+    reason: z.optional(z.string()),
+    error: z.optional(z.string()),
+  }),
+]);
+
+export type AuditLogEntry = z.infer<typeof auditLogEntrySchema>;
+
+// Compile-time check: errors if a variant is added to OrgEventDiscriminants but not handled here.
+type _AllVariantsCovered = [OrgEventDiscriminants] extends [AuditLogEntry["event"]]
+  ? [AuditLogEntry["event"]] extends [OrgEventDiscriminants]
+    ? true
+    : never
+  : never;
+const _allVariantsCovered: _AllVariantsCovered = true;
+void _allVariantsCovered;

package/src/client/api_client.ts

@@ -71,6 +71,7 @@ import type {
   PolicyInfo,
 } from "../schema_types";
 import { encodeToBase64 } from "../util";
+import { auditLogEntrySchema } from "../audit_log";
 import {
   AddFidoChallenge,
   MfaFidoChallenge,
@@ -159,13 +160,19 @@ import {
   type BucketInfo,
 } from "../index";
 import { assertOk, op, type Op, type Operation, apiFetch } from "../fetch";
-import { BaseClient, type ClientConfig, signerSessionFromSessionInfo } from "./base_client";
+import {
+  authHeader,
+  BaseClient,
+  type ClientConfig,
+  signerSessionFromSessionInfo,
+} from "./base_client";
 import { retryOn5XX } from "../retry";
 import { PasskeyLoginChallenge } from "../passkey";
 
 // these types are used in doc comments only
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { RoleAttestationClaims, KeyAttestationClaims } from "../schema_types";
+import { mergeHeaders } from "openapi-fetch";
 
 /**
  * String returned by API when a user does not have an email address (for backwards compatibility)
@@ -216,10 +223,7 @@ export class ApiClient extends BaseClient {
     return new ApiClient(this.sessionMeta, this.sessionManager, this.orgId, {
       ...this.config,
       ...cfg,
-      headers: {
-        ...(this.config.headers ?? {}),
-        ...(cfg.headers ?? {}),
-      },
+      headers: mergeHeaders(this.config.headers, cfg.headers),
     });
   }
 
@@ -257,12 +261,14 @@ export class ApiClient extends BaseClient {
    * @param env The environment to use
    * @param orgId The org to login to
    * @param email The email to send the signature to
+   * @param headers Optional headers to set
    * @returns The partial OIDC token that must be combined with the signature in the email
    */
   static async initEmailOtpAuth(
     env: EnvInterface,
     orgId: string,
     email: string,
+    headers?: HeadersInit,
   ): Promise<EmailOtpResponse> {
     const o = op("/v0/org/{org_id}/oidc/email-otp", "post");
 
@@ -271,6 +277,7 @@ export class ApiClient extends BaseClient {
         baseUrl: env.SignerApiRoot,
         params: { path: { org_id: orgId } },
         body: { email },
+        headers,
       }),
     ).then(assertOk);
   }
@@ -565,7 +572,11 @@ export class ApiClient extends BaseClient {
     return Paginator.items(
       page ?? Page.default(),
       (query) => this.exec(o, { body, params: { query } }),
-      (r) => r.entries,
+      (r) =>
+        r.entries.flatMap((entry) => {
+          const result = auditLogEntrySchema.safeParse(entry);
+          return result.success ? [result.data] : [];
+        }),
       (r) => r.last_evaluated_key,
     );
   }
@@ -2929,14 +2940,16 @@ export class ApiClient extends BaseClient {
    *
    * @param env The environment to use
    * @param email The user's email
+   * @param headers Optional headers to set
    * @returns Empty response
    */
-  static async emailMyOrgs(env: EnvInterface, email: string) {
+  static async emailMyOrgs(env: EnvInterface, email: string, headers?: HeadersInit) {
     const o = op("/v0/email/orgs", "get");
     return await retryOn5XX(() =>
       o({
         baseUrl: env.SignerApiRoot,
         params: { query: { email } },
+        headers,
       }),
     ).then(assertOk);
   }
@@ -2951,6 +2964,7 @@ export class ApiClient extends BaseClient {
    * @param lifetimes Lifetimes of the new session.
    * @param mfaReceipt Optional MFA receipt(s)
    * @param purpose Optional session description.
+   * @param headers Additional headers to set
    * @returns The session data.
    */
   static async oidcSessionCreate(
@@ -2961,18 +2975,16 @@ export class ApiClient extends BaseClient {
     lifetimes?: RatchetConfig,
     mfaReceipt?: MfaReceipts,
     purpose?: string,
+    headers?: HeadersInit,
   ): Promise<CubeSignerResponse<SessionData>> {
     const o = op("/v0/org/{org_id}/oidc", "post");
 
-    const loginFn = async (headers?: HeadersInit) => {
+    const loginFn = async (mfaHeaders?: HeadersInit) => {
       const data = await retryOn5XX(() =>
         o({
           baseUrl: env.SignerApiRoot,
           params: { path: { org_id: orgId } },
-          headers: {
-            ...headers,
-            Authorization: token,
-          },
+          headers: mergeHeaders(headers, mfaHeaders, authHeader(token)),
           body: {
             scopes,
             purpose,
@@ -3008,12 +3020,14 @@ export class ApiClient extends BaseClient {
    * @param env The environment to use
    * @param orgId The org to login to
    * @param body The request body
+   * @param headers Optional headers to set
    * @returns The challenge that needs to be answered via {@link siweLoginComplete}
    */
   static async siweLoginInit(
     env: EnvInterface,
     orgId: string,
     body: schemas["SiweInitRequest"],
+    headers?: HeadersInit,
   ): Promise<schemas["SiweInitResponse"]> {
     const o = op("/v0/org/{org_id}/oidc/siwe", "post");
     return await retryOn5XX(() =>
@@ -3021,6 +3035,7 @@ export class ApiClient extends BaseClient {
         baseUrl: env.SignerApiRoot,
         params: { path: { org_id: orgId } },
         body,
+        headers,
       }),
     ).then(assertOk);
   }
@@ -3035,12 +3050,14 @@ export class ApiClient extends BaseClient {
    * @param env The environment to use
    * @param orgId The org to login to
    * @param body The request body
+   * @param headers Optional headers to set
    * @returns An OIDC token which can be used to log in via OIDC (see {@link oidcSessionCreate})
    */
   static async siweLoginComplete(
     env: EnvInterface,
     orgId: string,
     body: schemas["SiweCompleteRequest"],
+    headers?: HeadersInit,
   ): Promise<schemas["SiweCompleteResponse"]> {
     const o = op("/v0/org/{org_id}/oidc/siwe", "patch");
     return await retryOn5XX(() =>
@@ -3048,6 +3065,7 @@ export class ApiClient extends BaseClient {
         baseUrl: env.SignerApiRoot,
         params: { path: { org_id: orgId } },
         body,
+        headers,
       }),
     ).then(assertOk);
   }
@@ -3057,17 +3075,20 @@ export class ApiClient extends BaseClient {
    *
    * @param env The environment to log into
    * @param body The login request
+   * @param headers Optional headers to set
    * @returns The challenge that must be answered (see {@link passkeyLoginComplete}) to log in.
    */
   static async passkeyLoginInit(
     env: EnvInterface,
     body: LoginRequest,
+    headers?: HeadersInit,
   ): Promise<PasskeyLoginChallenge> {
     const o = op("/v0/passkey", "post");
     const resp = await retryOn5XX(() =>
       o({
         baseUrl: env.SignerApiRoot,
         body,
+        headers,
       }),
     ).then(assertOk);
     return new PasskeyLoginChallenge(env, resp, body.purpose);
@@ -3079,18 +3100,21 @@ export class ApiClient extends BaseClient {
    * @param env The environment to log into
    * @param body The request body
    * @param purpose Optional descriptive session purpose
+   * @param headers Optional headers to set
    * @returns The session data
    */
   static async passkeyLoginComplete(
     env: EnvInterface,
     body: PasskeyAssertAnswer,
     purpose?: string | null,
+    headers?: HeadersInit,
   ): Promise<SessionData> {
     const o = op("/v0/passkey", "patch");
     const resp = await retryOn5XX(() =>
       o({
         baseUrl: env.SignerApiRoot,
         body,
+        headers,
       }),
     ).then(assertOk);
     return {
@@ -3112,11 +3136,13 @@ export class ApiClient extends BaseClient {
    * @param env The environment to log into
    * @param orgId The id of the organization
    * @param body The request body
+   * @param headers Optional headers to set
    */
   static async idpAcceptInvite(
     env: EnvInterface,
     orgId: string,
     body: InvitationAcceptRequest,
+    headers?: HeadersInit,
   ): Promise<void> {
     const o = op("/v0/org/{org_id}/invitation/accept", "post");
     await retryOn5XX(() =>
@@ -3124,6 +3150,7 @@ export class ApiClient extends BaseClient {
         baseUrl: env.SignerApiRoot,
         params: { path: { org_id: orgId } },
         body,
+        headers,
       }),
     ).then(assertOk);
   }
@@ -3134,6 +3161,7 @@ export class ApiClient extends BaseClient {
    * @param env The environment to log into
    * @param orgId The id of the organization
    * @param body The request body
+   * @param headers Optional headers to set
    * @returns Returns an OIDC token which can be used
    *   to log in via OIDC (see {@link oidcSessionCreate}).
    */
@@ -3141,6 +3169,7 @@ export class ApiClient extends BaseClient {
     env: EnvInterface,
     orgId: string,
     body: AuthenticationRequest,
+    headers?: HeadersInit,
   ): Promise<AuthenticationResponse> {
     const o = op("/v0/org/{org_id}/idp/authenticate", "post");
     return retryOn5XX(() =>
@@ -3148,6 +3177,7 @@ export class ApiClient extends BaseClient {
         baseUrl: env.SignerApiRoot,
         params: { path: { org_id: orgId } },
         body,
+        headers,
       }),
     ).then(assertOk);
   }
@@ -3158,12 +3188,14 @@ export class ApiClient extends BaseClient {
    * @param env The environment to log into
    * @param orgId The id of the organization
    * @param body The request body
+   * @param headers Optional headers to set
    * @returns Returns the partial token (`${header}.${claims}.`) while the signature is sent via email.
    */
   static async idpPasswordResetRequest(
     env: EnvInterface,
     orgId: string,
     body: PasswordResetRequest,
+    headers?: HeadersInit,
   ): Promise<EmailOtpResponse> {
     const o = op("/v0/org/{org_id}/idp/password_reset", "post");
     return retryOn5XX(() =>
@@ -3171,6 +3203,7 @@ export class ApiClient extends BaseClient {
         baseUrl: env.SignerApiRoot,
         params: { path: { org_id: orgId } },
         body,
+        headers,
       }),
     ).then(assertOk);
   }
@@ -3183,6 +3216,7 @@ export class ApiClient extends BaseClient {
    * @param partialToken The partial token returned by {@link passwordResetRequest}
    * @param signature The one-time code (signature in this case) sent via email
    * @param newPassword The new password
+   * @param headers Optional headers to set
    */
   static async idpPasswordResetConfirm(
     env: EnvInterface,
@@ -3190,6 +3224,7 @@ export class ApiClient extends BaseClient {
     partialToken: string,
     signature: string,
     newPassword: string,
+    headers?: HeadersInit,
   ): Promise<void> {
     const o = op("/v0/org/{org_id}/idp/password_reset", "patch");
     await retryOn5XX(() =>
@@ -3200,6 +3235,7 @@ export class ApiClient extends BaseClient {
           token: `${partialToken}${signature}`,
           new_password: newPassword,
         },
+        headers,
       }),
     ).then(assertOk);
   }
@@ -3210,21 +3246,21 @@ export class ApiClient extends BaseClient {
    * @param env The environment to log into
    * @param orgId The org id in which to generate proof
    * @param token The oidc token
+   * @param headers Optional headers to set
    * @returns Proof of authentication
    */
   static async identityProveOidc(
     env: EnvInterface,
     orgId: string,
     token: string,
+    headers?: HeadersInit,
   ): Promise<IdentityProof> {
     const o = op("/v0/org/{org_id}/identity/prove/oidc", "post");
     return retryOn5XX(() =>
       o({
         baseUrl: env.SignerApiRoot,
         params: { path: { org_id: orgId } },
-        headers: {
-          Authorization: token,
-        },
+        headers: mergeHeaders(headers, authHeader(token)),
       }),
     ).then(assertOk);
   }
@@ -3234,16 +3270,19 @@ export class ApiClient extends BaseClient {
    *
    * @param env The environment to log into
    * @param token The oidc token identifying the user
+   * @param headers Optional headers to set
    * @returns The organization the user belongs to
    */
-  static async userOrgs(env: EnvInterface, token: string): Promise<UserOrgsResponse> {
+  static async userOrgs(
+    env: EnvInterface,
+    token: string,
+    headers?: HeadersInit,
+  ): Promise<UserOrgsResponse> {
     const o = op("/v0/user/orgs", "get");
     return retryOn5XX(() =>
       o({
         baseUrl: env.SignerApiRoot,
-        headers: {
-          Authorization: token,
-        },
+        headers: mergeHeaders(headers, authHeader(token)),
       }),
     ).then(assertOk);
   }