@hsuite/smart-engines-sdk 3.3.0 → 3.4.1

package/dist/nestjs/index.d.ts

@@ -122,6 +122,23 @@ declare const AccountBalanceSchema: z.ZodObject<{
 	}[] | undefined;
 }>;
 export type AccountBalance = z.infer<typeof AccountBalanceSchema>;
+export type HederaKeyShape = {
+	type: "ed25519";
+	key: string;
+} | {
+	type: "keyList";
+	threshold: number;
+	keys: HederaKeyShape[];
+};
+export type PolkadotSignatoryShape = {
+	type: "account";
+	address: string;
+} | {
+	type: "multisig";
+	address: string;
+	threshold: number;
+	signatories: PolkadotSignatoryShape[];
+};
 declare const TransactionSchema: z.ZodObject<{
 	id: z.ZodString;
 	chain: z.ZodEnum<[
@@ -658,6 +675,837 @@ declare const ActionResultSchema: z.ZodObject<{
 	notes?: string[] | undefined;
 }>;
 export type ActionResult = z.infer<typeof ActionResultSchema>;
+declare const PreparedTransactionResponseSchema: z.ZodObject<{
+	chain: z.ZodEnum<[
+		"hedera",
+		"xrpl",
+		"polkadot",
+		"solana",
+		"stellar",
+		"ethereum",
+		"polygon",
+		"bitcoin",
+		"cardano"
+	]>;
+	transactionType: z.ZodString;
+	transactionId: z.ZodString;
+	transactionBytes: z.ZodString;
+	expiresAt: z.ZodDate;
+	validatorSignatures: z.ZodArray<z.ZodObject<{
+		validatorId: z.ZodString;
+		publicKey: z.ZodString;
+		signature: z.ZodString;
+		signedAt: z.ZodDate;
+		algorithm: z.ZodOptional<z.ZodEnum<[
+			"ed25519",
+			"ecdsa-secp256k1",
+			"bls12-381"
+		]>>;
+	}, "strip", z.ZodTypeAny, {
+		publicKey: string;
+		validatorId: string;
+		signature: string;
+		signedAt: Date;
+		algorithm?: "ed25519" | "ecdsa-secp256k1" | "bls12-381" | undefined;
+	}, {
+		publicKey: string;
+		validatorId: string;
+		signature: string;
+		signedAt: Date;
+		algorithm?: "ed25519" | "ecdsa-secp256k1" | "bls12-381" | undefined;
+	}>, "many">;
+	payerAccountId: z.ZodOptional<z.ZodString>;
+	estimatedFee: z.ZodOptional<z.ZodString>;
+	requiredSignatures: z.ZodOptional<z.ZodNumber>;
+	readyToSubmit: z.ZodDefault<z.ZodBoolean>;
+	metadata: z.ZodOptional<z.ZodUnion<[
+		z.ZodObject<{
+			nodeAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+			maxTransactionFee: z.ZodOptional<z.ZodString>;
+			memo: z.ZodOptional<z.ZodString>;
+			scheduleInfo: z.ZodOptional<z.ZodObject<{
+				scheduleId: z.ZodString;
+				adminKey: z.ZodOptional<z.ZodString>;
+			}, "strip", z.ZodTypeAny, {
+				scheduleId: string;
+				adminKey?: string | undefined;
+			}, {
+				scheduleId: string;
+				adminKey?: string | undefined;
+			}>>;
+		}, "strip", z.ZodTypeAny, {
+			memo?: string | undefined;
+			nodeAccountIds?: string[] | undefined;
+			maxTransactionFee?: string | undefined;
+			scheduleInfo?: {
+				scheduleId: string;
+				adminKey?: string | undefined;
+			} | undefined;
+		}, {
+			memo?: string | undefined;
+			nodeAccountIds?: string[] | undefined;
+			maxTransactionFee?: string | undefined;
+			scheduleInfo?: {
+				scheduleId: string;
+				adminKey?: string | undefined;
+			} | undefined;
+		}>,
+		z.ZodObject<{
+			sequence: z.ZodOptional<z.ZodNumber>;
+			lastLedgerSequence: z.ZodOptional<z.ZodNumber>;
+			signerList: z.ZodOptional<z.ZodArray<z.ZodObject<{
+				account: z.ZodString;
+				signerWeight: z.ZodNumber;
+			}, "strip", z.ZodTypeAny, {
+				account: string;
+				signerWeight: number;
+			}, {
+				account: string;
+				signerWeight: number;
+			}>, "many">>;
+			signerQuorum: z.ZodOptional<z.ZodNumber>;
+		}, "strip", z.ZodTypeAny, {
+			signerQuorum?: number | undefined;
+			sequence?: number | undefined;
+			lastLedgerSequence?: number | undefined;
+			signerList?: {
+				account: string;
+				signerWeight: number;
+			}[] | undefined;
+		}, {
+			signerQuorum?: number | undefined;
+			sequence?: number | undefined;
+			lastLedgerSequence?: number | undefined;
+			signerList?: {
+				account: string;
+				signerWeight: number;
+			}[] | undefined;
+		}>,
+		z.ZodObject<{
+			recentBlockhash: z.ZodOptional<z.ZodString>;
+			feePayer: z.ZodOptional<z.ZodString>;
+			programIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+			squadsMultisigPda: z.ZodOptional<z.ZodString>;
+			squadsVaultPda: z.ZodOptional<z.ZodString>;
+			squadsTransactionIndex: z.ZodOptional<z.ZodNumber>;
+			squadsProposalAddress: z.ZodOptional<z.ZodString>;
+			multisigCreated: z.ZodOptional<z.ZodBoolean>;
+			securityMode: z.ZodOptional<z.ZodEnum<[
+				"partial",
+				"full"
+			]>>;
+			splMint: z.ZodOptional<z.ZodString>;
+		}, "strip", z.ZodTypeAny, {
+			securityMode?: "partial" | "full" | undefined;
+			recentBlockhash?: string | undefined;
+			feePayer?: string | undefined;
+			programIds?: string[] | undefined;
+			squadsMultisigPda?: string | undefined;
+			squadsVaultPda?: string | undefined;
+			squadsTransactionIndex?: number | undefined;
+			squadsProposalAddress?: string | undefined;
+			multisigCreated?: boolean | undefined;
+			splMint?: string | undefined;
+		}, {
+			securityMode?: "partial" | "full" | undefined;
+			recentBlockhash?: string | undefined;
+			feePayer?: string | undefined;
+			programIds?: string[] | undefined;
+			squadsMultisigPda?: string | undefined;
+			squadsVaultPda?: string | undefined;
+			squadsTransactionIndex?: number | undefined;
+			squadsProposalAddress?: string | undefined;
+			multisigCreated?: boolean | undefined;
+			splMint?: string | undefined;
+		}>,
+		z.ZodObject<{
+			era: z.ZodOptional<z.ZodString>;
+			nonce: z.ZodOptional<z.ZodNumber>;
+			tip: z.ZodOptional<z.ZodString>;
+			specVersion: z.ZodOptional<z.ZodNumber>;
+		}, "strip", z.ZodTypeAny, {
+			era?: string | undefined;
+			nonce?: number | undefined;
+			tip?: string | undefined;
+			specVersion?: number | undefined;
+		}, {
+			era?: string | undefined;
+			nonce?: number | undefined;
+			tip?: string | undefined;
+			specVersion?: number | undefined;
+		}>,
+		z.ZodRecord<z.ZodString, z.ZodAny>
+	]>>;
+	sovereignty: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [
+		z.ZodObject<{
+			mode: z.ZodLiteral<"partial">;
+			entityId: z.ZodString;
+			validatorPublicKeys: z.ZodArray<z.ZodString, "many">;
+			authorizationSet: z.ZodOptional<z.ZodDiscriminatedUnion<"chain", [
+				z.ZodObject<{
+					chain: z.ZodLiteral<"hedera">;
+					adminKey: z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>;
+					supplyKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					freezeKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					wipeKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					pauseKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					kycKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+				}, "strip", z.ZodTypeAny, {
+					chain: "hedera";
+					adminKey: HederaKeyShape;
+					supplyKey?: HederaKeyShape | undefined;
+					freezeKey?: HederaKeyShape | undefined;
+					wipeKey?: HederaKeyShape | undefined;
+					pauseKey?: HederaKeyShape | undefined;
+					kycKey?: HederaKeyShape | undefined;
+				}, {
+					chain: "hedera";
+					adminKey: HederaKeyShape;
+					supplyKey?: HederaKeyShape | undefined;
+					freezeKey?: HederaKeyShape | undefined;
+					wipeKey?: HederaKeyShape | undefined;
+					pauseKey?: HederaKeyShape | undefined;
+					kycKey?: HederaKeyShape | undefined;
+				}>,
+				z.ZodObject<{
+					chain: z.ZodLiteral<"xrpl">;
+					signerEntries: z.ZodArray<z.ZodObject<{
+						account: z.ZodString;
+						weight: z.ZodNumber;
+					}, "strip", z.ZodTypeAny, {
+						account: string;
+						weight: number;
+					}, {
+						account: string;
+						weight: number;
+					}>, "many">;
+					signerQuorum: z.ZodNumber;
+					masterDisabled: z.ZodBoolean;
+				}, "strip", z.ZodTypeAny, {
+					chain: "xrpl";
+					signerEntries: {
+						account: string;
+						weight: number;
+					}[];
+					signerQuorum: number;
+					masterDisabled: boolean;
+				}, {
+					chain: "xrpl";
+					signerEntries: {
+						account: string;
+						weight: number;
+					}[];
+					signerQuorum: number;
+					masterDisabled: boolean;
+				}>,
+				z.ZodObject<{
+					chain: z.ZodLiteral<"stellar">;
+					signers: z.ZodArray<z.ZodObject<{
+						key: z.ZodString;
+						weight: z.ZodNumber;
+					}, "strip", z.ZodTypeAny, {
+						key: string;
+						weight: number;
+					}, {
+						key: string;
+						weight: number;
+					}>, "many">;
+					thresholds: z.ZodObject<{
+						low: z.ZodNumber;
+						med: z.ZodNumber;
+						high: z.ZodNumber;
+					}, "strip", z.ZodTypeAny, {
+						low: number;
+						med: number;
+						high: number;
+					}, {
+						low: number;
+						med: number;
+						high: number;
+					}>;
+					masterWeight: z.ZodNumber;
+				}, "strip", z.ZodTypeAny, {
+					chain: "stellar";
+					signers: {
+						key: string;
+						weight: number;
+					}[];
+					thresholds: {
+						low: number;
+						med: number;
+						high: number;
+					};
+					masterWeight: number;
+				}, {
+					chain: "stellar";
+					signers: {
+						key: string;
+						weight: number;
+					}[];
+					thresholds: {
+						low: number;
+						med: number;
+						high: number;
+					};
+					masterWeight: number;
+				}>,
+				z.ZodObject<{
+					chain: z.ZodLiteral<"polkadot">;
+					address: z.ZodString;
+					signatory: z.ZodType<PolkadotSignatoryShape, z.ZodTypeDef, PolkadotSignatoryShape>;
+					ss58Format: z.ZodNumber;
+				}, "strip", z.ZodTypeAny, {
+					chain: "polkadot";
+					address: string;
+					signatory: PolkadotSignatoryShape;
+					ss58Format: number;
+				}, {
+					chain: "polkadot";
+					address: string;
+					signatory: PolkadotSignatoryShape;
+					ss58Format: number;
+				}>
+			]>>;
+		}, "strip", z.ZodTypeAny, {
+			entityId: string;
+			mode: "partial";
+			validatorPublicKeys: string[];
+			authorizationSet?: {
+				chain: "hedera";
+				adminKey: HederaKeyShape;
+				supplyKey?: HederaKeyShape | undefined;
+				freezeKey?: HederaKeyShape | undefined;
+				wipeKey?: HederaKeyShape | undefined;
+				pauseKey?: HederaKeyShape | undefined;
+				kycKey?: HederaKeyShape | undefined;
+			} | {
+				chain: "xrpl";
+				signerEntries: {
+					account: string;
+					weight: number;
+				}[];
+				signerQuorum: number;
+				masterDisabled: boolean;
+			} | {
+				chain: "stellar";
+				signers: {
+					key: string;
+					weight: number;
+				}[];
+				thresholds: {
+					low: number;
+					med: number;
+					high: number;
+				};
+				masterWeight: number;
+			} | {
+				chain: "polkadot";
+				address: string;
+				signatory: PolkadotSignatoryShape;
+				ss58Format: number;
+			} | undefined;
+		}, {
+			entityId: string;
+			mode: "partial";
+			validatorPublicKeys: string[];
+			authorizationSet?: {
+				chain: "hedera";
+				adminKey: HederaKeyShape;
+				supplyKey?: HederaKeyShape | undefined;
+				freezeKey?: HederaKeyShape | undefined;
+				wipeKey?: HederaKeyShape | undefined;
+				pauseKey?: HederaKeyShape | undefined;
+				kycKey?: HederaKeyShape | undefined;
+			} | {
+				chain: "xrpl";
+				signerEntries: {
+					account: string;
+					weight: number;
+				}[];
+				signerQuorum: number;
+				masterDisabled: boolean;
+			} | {
+				chain: "stellar";
+				signers: {
+					key: string;
+					weight: number;
+				}[];
+				thresholds: {
+					low: number;
+					med: number;
+					high: number;
+				};
+				masterWeight: number;
+			} | {
+				chain: "polkadot";
+				address: string;
+				signatory: PolkadotSignatoryShape;
+				ss58Format: number;
+			} | undefined;
+		}>,
+		z.ZodObject<{
+			mode: z.ZodLiteral<"full">;
+			entityId: z.ZodString;
+			validatorPublicKeys: z.ZodArray<z.ZodString, "many">;
+			authorizationSet: z.ZodOptional<z.ZodDiscriminatedUnion<"chain", [
+				z.ZodObject<{
+					chain: z.ZodLiteral<"hedera">;
+					adminKey: z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>;
+					supplyKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					freezeKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					wipeKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					pauseKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+					kycKey: z.ZodOptional<z.ZodType<HederaKeyShape, z.ZodTypeDef, HederaKeyShape>>;
+				}, "strip", z.ZodTypeAny, {
+					chain: "hedera";
+					adminKey: HederaKeyShape;
+					supplyKey?: HederaKeyShape | undefined;
+					freezeKey?: HederaKeyShape | undefined;
+					wipeKey?: HederaKeyShape | undefined;
+					pauseKey?: HederaKeyShape | undefined;
+					kycKey?: HederaKeyShape | undefined;
+				}, {
+					chain: "hedera";
+					adminKey: HederaKeyShape;
+					supplyKey?: HederaKeyShape | undefined;
+					freezeKey?: HederaKeyShape | undefined;
+					wipeKey?: HederaKeyShape | undefined;
+					pauseKey?: HederaKeyShape | undefined;
+					kycKey?: HederaKeyShape | undefined;
+				}>,
+				z.ZodObject<{
+					chain: z.ZodLiteral<"xrpl">;
+					signerEntries: z.ZodArray<z.ZodObject<{
+						account: z.ZodString;
+						weight: z.ZodNumber;
+					}, "strip", z.ZodTypeAny, {
+						account: string;
+						weight: number;
+					}, {
+						account: string;
+						weight: number;
+					}>, "many">;
+					signerQuorum: z.ZodNumber;
+					masterDisabled: z.ZodBoolean;
+				}, "strip", z.ZodTypeAny, {
+					chain: "xrpl";
+					signerEntries: {
+						account: string;
+						weight: number;
+					}[];
+					signerQuorum: number;
+					masterDisabled: boolean;
+				}, {
+					chain: "xrpl";
+					signerEntries: {
+						account: string;
+						weight: number;
+					}[];
+					signerQuorum: number;
+					masterDisabled: boolean;
+				}>,
+				z.ZodObject<{
+					chain: z.ZodLiteral<"stellar">;
+					signers: z.ZodArray<z.ZodObject<{
+						key: z.ZodString;
+						weight: z.ZodNumber;
+					}, "strip", z.ZodTypeAny, {
+						key: string;
+						weight: number;
+					}, {
+						key: string;
+						weight: number;
+					}>, "many">;
+					thresholds: z.ZodObject<{
+						low: z.ZodNumber;
+						med: z.ZodNumber;
+						high: z.ZodNumber;
+					}, "strip", z.ZodTypeAny, {
+						low: number;
+						med: number;
+						high: number;
+					}, {
+						low: number;
+						med: number;
+						high: number;
+					}>;
+					masterWeight: z.ZodNumber;
+				}, "strip", z.ZodTypeAny, {
+					chain: "stellar";
+					signers: {
+						key: string;
+						weight: number;
+					}[];
+					thresholds: {
+						low: number;
+						med: number;
+						high: number;
+					};
+					masterWeight: number;
+				}, {
+					chain: "stellar";
+					signers: {
+						key: string;
+						weight: number;
+					}[];
+					thresholds: {
+						low: number;
+						med: number;
+						high: number;
+					};
+					masterWeight: number;
+				}>,
+				z.ZodObject<{
+					chain: z.ZodLiteral<"polkadot">;
+					address: z.ZodString;
+					signatory: z.ZodType<PolkadotSignatoryShape, z.ZodTypeDef, PolkadotSignatoryShape>;
+					ss58Format: z.ZodNumber;
+				}, "strip", z.ZodTypeAny, {
+					chain: "polkadot";
+					address: string;
+					signatory: PolkadotSignatoryShape;
+					ss58Format: number;
+				}, {
+					chain: "polkadot";
+					address: string;
+					signatory: PolkadotSignatoryShape;
+					ss58Format: number;
+				}>
+			]>>;
+		}, "strip", z.ZodTypeAny, {
+			entityId: string;
+			mode: "full";
+			validatorPublicKeys: string[];
+			authorizationSet?: {
+				chain: "hedera";
+				adminKey: HederaKeyShape;
+				supplyKey?: HederaKeyShape | undefined;
+				freezeKey?: HederaKeyShape | undefined;
+				wipeKey?: HederaKeyShape | undefined;
+				pauseKey?: HederaKeyShape | undefined;
+				kycKey?: HederaKeyShape | undefined;
+			} | {
+				chain: "xrpl";
+				signerEntries: {
+					account: string;
+					weight: number;
+				}[];
+				signerQuorum: number;
+				masterDisabled: boolean;
+			} | {
+				chain: "stellar";
+				signers: {
+					key: string;
+					weight: number;
+				}[];
+				thresholds: {
+					low: number;
+					med: number;
+					high: number;
+				};
+				masterWeight: number;
+			} | {
+				chain: "polkadot";
+				address: string;
+				signatory: PolkadotSignatoryShape;
+				ss58Format: number;
+			} | undefined;
+		}, {
+			entityId: string;
+			mode: "full";
+			validatorPublicKeys: string[];
+			authorizationSet?: {
+				chain: "hedera";
+				adminKey: HederaKeyShape;
+				supplyKey?: HederaKeyShape | undefined;
+				freezeKey?: HederaKeyShape | undefined;
+				wipeKey?: HederaKeyShape | undefined;
+				pauseKey?: HederaKeyShape | undefined;
+				kycKey?: HederaKeyShape | undefined;
+			} | {
+				chain: "xrpl";
+				signerEntries: {
+					account: string;
+					weight: number;
+				}[];
+				signerQuorum: number;
+				masterDisabled: boolean;
+			} | {
+				chain: "stellar";
+				signers: {
+					key: string;
+					weight: number;
+				}[];
+				thresholds: {
+					low: number;
+					med: number;
+					high: number;
+				};
+				masterWeight: number;
+			} | {
+				chain: "polkadot";
+				address: string;
+				signatory: PolkadotSignatoryShape;
+				ss58Format: number;
+			} | undefined;
+		}>
+	]>>;
+}, "strip", z.ZodTypeAny, {
+	chain: "hedera" | "xrpl" | "polkadot" | "solana" | "stellar" | "ethereum" | "polygon" | "bitcoin" | "cardano";
+	transactionId: string;
+	transactionType: string;
+	transactionBytes: string;
+	expiresAt: Date;
+	validatorSignatures: {
+		publicKey: string;
+		validatorId: string;
+		signature: string;
+		signedAt: Date;
+		algorithm?: "ed25519" | "ecdsa-secp256k1" | "bls12-381" | undefined;
+	}[];
+	readyToSubmit: boolean;
+	metadata?: Record<string, any> | {
+		memo?: string | undefined;
+		nodeAccountIds?: string[] | undefined;
+		maxTransactionFee?: string | undefined;
+		scheduleInfo?: {
+			scheduleId: string;
+			adminKey?: string | undefined;
+		} | undefined;
+	} | {
+		signerQuorum?: number | undefined;
+		sequence?: number | undefined;
+		lastLedgerSequence?: number | undefined;
+		signerList?: {
+			account: string;
+			signerWeight: number;
+		}[] | undefined;
+	} | {
+		securityMode?: "partial" | "full" | undefined;
+		recentBlockhash?: string | undefined;
+		feePayer?: string | undefined;
+		programIds?: string[] | undefined;
+		squadsMultisigPda?: string | undefined;
+		squadsVaultPda?: string | undefined;
+		squadsTransactionIndex?: number | undefined;
+		squadsProposalAddress?: string | undefined;
+		multisigCreated?: boolean | undefined;
+		splMint?: string | undefined;
+	} | {
+		era?: string | undefined;
+		nonce?: number | undefined;
+		tip?: string | undefined;
+		specVersion?: number | undefined;
+	} | undefined;
+	payerAccountId?: string | undefined;
+	estimatedFee?: string | undefined;
+	requiredSignatures?: number | undefined;
+	sovereignty?: {
+		entityId: string;
+		mode: "partial";
+		validatorPublicKeys: string[];
+		authorizationSet?: {
+			chain: "hedera";
+			adminKey: HederaKeyShape;
+			supplyKey?: HederaKeyShape | undefined;
+			freezeKey?: HederaKeyShape | undefined;
+			wipeKey?: HederaKeyShape | undefined;
+			pauseKey?: HederaKeyShape | undefined;
+			kycKey?: HederaKeyShape | undefined;
+		} | {
+			chain: "xrpl";
+			signerEntries: {
+				account: string;
+				weight: number;
+			}[];
+			signerQuorum: number;
+			masterDisabled: boolean;
+		} | {
+			chain: "stellar";
+			signers: {
+				key: string;
+				weight: number;
+			}[];
+			thresholds: {
+				low: number;
+				med: number;
+				high: number;
+			};
+			masterWeight: number;
+		} | {
+			chain: "polkadot";
+			address: string;
+			signatory: PolkadotSignatoryShape;
+			ss58Format: number;
+		} | undefined;
+	} | {
+		entityId: string;
+		mode: "full";
+		validatorPublicKeys: string[];
+		authorizationSet?: {
+			chain: "hedera";
+			adminKey: HederaKeyShape;
+			supplyKey?: HederaKeyShape | undefined;
+			freezeKey?: HederaKeyShape | undefined;
+			wipeKey?: HederaKeyShape | undefined;
+			pauseKey?: HederaKeyShape | undefined;
+			kycKey?: HederaKeyShape | undefined;
+		} | {
+			chain: "xrpl";
+			signerEntries: {
+				account: string;
+				weight: number;
+			}[];
+			signerQuorum: number;
+			masterDisabled: boolean;
+		} | {
+			chain: "stellar";
+			signers: {
+				key: string;
+				weight: number;
+			}[];
+			thresholds: {
+				low: number;
+				med: number;
+				high: number;
+			};
+			masterWeight: number;
+		} | {
+			chain: "polkadot";
+			address: string;
+			signatory: PolkadotSignatoryShape;
+			ss58Format: number;
+		} | undefined;
+	} | undefined;
+}, {
+	chain: "hedera" | "xrpl" | "polkadot" | "solana" | "stellar" | "ethereum" | "polygon" | "bitcoin" | "cardano";
+	transactionId: string;
+	transactionType: string;
+	transactionBytes: string;
+	expiresAt: Date;
+	validatorSignatures: {
+		publicKey: string;
+		validatorId: string;
+		signature: string;
+		signedAt: Date;
+		algorithm?: "ed25519" | "ecdsa-secp256k1" | "bls12-381" | undefined;
+	}[];
+	metadata?: Record<string, any> | {
+		memo?: string | undefined;
+		nodeAccountIds?: string[] | undefined;
+		maxTransactionFee?: string | undefined;
+		scheduleInfo?: {
+			scheduleId: string;
+			adminKey?: string | undefined;
+		} | undefined;
+	} | {
+		signerQuorum?: number | undefined;
+		sequence?: number | undefined;
+		lastLedgerSequence?: number | undefined;
+		signerList?: {
+			account: string;
+			signerWeight: number;
+		}[] | undefined;
+	} | {
+		securityMode?: "partial" | "full" | undefined;
+		recentBlockhash?: string | undefined;
+		feePayer?: string | undefined;
+		programIds?: string[] | undefined;
+		squadsMultisigPda?: string | undefined;
+		squadsVaultPda?: string | undefined;
+		squadsTransactionIndex?: number | undefined;
+		squadsProposalAddress?: string | undefined;
+		multisigCreated?: boolean | undefined;
+		splMint?: string | undefined;
+	} | {
+		era?: string | undefined;
+		nonce?: number | undefined;
+		tip?: string | undefined;
+		specVersion?: number | undefined;
+	} | undefined;
+	payerAccountId?: string | undefined;
+	estimatedFee?: string | undefined;
+	requiredSignatures?: number | undefined;
+	readyToSubmit?: boolean | undefined;
+	sovereignty?: {
+		entityId: string;
+		mode: "partial";
+		validatorPublicKeys: string[];
+		authorizationSet?: {
+			chain: "hedera";
+			adminKey: HederaKeyShape;
+			supplyKey?: HederaKeyShape | undefined;
+			freezeKey?: HederaKeyShape | undefined;
+			wipeKey?: HederaKeyShape | undefined;
+			pauseKey?: HederaKeyShape | undefined;
+			kycKey?: HederaKeyShape | undefined;
+		} | {
+			chain: "xrpl";
+			signerEntries: {
+				account: string;
+				weight: number;
+			}[];
+			signerQuorum: number;
+			masterDisabled: boolean;
+		} | {
+			chain: "stellar";
+			signers: {
+				key: string;
+				weight: number;
+			}[];
+			thresholds: {
+				low: number;
+				med: number;
+				high: number;
+			};
+			masterWeight: number;
+		} | {
+			chain: "polkadot";
+			address: string;
+			signatory: PolkadotSignatoryShape;
+			ss58Format: number;
+		} | undefined;
+	} | {
+		entityId: string;
+		mode: "full";
+		validatorPublicKeys: string[];
+		authorizationSet?: {
+			chain: "hedera";
+			adminKey: HederaKeyShape;
+			supplyKey?: HederaKeyShape | undefined;
+			freezeKey?: HederaKeyShape | undefined;
+			wipeKey?: HederaKeyShape | undefined;
+			pauseKey?: HederaKeyShape | undefined;
+			kycKey?: HederaKeyShape | undefined;
+		} | {
+			chain: "xrpl";
+			signerEntries: {
+				account: string;
+				weight: number;
+			}[];
+			signerQuorum: number;
+			masterDisabled: boolean;
+		} | {
+			chain: "stellar";
+			signers: {
+				key: string;
+				weight: number;
+			}[];
+			thresholds: {
+				low: number;
+				med: number;
+				high: number;
+			};
+			masterWeight: number;
+		} | {
+			chain: "polkadot";
+			address: string;
+			signatory: PolkadotSignatoryShape;
+			ss58Format: number;
+		} | undefined;
+	} | undefined;
+}>;
+export type PreparedTransactionResponse = z.infer<typeof PreparedTransactionResponseSchema>;
 export interface ValidatorNetworkEndpoints {
 	apiEndpoint: string;
 	natsEndpoint?: string;
@@ -695,6 +1543,85 @@ export interface ClusterInfo {
 	endpoints: ClusterEndpointsView;
 	nodeIds: string[];
 }
+export type HttpClient = {
+	post<T = any>(path: string, body: unknown): Promise<T>;
+	get<T = any>(path: string): Promise<T>;
+	put<T = any>(path: string, body: unknown): Promise<T>;
+	patch<T = any>(path: string, body: unknown): Promise<T>;
+	delete<T = any>(path: string): Promise<T>;
+	getText(path: string): Promise<string>;
+	upload<T = any>(path: string, file: Blob | Buffer, filename: string, metadata?: Record<string, string>, fieldName?: string): Promise<T>;
+};
+export type DiscoveryClusterEndpoints = {
+	clusterId: string;
+	gatewayUrl: string;
+	harborUrl?: string;
+	natsUrl?: string;
+	publicIp?: string;
+	region?: string;
+};
+export type DiscoveryClusterRecord = {
+	clusterId: string;
+	endpoints: DiscoveryClusterEndpoints;
+	nodeIds: string[];
+};
+export type DiscoveryNodeRecord = {
+	nodeId: string;
+	publicKey?: string;
+	status?: string;
+	endpoints: DiscoveryClusterEndpoints;
+	endpointsCid: string;
+	lastEventTs: string;
+};
+export type DiscoveryPlatformImageManifest = {
+	imageName: string;
+	version: string;
+	sha256digest: string;
+	publishedAt: string;
+	publisherNodeId?: string;
+	metadata?: Record<string, unknown>;
+};
+export type DiscoveryPlatformImageEnvelope = {
+	manifest: DiscoveryPlatformImageManifest;
+	signature: string;
+	publicKey: string;
+};
+export type DiscoveryVerifyResult = {
+	verified: boolean;
+	reason?: string;
+};
+declare class DiscoveryClient {
+	private readonly http;
+	readonly platformImages: PlatformImagesClient;
+	constructor(http: HttpClient);
+	listClusters(): Promise<{
+		clusters: DiscoveryClusterRecord[];
+	}>;
+	listAllClusters(): Promise<{
+		records: DiscoveryNodeRecord[];
+	}>;
+	getClusterByNode(nodeId: string): Promise<{
+		record: DiscoveryNodeRecord | null;
+	}>;
+}
+declare class PlatformImagesClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	list(): Promise<{
+		manifests: DiscoveryPlatformImageManifest[];
+	}>;
+	listEnvelopes(): Promise<{
+		envelopes: DiscoveryPlatformImageEnvelope[];
+	}>;
+	get(imageName: string): Promise<{
+		imageName: string;
+		manifests: DiscoveryPlatformImageManifest[];
+	}>;
+	getVersion(imageName: string, version: string): Promise<{
+		manifest: DiscoveryPlatformImageManifest | null;
+	}>;
+	verify(imageName: string, version: string, digest: string): Promise<DiscoveryVerifyResult>;
+}
 export type AuthChain = "hedera" | "xrpl" | "polkadot" | "stellar" | "solana";
 export interface AuthenticateResponse {
 	token: string;
@@ -718,13 +1645,6 @@ export interface ResilientHttpConfig {
 	onCircuitBreakerStateChange?: (state: "closed" | "open" | "half_open") => void;
 }
 export type NetworkName = "testnet" | "mainnet";
-export type HttpClient = {
-	post<T = any>(path: string, body: unknown): Promise<T>;
-	get<T = any>(path: string): Promise<T>;
-	put<T = any>(path: string, body: unknown): Promise<T>;
-	delete<T = any>(path: string): Promise<T>;
-	upload<T = any>(path: string, file: Blob | Buffer, filename: string, metadata?: Record<string, string>, fieldName?: string): Promise<T>;
-};
 export type SubscriptionTierName = "free_testnet" | "starter" | "professional" | "enterprise";
 export type SubscriptionStatus = "pending_deposit" | "deposit_confirmed" | "active" | "expired" | "cancelled";
 export type DepositWalletStatus = "pending" | "locked" | "expired" | "slashed" | "released";
@@ -820,6 +1740,120 @@ export type SubscriptionListResponse = {
 		createdAt: string;
 	}>;
 };
+export type PendingTierChange = {
+	fromTier?: SubscriptionTierName;
+	toTier?: SubscriptionTierName;
+	direction?: "upgrade" | "downgrade";
+	effectiveAt?: string;
+	depositInstructions?: {
+		walletAddress: string;
+		tokenId: string;
+		amount: string;
+		chain: string;
+	};
+};
+export type DowngradeSubscriptionRequest = {
+	appId: string;
+	toTier: SubscriptionTierName;
+};
+export type DowngradeSubscriptionResponse = {
+	success: boolean;
+	appId: string;
+	pendingTierChange?: PendingTierChange;
+	message: string;
+};
+export type UpgradeSubscriptionRequest = {
+	appId: string;
+	toTier: SubscriptionTierName;
+};
+export type UpgradeSubscriptionResponse = {
+	success: boolean;
+	appId: string;
+	pendingTierChange?: PendingTierChange;
+	depositInstructions?: {
+		walletAddress: string;
+		tokenId: string;
+		amount: string;
+		chain: string;
+	};
+	message: string;
+};
+export type CancelTierChangeRequest = {
+	appId: string;
+};
+export type CancelTierChangeResponse = {
+	success: boolean;
+	appId: string;
+	message: string;
+};
+export type ActiveSubscriptionForWalletResponse = {
+	active: boolean;
+};
+export type SubscriptionUsageSummaryResponse = {
+	appId: string;
+	total: number;
+	byCategory: {
+		database: number;
+		functions: number;
+		messaging: number;
+		storage: number;
+		ipfs: number;
+		snapshots: number;
+		other: number;
+	};
+	recordCount: number;
+	lastUpdated: string;
+};
+export type SubscriptionUsageStatusResponse = {
+	appId: string;
+	usagePercent: number;
+	currentUsage: number;
+	dailyLimit: number;
+	overagePercent: number;
+	inGracePeriod: boolean;
+	graceExpiresAt: string | null;
+	blocked: boolean;
+	suggestUpgrade: boolean;
+	nextTier: {
+		tier: SubscriptionTierName;
+		name: string;
+		apiCallsPerDay: number;
+		monthlyPriceHsuite: number;
+	} | null;
+	projectedDaysUntilLimit: number | null;
+};
+export type SubscriptionBillingLedgerEntry = {
+	id: string;
+	subscriptionId: string;
+	operation: string;
+	amount: string;
+	balanceAfter: string;
+	timestamp: string;
+	metadata?: Record<string, unknown>;
+};
+export type SubscriptionBillingResponse = {
+	appId: string;
+	entries: SubscriptionBillingLedgerEntry[];
+	total: number;
+	hasMore: boolean;
+};
+export type GetBillingOptions = {
+	limit?: number;
+	offset?: number;
+	from?: string;
+	to?: string;
+};
+export type MintCustomerSubscriptionRequest = {
+	appId: string;
+	customerAddress: string;
+	customerChain: "xrpl";
+	metadataCid: string;
+};
+export type MintCustomerSubscriptionResponse = {
+	success: true;
+	nftSerial: number;
+	txHash: string;
+};
 export type BalanceResponse = {
 	appId: string;
 	subscriptionId: string;
@@ -839,6 +1873,14 @@ declare class SubscriptionClient {
 	list(): Promise<SubscriptionListResponse>;
 	listByStatus(status: SubscriptionStatus): Promise<SubscriptionListResponse>;
 	getBalance(appId: string): Promise<BalanceResponse>;
+	downgrade(request: DowngradeSubscriptionRequest): Promise<DowngradeSubscriptionResponse>;
+	upgrade(request: UpgradeSubscriptionRequest): Promise<UpgradeSubscriptionResponse>;
+	cancelTierChange(request: CancelTierChangeRequest): Promise<CancelTierChangeResponse>;
+	getActiveFor(walletAddress: string): Promise<ActiveSubscriptionForWalletResponse>;
+	getUsage(appId: string): Promise<SubscriptionUsageSummaryResponse>;
+	getUsageStatus(appId: string): Promise<SubscriptionUsageStatusResponse>;
+	getBilling(appId: string, options?: GetBillingOptions): Promise<SubscriptionBillingResponse>;
+	mintCustomer(request: MintCustomerSubscriptionRequest): Promise<MintCustomerSubscriptionResponse>;
 }
 export type EntityType = "account" | "token" | "topic";
 export type EntityCreationOptions = {
@@ -929,13 +1971,44 @@ export type MultiSigStatusResponse = {
 	threshold?: number;
 	participants?: string[];
 };
+export type TssJobType = "entity-create";
+export type TssJobStatus = "pending" | "in-progress" | "success" | "failed";
+export type TssJobAccepted = {
+	jobId: string;
+	statusUrl: string;
+	status: "pending";
+};
+export type TssJobResponse = {
+	jobId: string;
+	type: TssJobType;
+	status: TssJobStatus;
+	request?: unknown;
+	result?: unknown;
+	error?: {
+		code: string;
+		message: string;
+	};
+	createdAt: string;
+	updatedAt: string;
+};
+export type SignForAppRequest = {
+	payloadHex: string;
+};
+export type SignForAppResponse = {
+	appId: string;
+	signatureHex: string;
+	blsPubKeyHex: string;
+	signedAt: string;
+};
 declare class TSSClient {
 	private readonly http;
 	constructor(http: HttpClient);
 	createEntity(options: EntityCreationOptions): Promise<EntityCreationResponse>;
 	reshareCluster(request: ReshareRequest): Promise<ReshareResponse>;
 	getEntity(entityId: string): Promise<EntityDetails>;
-	signMPC(request: MPCSigningRequest): Promise<MPCSigningResponse>;
+	signMPC(request: MPCSigningRequest & {
+		chain?: "hedera";
+	}): Promise<MPCSigningResponse>;
 	getValidators(): Promise<ValidatorListResponse>;
 	announceKey(): Promise<{
 		success: boolean;
@@ -946,6 +2019,10 @@ declare class TSSClient {
 	getHealth(): Promise<TSSHealthResponse>;
 	listCeremonies(): Promise<CeremonyListResponse>;
 	getMultiSigStatus(txId: string): Promise<MultiSigStatusResponse>;
+	createEntityAsync(options: EntityCreationOptions): Promise<TssJobAccepted>;
+	reshareClusterAsync(request: ReshareRequest): Promise<TssJobAccepted>;
+	getJob(jobId: string): Promise<TssJobResponse>;
+	signForApp(appId: string, request: SignForAppRequest): Promise<SignForAppResponse>;
 }
 export type IpfsFileMetadata = {
 	cid: string;
@@ -1196,18 +2273,192 @@ export type TransactionInfoResponse = {
 	supportedChains: string[];
 	responseFormat?: Record<string, string>;
 };
-export type PrepareTopicCreateRequest = {
+export type MetaplexCreator = {
+	address: string;
+	verified: boolean;
+	share: number;
+};
+export type PrepareNftCollectionCreateRequest = {
+	chain: "polkadot" | "solana";
 	payerAccountId?: string;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+	admin?: string;
+	config?: {
+		settings?: number;
+		maxSupply?: number | null;
+		mintSettings?: unknown;
+	};
+	name?: string;
+	symbol?: string;
+	uri?: string;
+	sellerFeeBasisPoints?: number;
+	creators?: MetaplexCreator[];
+	recipient?: string;
+	mintAuthority?: string;
 	memo?: string;
-	adminKeyRequired?: boolean;
-	submitKeyRequired?: boolean;
-	entityId: string;
 };
-export type PrepareTopicMessageRequest = {
+export type PrepareNftSetMetadataRequest = {
+	chain: "polkadot";
 	payerAccountId?: string;
-	topicId: string;
-	message: string | Record<string, unknown>;
-	entityId: string;
+	collection: number;
+	item: number;
+	data: string;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+};
+export type PrepareNftCollectionSetMetadataRequest = {
+	chain: "polkadot";
+	payerAccountId?: string;
+	collection: number;
+	data: string;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+};
+export type PrepareNftCollectionLockRequest = {
+	chain: "polkadot";
+	payerAccountId?: string;
+	collection: number;
+	lockSettings: number;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+};
+export type HederaTssSecurityMode = "full" | "partial";
+export type ValidatorBoundRequest = {
+	entityId: string;
+	validatorTimestamp: string;
+	validatorTopicId: string;
+	payerAccountId?: string;
+};
+export type CreateHederaAccountRequest = ValidatorBoundRequest & {
+	initialBalance?: number;
+	securityMode?: HederaTssSecurityMode;
+	appOwnerPublicKey?: string;
+};
+export type CreateHederaAccountResponse = {
+	success: boolean;
+	accountId: string;
+	transactionId: string;
+	hashscanUrl: string;
+	securityMode: HederaTssSecurityMode;
+	validatorBinding: {
+		timestamp: string;
+		topicId: string;
+		memo: string;
+		rulesUrl: string;
+	};
+};
+export type UpdateHederaMemoRequest = {
+	entityId: string;
+	accountId: string;
+	newMemo: string;
+	payerAccountId?: string;
+};
+export type UpdateHederaMemoResponse = {
+	success: boolean;
+	transactionId: string;
+	hashscanUrl: string;
+	status: string;
+};
+export type CreateHederaTopicRequest = ValidatorBoundRequest;
+export type CreateHederaTopicResponse = {
+	success: boolean;
+	topicId: string;
+	transactionId: string;
+	hashscanUrl: string;
+	validatorBinding: {
+		timestamp: string;
+		topicId: string;
+		memo: string;
+		rulesUrl: string;
+	};
+};
+export type SubmitHederaMessageRequest = {
+	entityId: string;
+	topicId: string;
+	message: string;
+	payerAccountId?: string;
+};
+export type SubmitHederaMessageResponse = {
+	success: boolean;
+	sequenceNumber: string | number;
+	transactionId: string;
+	hashscanUrl: string;
+};
+export type CreateHederaTokenRequest = ValidatorBoundRequest & {
+	name: string;
+	symbol: string;
+	decimals: number;
+	initialSupply: number;
+	maxSupply?: number;
+	treasuryAccountId: string;
+	enableAdminKey?: boolean;
+	enableSupplyKey?: boolean;
+	enableFreezeKey?: boolean;
+	enablePauseKey?: boolean;
+	enableWipeKey?: boolean;
+};
+export type CreateHederaTokenResponse = {
+	success: boolean;
+	tokenId: string;
+	transactionId: string;
+	hashscanUrl: string;
+	tokenUrl: string;
+	keys: Record<string, string>;
+	validatorBinding: {
+		timestamp: string;
+		topicId: string;
+		memo: string;
+		rulesUrl: string;
+	};
+};
+export type MintHederaTokenRequest = {
+	entityId: string;
+	tokenId: string;
+	amount: number;
+	decimals?: number;
+	validatorTopicId?: string;
+	payerAccountId?: string;
+};
+export type MintHederaTokenResponse = {
+	success: boolean;
+	transactionId: string;
+	hashscanUrl: string;
+	newTotalSupply: string;
+	mintedAmount: string | number;
+	tokenId: string;
+	decimals: number;
+};
+declare class HederaTssClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	createAccount(request: CreateHederaAccountRequest): Promise<CreateHederaAccountResponse>;
+	updateMemo(request: UpdateHederaMemoRequest): Promise<UpdateHederaMemoResponse>;
+	createTopic(request: CreateHederaTopicRequest): Promise<CreateHederaTopicResponse>;
+	submitMessage(request: SubmitHederaMessageRequest): Promise<SubmitHederaMessageResponse>;
+	createToken(request: CreateHederaTokenRequest): Promise<CreateHederaTokenResponse>;
+	mintToken(request: MintHederaTokenRequest): Promise<MintHederaTokenResponse>;
+}
+export type PrepareTopicCreateRequest = {
+	payerAccountId?: string;
+	memo?: string;
+	adminKeyRequired?: boolean;
+	submitKeyRequired?: boolean;
+	entityId: string;
+};
+export type PrepareTopicMessageRequest = {
+	payerAccountId?: string;
+	topicId: string;
+	message: string | Record<string, unknown>;
+	entityId: string;
 };
 export type PrepareTokenComplianceEnableRequest = {
 	payerAccountId?: string;
@@ -1229,7 +2480,8 @@ export type PrepareTokenWipeRequest = {
 };
 declare class HederaTransactionsClient {
 	private readonly http;
-	constructor(http: HttpClient);
+	readonly tss: HederaTssClient;
+	constructor(http: HttpClient, tssHttp?: HttpClient);
 	prepareTopicCreate(request: PrepareTopicCreateRequest): Promise<PreparedTransaction>;
 	prepareTopicMessage(request: PrepareTopicMessageRequest): Promise<PreparedTransaction>;
 	prepareTokenComplianceEnable(request: PrepareTokenComplianceEnableRequest): Promise<PreparedTransaction>;
@@ -1244,10 +2496,39 @@ export type PrepareTrustLineRequest = {
 	limit?: string;
 	entityId: string;
 };
+export type PrepareXrplAccountSetupRequest = {
+	payerAccountId?: string;
+	accountAddress: string;
+	validatorTimestamp: string;
+	validatorTopicId: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	entityId?: string;
+};
+export type PreparedTransactionSovereignty = {
+	mode: SecurityMode | "none";
+	appOwnerPublicKey?: string;
+	signerListEntries?: Array<{
+		account: string;
+		weight: number;
+	}>;
+	signerQuorum?: number;
+};
+export type XrplAccountSetupSteps = {
+	steps: Array<{
+		step: number;
+		description?: string;
+		transactionBytes: string;
+		transactionId?: string;
+		[k: string]: unknown;
+	}>;
+	sovereignty: PreparedTransactionSovereignty;
+};
 declare class XrplTransactionsClient {
 	private readonly http;
 	constructor(http: HttpClient);
 	prepareTrustLine(request: PrepareTrustLineRequest): Promise<PreparedTransaction>;
+	prepareAccountSetup(request: PrepareXrplAccountSetupRequest): Promise<XrplAccountSetupSteps>;
 }
 export type PrepareTokenCloseAccountRequest = {
 	payerAccountId?: string;
@@ -1300,6 +2581,10 @@ declare class TransactionsClient {
 	prepareNftMint(request: PrepareNftMintRequest): Promise<PreparedTransaction>;
 	prepareNftBurn(request: PrepareNftBurnRequest): Promise<PreparedTransaction>;
 	prepareNftTransfer(request: PrepareNftTransferRequest): Promise<PreparedTransaction>;
+	prepareNftCollectionCreate(request: PrepareNftCollectionCreateRequest): Promise<PreparedTransaction>;
+	prepareNftSetMetadata(request: PrepareNftSetMetadataRequest): Promise<PreparedTransaction>;
+	prepareNftCollectionSetMetadata(request: PrepareNftCollectionSetMetadataRequest): Promise<PreparedTransaction>;
+	prepareNftCollectionLock(request: PrepareNftCollectionLockRequest): Promise<PreparedTransaction>;
 	prepareTokenCreate(request: PrepareTokenCreateRequest): Promise<PreparedTransaction>;
 	prepareTokenMint(request: PrepareTokenMintRequest): Promise<PreparedTransaction>;
 	prepareTokenBurn(request: PrepareTokenBurnRequest): Promise<PreparedTransaction>;
@@ -1516,6 +2801,391 @@ declare class GovernanceClient {
 	constructor(http: HttpClient);
 	simulate(params: GovernanceSimulateRequest): Promise<GovernanceValidationResult>;
 }
+export type DaoSupportedChain = "hedera" | "xrpl" | "polkadot" | "solana" | "ethereum" | "polygon" | "bitcoin" | "stellar" | "cardano";
+export type DaoStatus = "pending" | "active" | "paused" | "dissolved";
+export type DaoMembershipModel = "token-only" | "nft-only" | "token-and-nft";
+export type DaoMemberStatus = "active" | "removed";
+export type DaoVotingPowerModel = "token-balance" | "quadratic" | "one-person-one-vote" | "nft-based" | "delegated";
+export type DaoProposalType = "dao_parameter_change" | "dao_treasury_transfer" | "dao_treasury_allocation" | "dao_update_details" | "dao_set_status" | "dao_add_member" | "dao_remove_member" | "dao_token_mint" | "dao_token_burn" | "dao_token_pause" | "dao_token_unpause" | "dao_token_freeze" | "dao_token_unfreeze" | "dao_token_kyc" | "dao_token_wipe" | "dao_token_transfer" | "dao_hbar_transfer" | "dao_custom";
+export type DaoProposalStatus = "pending" | "awaiting_signature" | "active" | "passed" | "failed" | "executed" | "cancelled" | "expired" | "vetoed";
+export type DaoChainTokenEntry = {
+	chain: DaoSupportedChain;
+	tokenId: string;
+	issuerAddress?: string;
+	decimals: number;
+};
+export type DaoMultiChainTokenConfig = {
+	symbol: string;
+	chains: DaoChainTokenEntry[];
+};
+export type DaoVotingRules = {
+	approvalThresholdPercent: number;
+	quorumPercent: number;
+	votingPeriodMs: number;
+	votingPowerModel: DaoVotingPowerModel;
+	allowVoteChange: boolean;
+	executionDelayMs: number;
+	proposalCooldownMs: number;
+	maxActiveProposals: number;
+	proposalThreshold: string;
+};
+export type DaoTreasuryWallet = {
+	chain: DaoSupportedChain;
+	walletAddress: string;
+	tssEntityId: string;
+};
+export type DaoTreasuryConfig = {
+	wallets: DaoTreasuryWallet[];
+	spendingLimits?: {
+		perProposalLimit?: string;
+		dailyLimit?: string;
+	};
+};
+export type DaoConfig = {
+	daoId: string;
+	name: string;
+	description: string;
+	status: DaoStatus;
+	membershipModel: DaoMembershipModel;
+	governanceToken: DaoMultiChainTokenConfig;
+	nftToken?: DaoMultiChainTokenConfig;
+	votingRules: DaoVotingRules;
+	treasury: DaoTreasuryConfig;
+	vetoCouncil?: string[];
+	createdBy: string;
+	createdAt: string | Date;
+	hcsTopicId?: string;
+	metadataCid?: string;
+	image?: string;
+	banner?: string;
+	socials?: {
+		discord?: string;
+		twitter?: string;
+		website?: string;
+	};
+	tokenControlledByValidators?: boolean;
+};
+export type DaoProposalAction = {
+	type: string;
+	chain?: DaoSupportedChain;
+	targetEntityId?: string;
+	params: Record<string, unknown>;
+};
+export type DaoVotingOption = {
+	id: string;
+	label: string;
+	description?: string;
+	type?: "approve" | "reject";
+	actionPayload?: DaoProposalAction;
+};
+export type DaoProposalConfig = {
+	proposalId: string;
+	daoId: string;
+	type: DaoProposalType;
+	title: string;
+	description: string;
+	content?: string;
+	images?: string[];
+	externalLinks?: Array<{
+		label: string;
+		url: string;
+	}>;
+	proposer: string;
+	status: DaoProposalStatus;
+	votingOptions: DaoVotingOption[];
+	votingPeriodMs: number;
+	votingStartsAt: string | Date;
+	votingEndsAt: string | Date;
+	executionDeadline?: string | Date;
+	snapshotId: string;
+	snapshotPinTimestamp?: number;
+	actions: DaoProposalAction[];
+	tally: Record<string, string>;
+	quorumReached: boolean;
+	totalVotingPower: string;
+	hcsTopicId?: string;
+	executionResult?: {
+		success: boolean;
+		transactionIds?: string[];
+		error?: string;
+	};
+	winningOptionId?: string;
+	preparedMessage?: {
+		message: Record<string, unknown>;
+		voteTopicId?: string;
+		snapshot?: string;
+		createdAt: string | Date;
+	};
+	passedAt?: string | Date;
+	createdAt: string | Date;
+	executedAt?: string | Date;
+};
+export type DaoVote = {
+	proposalId: string;
+	daoId: string;
+	voter: string;
+	choice: string;
+	weight: string;
+	comment?: string;
+	chain: DaoSupportedChain;
+	delegatedFrom?: string;
+	timestamp: string | Date;
+};
+export type DaoMember = {
+	daoId: string;
+	address: string;
+	chain: DaoSupportedChain;
+	nftSerials?: number[];
+	joinedAt: string | Date;
+	status: DaoMemberStatus;
+};
+export type DaoDashboardStats = {
+	totalDaosJoined: number;
+	totalVotesCast: number;
+	totalProposalsCreated: number;
+	activeProposalsCount: number;
+	pendingActionsCount: number;
+};
+export type DaoGovernanceImpact = {
+	totalVotingPower: string;
+	proposalSuccessRate: number;
+	averageVoteWeight: string;
+	mostActiveDao?: {
+		daoId: string;
+		name: string;
+	};
+	participationStreak: number;
+	proposalOutcomes: {
+		created: number;
+		passed: number;
+		rejected: number;
+		expired: number;
+	};
+};
+export type DaoActiveProposalForUser = {
+	proposal: DaoProposalConfig;
+	dao: DaoConfig;
+	hasVoted: boolean;
+	timeRemaining: number;
+};
+export type DaoActivityEntry = {
+	type: string;
+	daoId: string;
+	entityId: string;
+	timestamp: string | Date;
+	description: string;
+};
+export type DaoPendingAction = {
+	type: string;
+	daoId: string;
+	entityId: string;
+	description: string;
+};
+export type CreateDaoRequest = {
+	name: string;
+	description: string;
+	membershipModel: DaoMembershipModel;
+	governanceToken: DaoMultiChainTokenConfig;
+	nftToken?: DaoMultiChainTokenConfig;
+	votingRules: DaoVotingRules;
+	vetoCouncil?: string[];
+	treasuryChains: DaoSupportedChain[];
+	metadataCid?: string;
+	daoId?: string;
+	createdBy: string;
+};
+export type CreateDaoProposalRequest = {
+	type: DaoProposalType;
+	title: string;
+	description: string;
+	content?: string;
+	proposer: string;
+	votingOptions?: DaoVotingOption[];
+	actions: DaoProposalAction[];
+};
+export type CastVoteRequest = {
+	voter: string;
+	choice: string;
+	chain: DaoSupportedChain;
+	comment?: string;
+	delegatedFrom?: string;
+};
+export type PrepareDaoProposalRequest = CreateDaoProposalRequest;
+export type PrepareVoteRequest = CastVoteRequest;
+export type SubmitSignedProposalRequest = {
+	signature: string;
+};
+export type SubmitSignedVoteRequest = PrepareVoteRequest & {
+	signature: string;
+};
+export type AddDaoMemberRequest = {
+	address: string;
+	chain: DaoSupportedChain;
+	nftSerials?: number[];
+};
+export type ClaimDaoMemberNftRequest = {
+	nftSerial: number;
+};
+export type ListDaosOptions = {
+	status?: string;
+	createdBy?: string;
+};
+export type ListProposalsOptions = {
+	status?: string;
+	proposer?: string;
+};
+export type ListMembersOptions = {
+	status?: string;
+};
+export type VoteListOptions = {
+	limit?: number;
+	offset?: number;
+};
+export type TreasuryHistoryOptions = {
+	chain?: string;
+	limit?: number;
+	offset?: number;
+};
+export type DashboardListOptions = {
+	limit?: number;
+	offset?: number;
+};
+export type DashboardActivityOptions = {
+	limit?: number;
+	daoId?: string;
+};
+export type CreateDaoResponse = {
+	success: boolean;
+	dao: DaoConfig;
+};
+export type ListDaosResponse = {
+	count: number;
+	daos: DaoConfig[];
+};
+export type DaoWithProposalsResponse = {
+	dao: DaoConfig;
+	proposals: DaoProposalConfig[];
+};
+export type ListProposalsResponse = {
+	count: number;
+	proposals: DaoProposalConfig[];
+};
+export type CreateProposalResponse = {
+	success: boolean;
+	proposal: DaoProposalConfig;
+};
+export type PrepareProposalResponse = {
+	success: boolean;
+	proposal: DaoProposalConfig;
+};
+export type SubmitSignedProposalResponse = {
+	success: boolean;
+	proposal: DaoProposalConfig;
+};
+export type PrepareVoteResponse = {
+	success: boolean;
+	proposalId: string;
+	message: Record<string, unknown>;
+	weight: string;
+};
+export type CastVoteResponse = {
+	success: boolean;
+	vote: DaoVote;
+};
+export type VotesListResponse = {
+	count: number;
+	votes: DaoVote[];
+};
+export type ProposalResultsResponse = {
+	tally: Record<string, string>;
+	quorumReached: boolean;
+	passed: boolean;
+};
+export type ExecuteProposalResponse = {
+	success: boolean;
+	transactionIds?: string[];
+	error?: string;
+};
+export type TreasuryHistoryEntry = {
+	chain: string;
+	type: string;
+	amount: string;
+	tokenId: string;
+	txId: string;
+	timestamp: string | Date;
+};
+export type TreasuryHistoryResponse = {
+	count: number;
+	transactions: TreasuryHistoryEntry[];
+};
+export type TreasuryBalancesResponse = {
+	balances: Array<{
+		chain: string;
+		walletAddress: string;
+		tokenBalances: Record<string, string>;
+	}>;
+};
+export type ListMembersResponse = {
+	count: number;
+	members: DaoMember[];
+};
+export type AddMemberResponse = {
+	success: boolean;
+	member: DaoMember;
+};
+export type RemoveMemberResponse = {
+	success: boolean;
+};
+export type ClaimNftResponse = {
+	success: boolean;
+	member: DaoMember;
+};
+export type MemberNftResponse = {
+	nftSerials: number[];
+	status: string;
+};
+declare class DaoDashboardClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	getStats(userAddress: string): Promise<DaoDashboardStats>;
+	getActiveProposals(userAddress: string): Promise<DaoActiveProposalForUser[]>;
+	getVoteHistory(userAddress: string, opts?: DashboardListOptions): Promise<{
+		count: number;
+		votes: DaoVote[];
+	}>;
+	getActivity(userAddress: string, opts?: DashboardActivityOptions): Promise<DaoActivityEntry[]>;
+	getPendingActions(userAddress: string): Promise<DaoPendingAction[]>;
+	getImpact(userAddress: string): Promise<DaoGovernanceImpact>;
+}
+declare class DaoClient {
+	private readonly http;
+	readonly dashboard: DaoDashboardClient;
+	constructor(http: HttpClient);
+	create(request: CreateDaoRequest): Promise<CreateDaoResponse>;
+	list(opts?: ListDaosOptions): Promise<ListDaosResponse>;
+	get(daoId: string): Promise<DaoConfig>;
+	getWithProposals(daoId: string): Promise<DaoWithProposalsResponse>;
+	listProposals(daoId: string, opts?: ListProposalsOptions): Promise<ListProposalsResponse>;
+	createProposal(daoId: string, request: CreateDaoProposalRequest): Promise<CreateProposalResponse>;
+	prepareProposal(daoId: string, request: PrepareDaoProposalRequest): Promise<PrepareProposalResponse>;
+	signProposal(daoId: string, proposalId: string, request: SubmitSignedProposalRequest): Promise<SubmitSignedProposalResponse>;
+	prepareVote(daoId: string, proposalId: string, request: PrepareVoteRequest): Promise<PrepareVoteResponse>;
+	submitVote(daoId: string, proposalId: string, request: SubmitSignedVoteRequest): Promise<CastVoteResponse>;
+	vote(daoId: string, proposalId: string, request: CastVoteRequest): Promise<CastVoteResponse>;
+	execute(daoId: string, proposalId: string): Promise<ExecuteProposalResponse>;
+	getVotes(daoId: string, proposalId: string, opts?: VoteListOptions): Promise<VotesListResponse>;
+	getResults(daoId: string, proposalId: string): Promise<ProposalResultsResponse>;
+	getVoteCounts(daoId: string, proposalId: string): Promise<Record<string, number>>;
+	getVoterRecord(daoId: string, proposalId: string, voterAddress: string): Promise<DaoVote>;
+	getProposal(daoId: string, proposalId: string): Promise<DaoProposalConfig>;
+	getTreasury(daoId: string, chain?: string): Promise<TreasuryBalancesResponse>;
+	getTreasuryHistory(daoId: string, opts?: TreasuryHistoryOptions): Promise<TreasuryHistoryResponse>;
+	listMembers(daoId: string, opts?: ListMembersOptions): Promise<ListMembersResponse>;
+	addMember(daoId: string, request: AddDaoMemberRequest): Promise<AddMemberResponse>;
+	removeMember(daoId: string, address: string): Promise<RemoveMemberResponse>;
+	claimMemberNft(daoId: string, address: string, request: ClaimDaoMemberNftRequest): Promise<ClaimNftResponse>;
+	getMemberNft(daoId: string, address: string): Promise<MemberNftResponse>;
+}
 export type PersonhoodAttestationMethod = "web-of-trust" | "biometric" | "pop-protocol";
 export interface PersonhoodProof {
 	attestationMethod: PersonhoodAttestationMethod;
@@ -1599,6 +3269,9 @@ export type AgentWithdrawRequest = {
 	amount: string;
 	destination: string;
 };
+export type AgentPreparedTransactionResponse = PreparedTransactionResponse & {
+	success: true;
+};
 declare class AgentsClient {
 	private readonly http;
 	constructor(http: HttpClient);
@@ -1608,18 +3281,9 @@ declare class AgentsClient {
 		agents: AgentInfo[];
 		total: number;
 	}>;
-	fund(agentId: string, request: AgentFundRequest): Promise<{
-		success: boolean;
-		txId?: string;
-	}>;
-	trade(agentId: string, request: AgentTradeRequest): Promise<{
-		success: boolean;
-		txId?: string;
-	}>;
-	withdraw(agentId: string, request: AgentWithdrawRequest): Promise<{
-		success: boolean;
-		txId?: string;
-	}>;
+	fund(agentId: string, request: AgentFundRequest): Promise<AgentPreparedTransactionResponse>;
+	trade(agentId: string, request: AgentTradeRequest): Promise<AgentPreparedTransactionResponse>;
+	withdraw(agentId: string, request: AgentWithdrawRequest): Promise<AgentPreparedTransactionResponse>;
 	pause(agentId: string): Promise<{
 		success: boolean;
 		status: string;
@@ -1931,6 +3595,19 @@ export type BaasRuntimeStatus = {
 export type BaasAppListResponse = {
 	apps: DeployedAppInfo[];
 };
+export type BaasSetWebhookResponse = {
+	appId: string;
+	webhookUrl: string;
+	webhookSecret: string;
+};
+export type BaasRotateKekResponse = {
+	success: boolean;
+	newKekVersion: number;
+};
+export type BaasRevokeKekResponse = {
+	success: boolean;
+	revokedKekVersions: number[];
+};
 declare class DeploymentClient {
 	private readonly http;
 	constructor(http: HttpClient);
@@ -1958,6 +3635,318 @@ declare class DeploymentClient {
 		activeApps: number;
 		totalOwners: number;
 	}>;
+	setWebhook(appId: string, webhookUrl: string): Promise<BaasSetWebhookResponse>;
+	getMetrics(appId: string): Promise<string>;
+	rotateKek(appId: string): Promise<BaasRotateKekResponse>;
+	revokeKek(appId: string, version: number): Promise<BaasRevokeKekResponse>;
+}
+export type BridgeChain = "hedera" | "xrpl" | "polkadot" | "solana" | "stellar";
+export type BridgeMode = "rekey" | "lock-wallet";
+export type BridgeDirection = "one-way" | "two-way";
+export type BridgeTrustLevel = "owner-rekeyed" | "owner-verified" | "community";
+export type BridgeStatus = "initializing" | "active" | "paused" | "closed";
+export type BridgeClaimStatus = "pending" | "completed" | "failed";
+export type BridgeOperationConfig = {
+	enabled: boolean;
+	controller?: "owner" | "dao";
+	requiresEvidence: boolean;
+	evidenceType?: string;
+	limits?: {
+		totalLimit?: string;
+		perTxLimit?: string;
+		dailyLimit?: string;
+	};
+};
+export type BridgeRulesConfig = {
+	mint: BridgeOperationConfig;
+	burn: BridgeOperationConfig;
+	timeRange?: {
+		start: number;
+		end?: number;
+	};
+};
+export type BridgeSourceConfig = {
+	chain: BridgeChain;
+	tokenId: string;
+	keyModel: BridgeMode;
+	lockWalletAddress?: string;
+	tssEntityId?: string;
+};
+export type BridgeDestinationConfig = {
+	chain: BridgeChain;
+	tokenId: string;
+	issuerAddress?: string;
+	createIfMissing: boolean;
+};
+export type BridgeGenesisBinding = {
+	sourceTokenId: string;
+	destinationTokenId: string;
+	initializedAt: string;
+};
+export type BridgeConfig = {
+	bridgeId: string;
+	source: BridgeSourceConfig;
+	destination: BridgeDestinationConfig;
+	direction: BridgeDirection;
+	allowedDirections: string[];
+	rules: BridgeRulesConfig;
+	trustLevel: BridgeTrustLevel;
+	status: BridgeStatus;
+	tssEntityId: string;
+	genesisBinding?: BridgeGenesisBinding;
+	createdAt: string | Date;
+	createdBy?: string;
+};
+export type CreateBridgeRequest = {
+	sourceChain: BridgeChain;
+	sourceTokenId: string;
+	destinationChain: BridgeChain;
+	keyModel: BridgeMode;
+	direction: BridgeDirection;
+	createDestinationToken: boolean;
+	destinationTokenId?: string;
+	rules: BridgeRulesConfig;
+	name?: string;
+};
+export type CreateBridgeResponse = {
+	success: boolean;
+	bridge: BridgeConfig;
+};
+export type ListBridgesOptions = {
+	status?: BridgeStatus;
+	sourceChain?: BridgeChain;
+};
+export type ListBridgesResponse = {
+	count: number;
+	bridges: BridgeConfig[];
+};
+export type PortRequest = {
+	amount: string;
+	sourceAccountId: string;
+	destinationAddress: string;
+	sourceTxId?: string;
+	metadata?: Record<string, unknown>;
+};
+export type ReturnRequest = {
+	amount: string;
+	destinationAccountId: string;
+	sourceAddress: string;
+	destinationBurnTxId?: string;
+	metadata?: Record<string, unknown>;
+};
+export type PortResult = {
+	success: boolean;
+	claimId: string;
+	sourceTxId?: string;
+	destinationTxId?: string;
+	amount: string;
+	error?: string;
+};
+export type BridgeClaimRecord = {
+	claimId: string;
+	bridgeId: string;
+	sourceTxId: string;
+	destinationTxId?: string;
+	amount: string;
+	sourceAccountId: string;
+	destinationAddress: string;
+	direction: string;
+	status: BridgeClaimStatus;
+	createdAt: string | Date;
+	completedAt?: string | Date;
+	error?: string;
+};
+export type BridgeSupply = {
+	sourceSupply: string;
+	destinationMinted: string;
+	totalPorted: string;
+	remainingMintable: string;
+	totalClaims: number;
+};
+export type ListClaimsOptions = {
+	limit?: number;
+	offset?: number;
+};
+export type ListClaimsResponse = {
+	count: number;
+	claims: BridgeClaimRecord[];
+};
+declare class BridgeClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	create(request: CreateBridgeRequest): Promise<CreateBridgeResponse>;
+	list(options?: ListBridgesOptions): Promise<ListBridgesResponse>;
+	get(bridgeId: string): Promise<BridgeConfig>;
+	port(bridgeId: string, request: PortRequest): Promise<PortResult>;
+	return(bridgeId: string, request: ReturnRequest): Promise<PortResult>;
+	getStatus(bridgeId: string, claimId: string): Promise<BridgeClaimRecord>;
+	getSupply(bridgeId: string): Promise<BridgeSupply>;
+	listClaims(bridgeId: string, options?: ListClaimsOptions): Promise<ListClaimsResponse>;
+}
+export type ResourcesEnvelope<T = unknown> = {
+	success: boolean;
+	data: T;
+	timestamp: string;
+};
+export type ResourceSummaryResponse = ResourcesEnvelope;
+export type ResourceConsumptionResponse = ResourcesEnvelope;
+export type ResourceHistoryResponse = ResourcesEnvelope;
+export type ResourceLedgerResponse = ResourcesEnvelope;
+export type ResourceBreakdownResponse = ResourcesEnvelope;
+export type ResourceNodesResponse = ResourcesEnvelope;
+export type ResourceNodeResponse = ResourcesEnvelope;
+export type ResourceStatusResponse = ResourcesEnvelope<{
+	appId: string;
+	currentUsage: number;
+	dailyLimit: number;
+	usagePercent: number;
+	blocked: boolean;
+	warnings: unknown;
+	suggestUpgrade: boolean;
+	breakdown: unknown;
+}>;
+export type ResourceLedgerOptions = {
+	limit?: number;
+	offset?: number;
+	since?: string;
+	until?: string;
+	category?: string;
+};
+export type ResourceBreakdownOptions = {
+	since?: string;
+	until?: string;
+};
+declare class ResourcesClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	getSummary(): Promise<ResourceSummaryResponse>;
+	getConsumption(appId: string): Promise<ResourceConsumptionResponse>;
+	getHistory(appId: string, days?: number): Promise<ResourceHistoryResponse>;
+	getLedger(appId: string, options?: ResourceLedgerOptions): Promise<ResourceLedgerResponse>;
+	getStatus(appId: string, dailyLimit?: number): Promise<ResourceStatusResponse>;
+	getBreakdown(appId: string, options?: ResourceBreakdownOptions): Promise<ResourceBreakdownResponse>;
+	listNodes(): Promise<ResourceNodesResponse>;
+	getNode(nodeId: string): Promise<ResourceNodeResponse>;
+}
+export type EncryptedEnvelope = {
+	v: 1;
+	alg: "aes-256-gcm";
+	kek: number;
+	mg: number;
+	ct: string;
+	n: string;
+	ts: string;
+};
+export type EncryptRequest = {
+	appId: string;
+	kekVersion: number;
+	plaintext: string;
+	masterGeneration?: number;
+};
+export type EncryptResponse = {
+	envelope: EncryptedEnvelope;
+};
+export type DecryptRequest = {
+	appId: string;
+	envelope: EncryptedEnvelope;
+};
+export type DecryptResponse = {
+	plaintext: string;
+};
+declare class EnvelopeClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	encrypt(request: EncryptRequest): Promise<EncryptResponse>;
+	decrypt(request: DecryptRequest): Promise<DecryptResponse>;
+}
+export type TokenMigrationChain = "hedera" | "xrpl" | "stellar";
+export type TokenMigrationStatusValue = "pending" | "in_progress" | "completed" | "failed";
+export type TokenMigrationRequest = {
+	chain: TokenMigrationChain;
+	tokenId: string;
+	currentAdminKey: string;
+	currentSupplyKey?: string;
+	payerAccountId?: string;
+};
+export type TokenMigrationResponse = {
+	migrationId: string;
+	success: boolean;
+	newAdminKey?: string;
+	newSupplyKey?: string;
+	entityId?: string;
+	txId?: string;
+	error?: string;
+};
+export type TokenMigrationStatus = {
+	migrationId: string;
+	chain: TokenMigrationChain;
+	tokenId: string;
+	status: TokenMigrationStatusValue;
+	progress: number;
+	currentStep: string;
+	error?: string;
+	startedAt: string | Date;
+	completedAt?: string | Date;
+	result?: TokenMigrationResponse;
+};
+export type ListMigrationsResponse = {
+	migrations: TokenMigrationStatus[];
+	count: number;
+};
+export type TokenMigrationsForTokenResponse = {
+	tokenId: string;
+	migrations: TokenMigrationStatus[];
+	count: number;
+};
+export type TokenDetailsResponse = {
+	chain: string;
+	tokenId: string;
+	name?: string;
+	symbol?: string;
+	totalSupply?: string;
+	adminKey?: string | null;
+	supplyKey?: string | null;
+	tssControlled?: boolean;
+	entityId?: string;
+	message?: string;
+};
+declare class TokensClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	migrate(request: TokenMigrationRequest): Promise<TokenMigrationResponse>;
+	listMigrations(): Promise<ListMigrationsResponse>;
+	getMigration(migrationId: string): Promise<TokenMigrationStatus | {
+		error: string;
+	}>;
+	getMigrationsForToken(tokenId: string): Promise<TokenMigrationsForTokenResponse>;
+	getDetails(chain: string, tokenId: string): Promise<TokenDetailsResponse>;
+}
+export type OperatorChain = "hedera";
+export type OperatorTokenBalance = {
+	tokenId: string;
+	balance: string;
+	decimals?: number;
+};
+export type OperatorBalanceResponse = {
+	accountId: string;
+	chain: OperatorChain;
+	hbarBalance: string;
+	tokenBalances: OperatorTokenBalance[];
+};
+export type OperatorTopUpResponse = {
+	accountId: string;
+	chain: OperatorChain;
+	minimumRecommended: string;
+	currentBalance: string;
+	needsTopUp: boolean;
+	instructions: string;
+	explorerUrl: string;
+};
+declare class OperatorClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	getBalance(chain: OperatorChain, accountId: string): Promise<OperatorBalanceResponse>;
+	getTopup(chain: OperatorChain, accountId: string): Promise<OperatorTopUpResponse>;
 }
 export interface SmartEngineClientConfig {
 	baseUrl: string;
@@ -2033,9 +4022,16 @@ declare class SmartEngineClient {
 	readonly historicalBalance: HistoricalBalanceClient;
 	readonly settlement: SettlementClient;
 	readonly governance: GovernanceClient;
+	readonly dao: DaoClient;
 	readonly personhood: PersonhoodClient;
 	readonly agents: AgentsClient;
 	readonly deployments: DeploymentClient;
+	readonly bridge: BridgeClient;
+	readonly resources: ResourcesClient;
+	readonly envelope: EnvelopeClient;
+	readonly tokens: TokensClient;
+	readonly operator: OperatorClient;
+	readonly discovery: DiscoveryClient;
 	constructor(config: SmartEngineClientConfig);
 	static fromEnv(env: Record<string, string | undefined>): SmartEngineClient;
 	static connectToNetwork(config: NetworkConnectionConfig): Promise<NetworkConnectionResult>;
@@ -2127,106 +4123,253 @@ declare class SmartEngineClient {
 	}>;
 }
 export type GatewayHealthResponse = {
-	status: "healthy" | "degraded" | "unhealthy";
+	status: "ok";
 	timestamp: string;
 	uptime: number;
 	version: string;
+	gatewayId: string;
 };
 export type GatewayStatusResponse = {
 	status: string;
-	hosts: {
-		total: number;
-		verified: number;
-		active: number;
+	timestamp: string;
+	uptime: number;
+	gatewayId: string;
+	version: string;
+	mode: {
+		strictVerification: boolean;
+		dnssecEnabled: boolean;
+		routingStrategy: string;
 	};
-	domains: {
-		total: number;
-		verified: number;
+	subsystems: {
+		dns: {
+			status: string;
+			cacheEnabled: boolean;
+			cacheSize: number;
+			maxCacheSize: number;
+			cacheUtilization: number;
+		};
+		routing: {
+			status: string;
+			strategy: string;
+			totalHosts: number;
+			verifiedHosts: number;
+			healthyHosts: number;
+		};
+		verification: {
+			status: string;
+			[key: string]: unknown;
+		};
 	};
-	uptime: number;
 };
 export type GatewayReadinessResponse = {
-	ready: boolean;
-	checks: Record<string, boolean>;
+	status: "ready";
+	timestamp: string;
+	verifiedHostsCount: number;
+} | {
+	status: "not_ready";
+	timestamp: string;
+	reason: string;
 };
 export type GatewayLivenessResponse = {
-	alive: boolean;
+	status: "alive";
 	timestamp: string;
+	uptime: number;
 };
 export type GatewayMetricsResponse = {
-	requests: {
-		total: number;
-		successful: number;
-		failed: number;
-		avgLatencyMs: number;
+	timestamp: string;
+	network: {
+		status: "operational" | "degraded" | "down";
+		totalClusters: number;
+		healthyClusters: number;
+		totalValidators: number;
+		activeValidators: number;
 	};
-	hosts: {
-		total: number;
-		healthy: number;
-		unhealthy: number;
+	gateway: {
+		version: string;
+		uptimeSeconds: number;
+		totalHosts: number;
+		verifiedHosts: number;
+		healthyHosts: number;
 	};
-	bandwidth: {
-		inbound: number;
-		outbound: number;
+	chains: {
+		hedera: {
+			connectedNodes: number;
+			totalNodes: number;
+			network: string | null;
+		};
+		xrpl: {
+			connectedNodes: number;
+			totalNodes: number;
+			network: string | null;
+		};
 	};
-	timestamp: string;
+	genesis: {
+		status: "pending" | "in_progress" | "completed" | "unknown";
+		completedClusters: number;
+		totalClusters: number;
+	};
+	clusters: ClusterHealth[];
+	cacheTtlSeconds: number;
+	gossipDiscovery?: {
+		enabled: boolean;
+		[key: string]: unknown;
+	};
+};
+export type ClusterHealth = {
+	clusterId: string;
+	clusterName: string;
+	status: "healthy" | "degraded" | "unhealthy" | "unreachable";
+	gateway: {
+		status: "up" | "down";
+		uptimeSeconds: number;
+	};
+	validator: {
+		status: "up" | "down" | "unknown";
+		responseTimeMs: number | null;
+		version: string | null;
+	};
+	host: {
+		status: "up" | "down" | "unknown";
+		responseTimeMs: number | null;
+	};
+	chains: {
+		hedera: {
+			connected: boolean;
+			network: string | null;
+		};
+		xrpl: {
+			connected: boolean;
+			network: string | null;
+		};
+	};
+	genesis: {
+		status: "pending" | "in_progress" | "completed" | "failed" | "unknown";
+		completedChains: string[];
+	};
+	lastChecked: string;
 };
 export type GatewayMetricsSummaryResponse = {
-	summary: Record<string, unknown>;
-	period: string;
-	generatedAt: string;
+	timestamp: string;
+	status: "operational" | "degraded" | "down";
+	clusters: string;
+	validators: string;
+	hedera: "connected" | "disconnected";
+	xrpl: "connected" | "disconnected";
+	genesis: "pending" | "in_progress" | "completed" | "unknown";
+	version: string;
+};
+export type ClusterHealthAggregate = {
+	clusterId: string;
+	gateway: {
+		status: "up";
+		uptimeSeconds: number;
+		version: string;
+		gatewayId: string;
+	};
+	validator: {
+		status: "up" | "down";
+		version: string | null;
+		chains: Array<{
+			chain: string;
+			connected: boolean;
+			network?: string;
+			latency?: number;
+		}>;
+	};
+	host: {
+		status: "up" | "down";
+	};
+	genesis: {
+		bootstrap?: {
+			state?: string;
+		};
+		multiChain?: {
+			overall?: string;
+			implementedChains?: {
+				completed?: number;
+			};
+			queueSummary?: unknown;
+		};
+	};
+	lastChecked: string;
 };
 export type RegisterHostRequest = {
-	name: string;
-	endpoint: string;
-	capabilities?: string[];
-	metadata?: Record<string, unknown>;
+	appId: string;
+	address: string;
+	port: number;
+	weight?: number;
+	region?: string;
+	metadata?: Record<string, string>;
 };
 export type HostInfo = {
-	hostId: string;
-	name: string;
-	endpoint: string;
-	status: "active" | "inactive" | "suspended";
+	id: string;
+	address: string;
+	port: number;
+	weight?: number;
+	region?: string;
 	verified: boolean;
-	capabilities: string[];
-	lastSeen: string;
+	verifiedAt?: string;
+	verificationExpires?: string;
+	attestationScore?: number;
+	healthStatus?: "healthy" | "unhealthy" | "unknown";
+	lastHealthCheck?: string;
+	responseTime?: number;
+	activeConnections?: number;
+	successfulChecks?: number;
+	failedChecks?: number;
 	registeredAt: string;
-	metadata?: Record<string, unknown>;
+};
+export type RegisterHostResponse = {
+	success: boolean;
+	host: {
+		id: string;
+		address: string;
+		port: number;
+		verified: boolean;
+		healthStatus?: string;
+		registeredAt: string;
+	};
+	message: string;
 };
 export type HostListResponse = {
+	count: number;
 	hosts: HostInfo[];
-	total: number;
 };
 export type RoutingConfig = {
-	strategy: "round-robin" | "least-connections" | "random" | "weighted";
+	hosts?: string[];
+	loadBalancing?: "round-robin" | "weighted" | "least-connections" | "random" | "ip-hash";
+	redundantExecution?: boolean;
+	minHosts?: number;
 	healthCheckInterval?: number;
-	timeout?: number;
-	retries?: number;
-	weights?: Record<string, number>;
+	healthCheckPath?: string;
 };
 export type ProxyRequest = {
-	targetHostId?: string;
-	method: string;
+	host: string;
 	path: string;
+	method: string;
 	headers?: Record<string, string>;
 	body?: unknown;
 };
 export type ProxyResponse = {
-	statusCode: number;
-	headers: Record<string, string>;
-	body: unknown;
-	hostId: string;
-	latencyMs: number;
+	success: boolean;
+	data: unknown;
+	meta: {
+		hostId: string;
+		responseTime: number;
+		routingStrategy: string;
+	};
 };
 export type RoutingStatsResponse = {
-	totalRequests: number;
-	successRate: number;
-	avgLatencyMs: number;
-	hostStats: Record<string, {
-		requests: number;
-		errors: number;
-		avgLatencyMs: number;
-	}>;
+	timestamp: string;
+	strictMode: boolean;
+	defaultStrategy: string;
+	hosts: Record<string, unknown>;
+	verification: Record<string, unknown>;
+};
+export type MapDomainToAppResponse = {
+	domain: string;
+	appId: string;
+	message: string;
 };
 export type DomainRegistrationRequest = {
 	domain: string;
@@ -2256,21 +4399,21 @@ export type DomainAvailabilityResponse = {
 	price?: string;
 	suggestions?: string[];
 };
+export type VerificationMethod = "dns-txt" | "dns-cname" | "http-file" | "email";
 export type VerificationTokenResponse = {
+	domain: string;
+	method: VerificationMethod;
 	token: string;
-	method: "dns" | "http" | "email";
 	instructions: string;
-	expiresAt: string;
 };
 export type VerificationResult = {
-	verified: boolean;
 	domain: string;
-	method: string;
-	verifiedAt?: string;
-	error?: string;
+	verified: boolean;
+	message: string;
 };
+export type DnsRecordType = "A" | "AAAA" | "CNAME" | "TXT" | "MX" | "NS" | "SOA" | "SRV" | "CAA" | "DNSKEY" | "DS" | "RRSIG" | "NSEC" | "NSEC3";
 export type DnsRecord = {
-	type: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS" | "SRV" | "CAA";
+	type: DnsRecordType;
 	name: string;
 	value: string;
 	ttl?: number;
@@ -2340,26 +4483,30 @@ export type DnssecDsRecord = {
 declare class RoutingClient {
 	private readonly http;
 	constructor(http: HttpClient);
-	registerHost(request: RegisterHostRequest): Promise<HostInfo>;
+	registerHost(request: RegisterHostRequest): Promise<RegisterHostResponse>;
 	unregisterHost(hostId: string): Promise<{
 		success: boolean;
+		message: string;
 	}>;
 	getAllHosts(): Promise<HostListResponse>;
 	getVerifiedHosts(): Promise<HostListResponse>;
 	getHost(hostId: string): Promise<HostInfo>;
 	verifyHost(hostId: string): Promise<{
+		success: boolean;
+		hostId: string;
 		verified: boolean;
+		attestationScore?: number;
 		message: string;
 	}>;
-	setRoutingConfig(appId: string, config: RoutingConfig): Promise<RoutingConfig>;
-	getRoutingConfig(appId: string): Promise<RoutingConfig>;
-	proxyRequest(request: ProxyRequest): Promise<ProxyResponse>;
-	getStats(): Promise<RoutingStatsResponse>;
-	mapDomainToApp(domain: string, appId: string): Promise<{
+	setRoutingConfig(appId: string, config: RoutingConfig): Promise<{
 		success: boolean;
-		domain: string;
 		appId: string;
+		message: string;
 	}>;
+	getRoutingConfig(appId: string): Promise<RoutingConfig>;
+	proxyRequest(request: ProxyRequest): Promise<ProxyResponse>;
+	getStats(): Promise<RoutingStatsResponse>;
+	mapDomainToApp(domain: string, appId: string): Promise<MapDomainToAppResponse>;
 }
 declare class DomainsClient {
 	private readonly http;
@@ -2368,7 +4515,7 @@ declare class DomainsClient {
 	checkAvailability(domain: string): Promise<DomainAvailabilityResponse>;
 	getInfo(domain: string): Promise<DomainInfo>;
 	list(owner?: string): Promise<DomainListResponse>;
-	generateVerificationToken(domain: string, method: "dns" | "http" | "email"): Promise<VerificationTokenResponse>;
+	generateVerificationToken(domain: string, method: VerificationMethod): Promise<VerificationTokenResponse>;
 	verifyOwnership(domain: string, token: string): Promise<VerificationResult>;
 	configureDns(domain: string, records: DnsRecord[]): Promise<{
 		success: boolean;
@@ -2433,6 +4580,11 @@ declare class DnsClient {
 		entriesCleared: number;
 	}>;
 }
+declare class HealthClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	getCluster(): Promise<ClusterHealthAggregate>;
+}
 export type SmartGatewayClientConfig = {
 	baseUrl: string;
 	apiKey?: string;
@@ -2445,6 +4597,7 @@ declare class SmartGatewayClient {
 	readonly routing: RoutingClient;
 	readonly domains: DomainsClient;
 	readonly dns: DnsClient;
+	readonly health: HealthClient;
 	constructor(config: SmartGatewayClientConfig);
 	getHealth(): Promise<GatewayHealthResponse>;
 	getStatus(): Promise<GatewayStatusResponse>;
@@ -2489,6 +4642,13 @@ declare class DatabaseClient {
 	listCollections(): Promise<{
 		collections: string[];
 	}>;
+	createCollection(name: string): Promise<{
+		success: boolean;
+		collection: string;
+	}>;
+	dropCollection(name: string): Promise<{
+		success: boolean;
+	}>;
 	getStateRoot(): Promise<StateRootResponse>;
 	getDocumentProof(documentId: string): Promise<DocumentProofResponse>;
 	getStateTransitions(options?: {
@@ -2511,7 +4671,7 @@ declare class StorageClient {
 	getFile(cid: string): Promise<BaasFileInfo>;
 	listFiles(pagination?: {
 		limit?: number;
-		skip?: number;
+		offset?: number;
 	}): Promise<{
 		files: BaasFileInfo[];
 		total: number;
@@ -2569,10 +4729,10 @@ declare class MessagingClient {
 		total: number;
 		hasMore: boolean;
 	}>;
-	setPresence(member: BaasPresenceMember): Promise<{
+	setPresence(channel: string, member: BaasPresenceMember): Promise<{
 		success: boolean;
 	}>;
-	removePresence(memberId: string): Promise<{
+	removePresence(channel: string, clientId: string): Promise<{
 		success: boolean;
 	}>;
 	getPresence(channel: string): Promise<BaasPresenceInfo>;