@ghostspeak/sdk 2.0.6 → 2.0.8

package/dist/chunk-5QZVFUXB.js

@@ -0,0 +1,4176 @@
+import { getStructEncoder, getBooleanEncoder, getI64Encoder, getStructDecoder, getBooleanDecoder, getI64Decoder, combineCodec, addEncoderSizePrefix, getArrayEncoder, getU8Encoder, getOptionEncoder, getUtf8Encoder, getU32Encoder, addDecoderSizePrefix, getArrayDecoder, getU8Decoder, getOptionDecoder, getUtf8Decoder, getU32Decoder, getEnumEncoder, getEnumDecoder, getAddressEncoder, getAddressDecoder, getU64Encoder, getU64Decoder, getDiscriminatedUnionEncoder, getDiscriminatedUnionDecoder, fixEncoderSize, getBytesEncoder, fixDecoderSize, getBytesDecoder, getUnitEncoder, getTupleEncoder, getUnitDecoder, getTupleDecoder, getU16Encoder, getU16Decoder, getF64Encoder, getF64Decoder, transformEncoder, decodeAccount, assertAccountExists, fetchEncodedAccount, assertAccountsExist, fetchEncodedAccounts } from '@solana/kit';
+
+// src/generated/accounts/agent.ts
+function getAccessAuditConfigEncoder() {
+  return getStructEncoder([
+    ["auditEnabled", getBooleanEncoder()],
+    ["realTimeMonitoring", getBooleanEncoder()],
+    ["retentionPeriod", getI64Encoder()]
+  ]);
+}
+function getAccessAuditConfigDecoder() {
+  return getStructDecoder([
+    ["auditEnabled", getBooleanDecoder()],
+    ["realTimeMonitoring", getBooleanDecoder()],
+    ["retentionPeriod", getI64Decoder()]
+  ]);
+}
+function getAccessAuditConfigCodec() {
+  return combineCodec(
+    getAccessAuditConfigEncoder(),
+    getAccessAuditConfigDecoder()
+  );
+}
+function getAccessPolicyEncoder() {
+  return getStructEncoder([
+    ["policyId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["policyType", getPolicyTypeEncoder()],
+    ["rules", getArrayEncoder(getPolicyRuleEncoder())],
+    ["scope", getPolicyScopeEncoder()],
+    ["priority", getU8Encoder()],
+    ["status", getPolicyStatusEncoder()],
+    ["effectiveDate", getI64Encoder()],
+    ["expirationDate", getOptionEncoder(getI64Encoder())],
+    ["metadata", getPolicyMetadataEncoder()]
+  ]);
+}
+function getAccessPolicyDecoder() {
+  return getStructDecoder([
+    ["policyId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["policyType", getPolicyTypeDecoder()],
+    ["rules", getArrayDecoder(getPolicyRuleDecoder())],
+    ["scope", getPolicyScopeDecoder()],
+    ["priority", getU8Decoder()],
+    ["status", getPolicyStatusDecoder()],
+    ["effectiveDate", getI64Decoder()],
+    ["expirationDate", getOptionDecoder(getI64Decoder())],
+    ["metadata", getPolicyMetadataDecoder()]
+  ]);
+}
+function getAccessPolicyCodec() {
+  return combineCodec(getAccessPolicyEncoder(), getAccessPolicyDecoder());
+}
+var AccessTier = /* @__PURE__ */ ((AccessTier2) => {
+  AccessTier2[AccessTier2["None"] = 0] = "None";
+  AccessTier2[AccessTier2["Basic"] = 1] = "Basic";
+  AccessTier2[AccessTier2["Verified"] = 2] = "Verified";
+  AccessTier2[AccessTier2["Pro"] = 3] = "Pro";
+  AccessTier2[AccessTier2["Whale"] = 4] = "Whale";
+  return AccessTier2;
+})(AccessTier || {});
+function getAccessTierEncoder() {
+  return getEnumEncoder(AccessTier);
+}
+function getAccessTierDecoder() {
+  return getEnumDecoder(AccessTier);
+}
+function getAccessTierCodec() {
+  return combineCodec(getAccessTierEncoder(), getAccessTierDecoder());
+}
+function getActionEncoder() {
+  return getStructEncoder([
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getActionDecoder() {
+  return getStructDecoder([
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getActionCodec() {
+  return combineCodec(getActionEncoder(), getActionDecoder());
+}
+function getAccountLockoutPoliciesEncoder() {
+  return getStructEncoder([
+    ["maxFailedAttempts", getU8Encoder()],
+    ["lockoutDuration", getI64Encoder()],
+    ["progressiveLockout", getBooleanEncoder()],
+    ["unlockMethods", getArrayEncoder(getUnlockMethodEncoder())],
+    [
+      "notificationRequirements",
+      getArrayEncoder(getNotificationRequirementEncoder())
+    ]
+  ]);
+}
+function getAccountLockoutPoliciesDecoder() {
+  return getStructDecoder([
+    ["maxFailedAttempts", getU8Decoder()],
+    ["lockoutDuration", getI64Decoder()],
+    ["progressiveLockout", getBooleanDecoder()],
+    ["unlockMethods", getArrayDecoder(getUnlockMethodDecoder())],
+    [
+      "notificationRequirements",
+      getArrayDecoder(getNotificationRequirementDecoder())
+    ]
+  ]);
+}
+function getAccountLockoutPoliciesCodec() {
+  return combineCodec(
+    getAccountLockoutPoliciesEncoder(),
+    getAccountLockoutPoliciesDecoder()
+  );
+}
+function getActivationRequirementEncoder() {
+  return getStructEncoder([
+    ["requirementType", getActivationRequirementTypeEncoder()],
+    ["approvers", getArrayEncoder(getAddressEncoder())],
+    ["minApprovals", getU8Encoder()],
+    ["approvalTimeout", getI64Encoder()],
+    [
+      "evidenceRequirements",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getActivationRequirementDecoder() {
+  return getStructDecoder([
+    ["requirementType", getActivationRequirementTypeDecoder()],
+    ["approvers", getArrayDecoder(getAddressDecoder())],
+    ["minApprovals", getU8Decoder()],
+    ["approvalTimeout", getI64Decoder()],
+    [
+      "evidenceRequirements",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getActivationRequirementCodec() {
+  return combineCodec(
+    getActivationRequirementEncoder(),
+    getActivationRequirementDecoder()
+  );
+}
+var ActivationRequirementType = /* @__PURE__ */ ((ActivationRequirementType2) => {
+  ActivationRequirementType2[ActivationRequirementType2["ManagerApproval"] = 0] = "ManagerApproval";
+  ActivationRequirementType2[ActivationRequirementType2["PeerReview"] = 1] = "PeerReview";
+  ActivationRequirementType2[ActivationRequirementType2["SecurityClearance"] = 2] = "SecurityClearance";
+  ActivationRequirementType2[ActivationRequirementType2["BackgroundCheck"] = 3] = "BackgroundCheck";
+  ActivationRequirementType2[ActivationRequirementType2["TrainingCompletion"] = 4] = "TrainingCompletion";
+  ActivationRequirementType2[ActivationRequirementType2["CertificationRequired"] = 5] = "CertificationRequired";
+  ActivationRequirementType2[ActivationRequirementType2["BusinessJustification"] = 6] = "BusinessJustification";
+  ActivationRequirementType2[ActivationRequirementType2["TechnicalAssessment"] = 7] = "TechnicalAssessment";
+  return ActivationRequirementType2;
+})(ActivationRequirementType || {});
+function getActivationRequirementTypeEncoder() {
+  return getEnumEncoder(ActivationRequirementType);
+}
+function getActivationRequirementTypeDecoder() {
+  return getEnumDecoder(ActivationRequirementType);
+}
+function getActivationRequirementTypeCodec() {
+  return combineCodec(
+    getActivationRequirementTypeEncoder(),
+    getActivationRequirementTypeDecoder()
+  );
+}
+function getAgentRegisteredEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["owner", getAddressEncoder()],
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getAgentRegisteredEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getAgentRegisteredEventCodec() {
+  return combineCodec(
+    getAgentRegisteredEventEncoder(),
+    getAgentRegisteredEventDecoder()
+  );
+}
+function getAgentServiceUpdatedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["owner", getAddressEncoder()],
+    ["timestamp", getI64Encoder()],
+    [
+      "serviceEndpoint",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["isActive", getBooleanEncoder()]
+  ]);
+}
+function getAgentServiceUpdatedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["timestamp", getI64Decoder()],
+    [
+      "serviceEndpoint",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["isActive", getBooleanDecoder()]
+  ]);
+}
+function getAgentServiceUpdatedEventCodec() {
+  return combineCodec(
+    getAgentServiceUpdatedEventEncoder(),
+    getAgentServiceUpdatedEventDecoder()
+  );
+}
+var AgentStatus = /* @__PURE__ */ ((AgentStatus2) => {
+  AgentStatus2[AgentStatus2["Unregistered"] = 0] = "Unregistered";
+  AgentStatus2[AgentStatus2["Registered"] = 1] = "Registered";
+  AgentStatus2[AgentStatus2["Claimed"] = 2] = "Claimed";
+  AgentStatus2[AgentStatus2["Verified"] = 3] = "Verified";
+  return AgentStatus2;
+})(AgentStatus || {});
+function getAgentStatusEncoder() {
+  return getEnumEncoder(AgentStatus);
+}
+function getAgentStatusDecoder() {
+  return getEnumDecoder(AgentStatus);
+}
+function getAgentStatusCodec() {
+  return combineCodec(getAgentStatusEncoder(), getAgentStatusDecoder());
+}
+function getAgentStatusChangedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["previousStatus", getBooleanEncoder()],
+    ["newStatus", getBooleanEncoder()],
+    ["timestamp", getI64Encoder()],
+    ["authority", getAddressEncoder()]
+  ]);
+}
+function getAgentStatusChangedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["previousStatus", getBooleanDecoder()],
+    ["newStatus", getBooleanDecoder()],
+    ["timestamp", getI64Decoder()],
+    ["authority", getAddressDecoder()]
+  ]);
+}
+function getAgentStatusChangedEventCodec() {
+  return combineCodec(
+    getAgentStatusChangedEventEncoder(),
+    getAgentStatusChangedEventDecoder()
+  );
+}
+function getAgentUpdatedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["owner", getAddressEncoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getAgentUpdatedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getAgentUpdatedEventCodec() {
+  return combineCodec(
+    getAgentUpdatedEventEncoder(),
+    getAgentUpdatedEventDecoder()
+  );
+}
+function getAgentVerificationDataEncoder() {
+  return getStructEncoder([
+    ["agentPubkey", getAddressEncoder()],
+    [
+      "serviceEndpoint",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["supportedCapabilities", getArrayEncoder(getU64Encoder())],
+    ["verifiedAt", getI64Encoder()]
+  ]);
+}
+function getAgentVerificationDataDecoder() {
+  return getStructDecoder([
+    ["agentPubkey", getAddressDecoder()],
+    [
+      "serviceEndpoint",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["supportedCapabilities", getArrayDecoder(getU64Decoder())],
+    ["verifiedAt", getI64Decoder()]
+  ]);
+}
+function getAgentVerificationDataCodec() {
+  return combineCodec(
+    getAgentVerificationDataEncoder(),
+    getAgentVerificationDataDecoder()
+  );
+}
+function getAgingPolicyEncoder() {
+  return getStructEncoder([
+    ["biometricType", getBiometricTypeEncoder()],
+    ["maxAge", getI64Encoder()],
+    [
+      "refreshRequirements",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["degradationHandling", getDegradationHandlingEncoder()]
+  ]);
+}
+function getAgingPolicyDecoder() {
+  return getStructDecoder([
+    ["biometricType", getBiometricTypeDecoder()],
+    ["maxAge", getI64Decoder()],
+    [
+      "refreshRequirements",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["degradationHandling", getDegradationHandlingDecoder()]
+  ]);
+}
+function getAgingPolicyCodec() {
+  return combineCodec(getAgingPolicyEncoder(), getAgingPolicyDecoder());
+}
+function getApprovalLevelEncoder() {
+  return getStructEncoder([
+    ["actionType", getAuditActionEncoder()],
+    ["requiredApprovers", getArrayEncoder(getAddressEncoder())],
+    ["minApprovals", getU8Encoder()],
+    ["approvalTimeout", getI64Encoder()]
+  ]);
+}
+function getApprovalLevelDecoder() {
+  return getStructDecoder([
+    ["actionType", getAuditActionDecoder()],
+    ["requiredApprovers", getArrayDecoder(getAddressDecoder())],
+    ["minApprovals", getU8Decoder()],
+    ["approvalTimeout", getI64Decoder()]
+  ]);
+}
+function getApprovalLevelCodec() {
+  return combineCodec(getApprovalLevelEncoder(), getApprovalLevelDecoder());
+}
+function getArbitratorDecisionEncoder() {
+  return getDiscriminatedUnionEncoder([
+    [
+      "FavorClient",
+      getStructEncoder([
+        ["reason", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+      ])
+    ],
+    [
+      "FavorAgent",
+      getStructEncoder([
+        ["reason", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+      ])
+    ],
+    [
+      "Split",
+      getStructEncoder([
+        ["clientPercentage", getU8Encoder()],
+        ["reason", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+      ])
+    ]
+  ]);
+}
+function getArbitratorDecisionDecoder() {
+  return getDiscriminatedUnionDecoder([
+    [
+      "FavorClient",
+      getStructDecoder([
+        ["reason", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+      ])
+    ],
+    [
+      "FavorAgent",
+      getStructDecoder([
+        ["reason", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+      ])
+    ],
+    [
+      "Split",
+      getStructDecoder([
+        ["clientPercentage", getU8Decoder()],
+        ["reason", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+      ])
+    ]
+  ]);
+}
+function getArbitratorDecisionCodec() {
+  return combineCodec(
+    getArbitratorDecisionEncoder(),
+    getArbitratorDecisionDecoder()
+  );
+}
+function arbitratorDecision(kind, data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
+}
+function isArbitratorDecision(kind, value) {
+  return value.__kind === kind;
+}
+var AuditAction = /* @__PURE__ */ ((AuditAction2) => {
+  AuditAction2[AuditAction2["AgentRegistered"] = 0] = "AgentRegistered";
+  AuditAction2[AuditAction2["AgentUpdated"] = 1] = "AgentUpdated";
+  AuditAction2[AuditAction2["AgentDeactivated"] = 2] = "AgentDeactivated";
+  AuditAction2[AuditAction2["AgentVerified"] = 3] = "AgentVerified";
+  AuditAction2[AuditAction2["PaymentProcessed"] = 4] = "PaymentProcessed";
+  AuditAction2[AuditAction2["EscrowCreated"] = 5] = "EscrowCreated";
+  AuditAction2[AuditAction2["EscrowReleased"] = 6] = "EscrowReleased";
+  AuditAction2[AuditAction2["FundsWithdrawn"] = 7] = "FundsWithdrawn";
+  AuditAction2[AuditAction2["ProposalCreated"] = 8] = "ProposalCreated";
+  AuditAction2[AuditAction2["VoteCast"] = 9] = "VoteCast";
+  AuditAction2[AuditAction2["ProposalExecuted"] = 10] = "ProposalExecuted";
+  AuditAction2[AuditAction2["GovernanceUpdated"] = 11] = "GovernanceUpdated";
+  AuditAction2[AuditAction2["AccessGranted"] = 12] = "AccessGranted";
+  AuditAction2[AuditAction2["AccessRevoked"] = 13] = "AccessRevoked";
+  AuditAction2[AuditAction2["SecurityPolicyUpdated"] = 14] = "SecurityPolicyUpdated";
+  AuditAction2[AuditAction2["SuspiciousActivity"] = 15] = "SuspiciousActivity";
+  AuditAction2[AuditAction2["ComplianceReportGenerated"] = 16] = "ComplianceReportGenerated";
+  AuditAction2[AuditAction2["RegulatorySubmission"] = 17] = "RegulatorySubmission";
+  AuditAction2[AuditAction2["AuditRequested"] = 18] = "AuditRequested";
+  AuditAction2[AuditAction2["ViolationDetected"] = 19] = "ViolationDetected";
+  AuditAction2[AuditAction2["SystemConfigUpdated"] = 20] = "SystemConfigUpdated";
+  AuditAction2[AuditAction2["EmergencyAction"] = 21] = "EmergencyAction";
+  AuditAction2[AuditAction2["MaintenancePerformed"] = 22] = "MaintenancePerformed";
+  AuditAction2[AuditAction2["WorkOrderCreated"] = 23] = "WorkOrderCreated";
+  AuditAction2[AuditAction2["WorkOrderCompleted"] = 24] = "WorkOrderCompleted";
+  AuditAction2[AuditAction2["DisputeRaised"] = 25] = "DisputeRaised";
+  AuditAction2[AuditAction2["DisputeResolved"] = 26] = "DisputeResolved";
+  AuditAction2[AuditAction2["MultisigCreated"] = 27] = "MultisigCreated";
+  AuditAction2[AuditAction2["MultisigSigned"] = 28] = "MultisigSigned";
+  AuditAction2[AuditAction2["MultisigExecuted"] = 29] = "MultisigExecuted";
+  AuditAction2[AuditAction2["RiskAssessmentPerformed"] = 30] = "RiskAssessmentPerformed";
+  AuditAction2[AuditAction2["RiskThresholdExceeded"] = 31] = "RiskThresholdExceeded";
+  AuditAction2[AuditAction2["RiskMitigationApplied"] = 32] = "RiskMitigationApplied";
+  return AuditAction2;
+})(AuditAction || {});
+function getAuditActionEncoder() {
+  return getEnumEncoder(AuditAction);
+}
+function getAuditActionDecoder() {
+  return getEnumDecoder(AuditAction);
+}
+function getAuditActionCodec() {
+  return combineCodec(getAuditActionEncoder(), getAuditActionDecoder());
+}
+function getAuditConfigEncoder() {
+  return getStructEncoder([
+    ["maxEntries", getU32Encoder()],
+    ["retentionPeriod", getI64Encoder()],
+    ["autoArchive", getBooleanEncoder()],
+    ["reportingFrequency", getReportingFrequencyEncoder()],
+    ["approvalLevels", getArrayEncoder(getApprovalLevelEncoder())],
+    ["encryptionRequired", getBooleanEncoder()],
+    ["backupFrequency", getBackupFrequencyEncoder()]
+  ]);
+}
+function getAuditConfigDecoder() {
+  return getStructDecoder([
+    ["maxEntries", getU32Decoder()],
+    ["retentionPeriod", getI64Decoder()],
+    ["autoArchive", getBooleanDecoder()],
+    ["reportingFrequency", getReportingFrequencyDecoder()],
+    ["approvalLevels", getArrayDecoder(getApprovalLevelDecoder())],
+    ["encryptionRequired", getBooleanDecoder()],
+    ["backupFrequency", getBackupFrequencyDecoder()]
+  ]);
+}
+function getAuditConfigCodec() {
+  return combineCodec(getAuditConfigEncoder(), getAuditConfigDecoder());
+}
+function getAuditContextEncoder() {
+  return getStructEncoder([
+    ["metadata", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getAuditContextDecoder() {
+  return getStructDecoder([
+    ["metadata", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getAuditContextCodec() {
+  return combineCodec(getAuditContextEncoder(), getAuditContextDecoder());
+}
+function getAuditEntryEncoder() {
+  return getStructEncoder([
+    ["entryId", getU64Encoder()],
+    ["timestamp", getI64Encoder()],
+    ["action", getAuditActionEncoder()],
+    ["actor", getAddressEncoder()],
+    ["target", getOptionEncoder(getAddressEncoder())],
+    ["context", getAuditContextEncoder()],
+    ["complianceFlags", getComplianceFlagsEncoder()],
+    ["previousHash", fixEncoderSize(getBytesEncoder(), 32)],
+    ["entryHash", fixEncoderSize(getBytesEncoder(), 32)],
+    ["signature", getOptionEncoder(fixEncoderSize(getBytesEncoder(), 64))]
+  ]);
+}
+function getAuditEntryDecoder() {
+  return getStructDecoder([
+    ["entryId", getU64Decoder()],
+    ["timestamp", getI64Decoder()],
+    ["action", getAuditActionDecoder()],
+    ["actor", getAddressDecoder()],
+    ["target", getOptionDecoder(getAddressDecoder())],
+    ["context", getAuditContextDecoder()],
+    ["complianceFlags", getComplianceFlagsDecoder()],
+    ["previousHash", fixDecoderSize(getBytesDecoder(), 32)],
+    ["entryHash", fixDecoderSize(getBytesDecoder(), 32)],
+    ["signature", getOptionDecoder(fixDecoderSize(getBytesDecoder(), 64))]
+  ]);
+}
+function getAuditEntryCodec() {
+  return combineCodec(getAuditEntryEncoder(), getAuditEntryDecoder());
+}
+function getAuditTrailInitializedEventEncoder() {
+  return getStructEncoder([
+    ["entity", getAddressEncoder()],
+    ["entityType", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getAuditTrailInitializedEventDecoder() {
+  return getStructDecoder([
+    ["entity", getAddressDecoder()],
+    ["entityType", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getAuditTrailInitializedEventCodec() {
+  return combineCodec(
+    getAuditTrailInitializedEventEncoder(),
+    getAuditTrailInitializedEventDecoder()
+  );
+}
+var AuthenticationLevel = /* @__PURE__ */ ((AuthenticationLevel2) => {
+  AuthenticationLevel2[AuthenticationLevel2["Low"] = 0] = "Low";
+  AuthenticationLevel2[AuthenticationLevel2["Medium"] = 1] = "Medium";
+  AuthenticationLevel2[AuthenticationLevel2["High"] = 2] = "High";
+  AuthenticationLevel2[AuthenticationLevel2["VeryHigh"] = 3] = "VeryHigh";
+  return AuthenticationLevel2;
+})(AuthenticationLevel || {});
+function getAuthenticationLevelEncoder() {
+  return getEnumEncoder(AuthenticationLevel);
+}
+function getAuthenticationLevelDecoder() {
+  return getEnumDecoder(AuthenticationLevel);
+}
+function getAuthenticationLevelCodec() {
+  return combineCodec(
+    getAuthenticationLevelEncoder(),
+    getAuthenticationLevelDecoder()
+  );
+}
+var AuthenticationMethod = /* @__PURE__ */ ((AuthenticationMethod2) => {
+  AuthenticationMethod2[AuthenticationMethod2["Password"] = 0] = "Password";
+  AuthenticationMethod2[AuthenticationMethod2["DigitalSignature"] = 1] = "DigitalSignature";
+  AuthenticationMethod2[AuthenticationMethod2["Biometric"] = 2] = "Biometric";
+  AuthenticationMethod2[AuthenticationMethod2["Token"] = 3] = "Token";
+  AuthenticationMethod2[AuthenticationMethod2["Certificate"] = 4] = "Certificate";
+  AuthenticationMethod2[AuthenticationMethod2["Sms"] = 5] = "Sms";
+  AuthenticationMethod2[AuthenticationMethod2["Email"] = 6] = "Email";
+  AuthenticationMethod2[AuthenticationMethod2["App"] = 7] = "App";
+  AuthenticationMethod2[AuthenticationMethod2["Hardware"] = 8] = "Hardware";
+  return AuthenticationMethod2;
+})(AuthenticationMethod || {});
+function getAuthenticationMethodEncoder() {
+  return getEnumEncoder(AuthenticationMethod);
+}
+function getAuthenticationMethodDecoder() {
+  return getEnumDecoder(AuthenticationMethod);
+}
+function getAuthenticationMethodCodec() {
+  return combineCodec(
+    getAuthenticationMethodEncoder(),
+    getAuthenticationMethodDecoder()
+  );
+}
+function getAuthenticationPoliciesEncoder() {
+  return getStructEncoder([
+    ["mfaRequired", getBooleanEncoder()],
+    ["supportedMethods", getArrayEncoder(getAuthenticationMethodEncoder())],
+    ["strengthRequirements", getAuthenticationStrengthEncoder()],
+    ["lockoutPolicies", getAccountLockoutPoliciesEncoder()],
+    ["biometricPolicies", getOptionEncoder(getBiometricPoliciesEncoder())]
+  ]);
+}
+function getAuthenticationPoliciesDecoder() {
+  return getStructDecoder([
+    ["mfaRequired", getBooleanDecoder()],
+    ["supportedMethods", getArrayDecoder(getAuthenticationMethodDecoder())],
+    ["strengthRequirements", getAuthenticationStrengthDecoder()],
+    ["lockoutPolicies", getAccountLockoutPoliciesDecoder()],
+    ["biometricPolicies", getOptionDecoder(getBiometricPoliciesDecoder())]
+  ]);
+}
+function getAuthenticationPoliciesCodec() {
+  return combineCodec(
+    getAuthenticationPoliciesEncoder(),
+    getAuthenticationPoliciesDecoder()
+  );
+}
+function getAuthenticationStrengthEncoder() {
+  return getStructEncoder([
+    ["minimumLevel", getAuthenticationLevelEncoder()],
+    ["riskBased", getBooleanEncoder()],
+    ["adaptive", getBooleanEncoder()],
+    ["stepUpTriggers", getArrayEncoder(getStepUpTriggerEncoder())]
+  ]);
+}
+function getAuthenticationStrengthDecoder() {
+  return getStructDecoder([
+    ["minimumLevel", getAuthenticationLevelDecoder()],
+    ["riskBased", getBooleanDecoder()],
+    ["adaptive", getBooleanDecoder()],
+    ["stepUpTriggers", getArrayDecoder(getStepUpTriggerDecoder())]
+  ]);
+}
+function getAuthenticationStrengthCodec() {
+  return combineCodec(
+    getAuthenticationStrengthEncoder(),
+    getAuthenticationStrengthDecoder()
+  );
+}
+function getAuthorizationPoliciesEncoder() {
+  return getStructEncoder([
+    ["defaultDeny", getBooleanEncoder()],
+    ["explicitPermissionsRequired", getBooleanEncoder()]
+  ]);
+}
+function getAuthorizationPoliciesDecoder() {
+  return getStructDecoder([
+    ["defaultDeny", getBooleanDecoder()],
+    ["explicitPermissionsRequired", getBooleanDecoder()]
+  ]);
+}
+function getAuthorizationPoliciesCodec() {
+  return combineCodec(
+    getAuthorizationPoliciesEncoder(),
+    getAuthorizationPoliciesDecoder()
+  );
+}
+var BackupFrequency = /* @__PURE__ */ ((BackupFrequency2) => {
+  BackupFrequency2[BackupFrequency2["Hourly"] = 0] = "Hourly";
+  BackupFrequency2[BackupFrequency2["Daily"] = 1] = "Daily";
+  BackupFrequency2[BackupFrequency2["Weekly"] = 2] = "Weekly";
+  BackupFrequency2[BackupFrequency2["Monthly"] = 3] = "Monthly";
+  return BackupFrequency2;
+})(BackupFrequency || {});
+function getBackupFrequencyEncoder() {
+  return getEnumEncoder(BackupFrequency);
+}
+function getBackupFrequencyDecoder() {
+  return getEnumDecoder(BackupFrequency);
+}
+function getBackupFrequencyCodec() {
+  return combineCodec(getBackupFrequencyEncoder(), getBackupFrequencyDecoder());
+}
+function getBiometricPoliciesEncoder() {
+  return getStructEncoder([
+    ["supportedTypes", getArrayEncoder(getBiometricTypeEncoder())],
+    ["qualityRequirements", getBiometricQualityEncoder()],
+    ["livenessDetection", getBooleanEncoder()],
+    ["templateProtection", getBiometricProtectionEncoder()]
+  ]);
+}
+function getBiometricPoliciesDecoder() {
+  return getStructDecoder([
+    ["supportedTypes", getArrayDecoder(getBiometricTypeDecoder())],
+    ["qualityRequirements", getBiometricQualityDecoder()],
+    ["livenessDetection", getBooleanDecoder()],
+    ["templateProtection", getBiometricProtectionDecoder()]
+  ]);
+}
+function getBiometricPoliciesCodec() {
+  return combineCodec(
+    getBiometricPoliciesEncoder(),
+    getBiometricPoliciesDecoder()
+  );
+}
+function getBiometricProtectionEncoder() {
+  return getStructEncoder([
+    ["encryptionRequired", getBooleanEncoder()],
+    ["storageMethod", getBiometricStorageMethodEncoder()],
+    ["revocationSupport", getBooleanEncoder()],
+    ["agingPolicies", getArrayEncoder(getAgingPolicyEncoder())]
+  ]);
+}
+function getBiometricProtectionDecoder() {
+  return getStructDecoder([
+    ["encryptionRequired", getBooleanDecoder()],
+    ["storageMethod", getBiometricStorageMethodDecoder()],
+    ["revocationSupport", getBooleanDecoder()],
+    ["agingPolicies", getArrayDecoder(getAgingPolicyDecoder())]
+  ]);
+}
+function getBiometricProtectionCodec() {
+  return combineCodec(
+    getBiometricProtectionEncoder(),
+    getBiometricProtectionDecoder()
+  );
+}
+function getBiometricQualityEncoder() {
+  return getStructEncoder([
+    ["score", getU8Encoder()]
+  ]);
+}
+function getBiometricQualityDecoder() {
+  return getStructDecoder([
+    ["score", getU8Decoder()]
+  ]);
+}
+function getBiometricQualityCodec() {
+  return combineCodec(getBiometricQualityEncoder(), getBiometricQualityDecoder());
+}
+var BiometricStorageMethod = /* @__PURE__ */ ((BiometricStorageMethod2) => {
+  BiometricStorageMethod2[BiometricStorageMethod2["OnDevice"] = 0] = "OnDevice";
+  BiometricStorageMethod2[BiometricStorageMethod2["Encrypted"] = 1] = "Encrypted";
+  BiometricStorageMethod2[BiometricStorageMethod2["Hashed"] = 2] = "Hashed";
+  BiometricStorageMethod2[BiometricStorageMethod2["Distributed"] = 3] = "Distributed";
+  BiometricStorageMethod2[BiometricStorageMethod2["None"] = 4] = "None";
+  return BiometricStorageMethod2;
+})(BiometricStorageMethod || {});
+function getBiometricStorageMethodEncoder() {
+  return getEnumEncoder(BiometricStorageMethod);
+}
+function getBiometricStorageMethodDecoder() {
+  return getEnumDecoder(BiometricStorageMethod);
+}
+function getBiometricStorageMethodCodec() {
+  return combineCodec(
+    getBiometricStorageMethodEncoder(),
+    getBiometricStorageMethodDecoder()
+  );
+}
+var BiometricType = /* @__PURE__ */ ((BiometricType2) => {
+  BiometricType2[BiometricType2["Fingerprint"] = 0] = "Fingerprint";
+  BiometricType2[BiometricType2["FaceRecognition"] = 1] = "FaceRecognition";
+  BiometricType2[BiometricType2["IrisRecognition"] = 2] = "IrisRecognition";
+  BiometricType2[BiometricType2["VoiceRecognition"] = 3] = "VoiceRecognition";
+  BiometricType2[BiometricType2["Signature"] = 4] = "Signature";
+  BiometricType2[BiometricType2["Gait"] = 5] = "Gait";
+  BiometricType2[BiometricType2["Behavioral"] = 6] = "Behavioral";
+  return BiometricType2;
+})(BiometricType || {});
+function getBiometricTypeEncoder() {
+  return getEnumEncoder(BiometricType);
+}
+function getBiometricTypeDecoder() {
+  return getEnumDecoder(BiometricType);
+}
+function getBiometricTypeCodec() {
+  return combineCodec(getBiometricTypeEncoder(), getBiometricTypeDecoder());
+}
+function getComplianceFlagsEncoder() {
+  return getStructEncoder([
+    ["requiresReporting", getBooleanEncoder()],
+    ["highRisk", getBooleanEncoder()],
+    ["sensitiveData", getBooleanEncoder()],
+    ["crossBorder", getBooleanEncoder()],
+    ["largeAmount", getBooleanEncoder()],
+    ["suspicious", getBooleanEncoder()],
+    ["manualReview", getBooleanEncoder()],
+    [
+      "jurisdiction",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getComplianceFlagsDecoder() {
+  return getStructDecoder([
+    ["requiresReporting", getBooleanDecoder()],
+    ["highRisk", getBooleanDecoder()],
+    ["sensitiveData", getBooleanDecoder()],
+    ["crossBorder", getBooleanDecoder()],
+    ["largeAmount", getBooleanDecoder()],
+    ["suspicious", getBooleanDecoder()],
+    ["manualReview", getBooleanDecoder()],
+    [
+      "jurisdiction",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getComplianceFlagsCodec() {
+  return combineCodec(getComplianceFlagsEncoder(), getComplianceFlagsDecoder());
+}
+function getComplianceMetricsEncoder() {
+  return getStructEncoder([
+    ["complianceScore", getU8Encoder()],
+    ["policyAdherenceRate", getU8Encoder()],
+    ["avgIncidentResponseTime", getU64Encoder()],
+    ["falsePositiveRate", getU8Encoder()],
+    ["coveragePercentage", getU8Encoder()],
+    ["auditReadinessScore", getU8Encoder()]
+  ]);
+}
+function getComplianceMetricsDecoder() {
+  return getStructDecoder([
+    ["complianceScore", getU8Decoder()],
+    ["policyAdherenceRate", getU8Decoder()],
+    ["avgIncidentResponseTime", getU64Decoder()],
+    ["falsePositiveRate", getU8Decoder()],
+    ["coveragePercentage", getU8Decoder()],
+    ["auditReadinessScore", getU8Decoder()]
+  ]);
+}
+function getComplianceMetricsCodec() {
+  return combineCodec(
+    getComplianceMetricsEncoder(),
+    getComplianceMetricsDecoder()
+  );
+}
+function getCompliancePoliciesEncoder() {
+  return getStructEncoder([
+    [
+      "frameworks",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "auditRequirements",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "reportingRequirements",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getCompliancePoliciesDecoder() {
+  return getStructDecoder([
+    [
+      "frameworks",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "auditRequirements",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "reportingRequirements",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getCompliancePoliciesCodec() {
+  return combineCodec(
+    getCompliancePoliciesEncoder(),
+    getCompliancePoliciesDecoder()
+  );
+}
+function getComplianceReportGeneratedEventEncoder() {
+  return getStructEncoder([
+    ["report", getAddressEncoder()],
+    ["reportId", getU64Encoder()],
+    ["reportType", getReportTypeEncoder()],
+    ["complianceRate", getU64Encoder()]
+  ]);
+}
+function getComplianceReportGeneratedEventDecoder() {
+  return getStructDecoder([
+    ["report", getAddressDecoder()],
+    ["reportId", getU64Decoder()],
+    ["reportType", getReportTypeDecoder()],
+    ["complianceRate", getU64Decoder()]
+  ]);
+}
+function getComplianceReportGeneratedEventCodec() {
+  return combineCodec(
+    getComplianceReportGeneratedEventEncoder(),
+    getComplianceReportGeneratedEventDecoder()
+  );
+}
+function getComplianceStatusEncoder() {
+  return getStructEncoder([
+    ["status", getU8Encoder()]
+  ]);
+}
+function getComplianceStatusDecoder() {
+  return getStructDecoder([
+    ["status", getU8Decoder()]
+  ]);
+}
+function getComplianceStatusCodec() {
+  return combineCodec(getComplianceStatusEncoder(), getComplianceStatusDecoder());
+}
+function getCompressedAgentCreatedEventEncoder() {
+  return getStructEncoder([
+    ["agentId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["owner", getAddressEncoder()],
+    ["treeAuthority", getAddressEncoder()],
+    ["merkleTree", getAddressEncoder()],
+    ["dataHash", fixEncoderSize(getBytesEncoder(), 32)],
+    ["index", getU64Encoder()],
+    ["metadataUri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["createdAt", getI64Encoder()]
+  ]);
+}
+function getCompressedAgentCreatedEventDecoder() {
+  return getStructDecoder([
+    ["agentId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["owner", getAddressDecoder()],
+    ["treeAuthority", getAddressDecoder()],
+    ["merkleTree", getAddressDecoder()],
+    ["dataHash", fixDecoderSize(getBytesDecoder(), 32)],
+    ["index", getU64Decoder()],
+    ["metadataUri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["createdAt", getI64Decoder()]
+  ]);
+}
+function getCompressedAgentCreatedEventCodec() {
+  return combineCodec(
+    getCompressedAgentCreatedEventEncoder(),
+    getCompressedAgentCreatedEventDecoder()
+  );
+}
+var ConditionType = /* @__PURE__ */ ((ConditionType2) => {
+  ConditionType2[ConditionType2["TimeDelay"] = 0] = "TimeDelay";
+  ConditionType2[ConditionType2["TokenBalance"] = 1] = "TokenBalance";
+  ConditionType2[ConditionType2["PriceThreshold"] = 2] = "PriceThreshold";
+  ConditionType2[ConditionType2["VoteCount"] = 3] = "VoteCount";
+  ConditionType2[ConditionType2["ExternalOracle"] = 4] = "ExternalOracle";
+  ConditionType2[ConditionType2["CustomLogic"] = 5] = "CustomLogic";
+  return ConditionType2;
+})(ConditionType || {});
+function getConditionTypeEncoder() {
+  return getEnumEncoder(ConditionType);
+}
+function getConditionTypeDecoder() {
+  return getEnumDecoder(ConditionType);
+}
+function getConditionTypeCodec() {
+  return combineCodec(getConditionTypeEncoder(), getConditionTypeDecoder());
+}
+function getConstraintConditionEncoder() {
+  return getStructEncoder([
+    ["attribute", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["operator", getConstraintOperatorEncoder()],
+    ["value", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["valueType", getValueTypeEncoder()]
+  ]);
+}
+function getConstraintConditionDecoder() {
+  return getStructDecoder([
+    ["attribute", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["operator", getConstraintOperatorDecoder()],
+    ["value", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["valueType", getValueTypeDecoder()]
+  ]);
+}
+function getConstraintConditionCodec() {
+  return combineCodec(
+    getConstraintConditionEncoder(),
+    getConstraintConditionDecoder()
+  );
+}
+var ConstraintOperator = /* @__PURE__ */ ((ConstraintOperator2) => {
+  ConstraintOperator2[ConstraintOperator2["Equals"] = 0] = "Equals";
+  ConstraintOperator2[ConstraintOperator2["NotEquals"] = 1] = "NotEquals";
+  ConstraintOperator2[ConstraintOperator2["GreaterThan"] = 2] = "GreaterThan";
+  ConstraintOperator2[ConstraintOperator2["LessThan"] = 3] = "LessThan";
+  ConstraintOperator2[ConstraintOperator2["GreaterThanOrEqual"] = 4] = "GreaterThanOrEqual";
+  ConstraintOperator2[ConstraintOperator2["LessThanOrEqual"] = 5] = "LessThanOrEqual";
+  ConstraintOperator2[ConstraintOperator2["Contains"] = 6] = "Contains";
+  ConstraintOperator2[ConstraintOperator2["NotContains"] = 7] = "NotContains";
+  ConstraintOperator2[ConstraintOperator2["In"] = 8] = "In";
+  ConstraintOperator2[ConstraintOperator2["NotIn"] = 9] = "NotIn";
+  ConstraintOperator2[ConstraintOperator2["Matches"] = 10] = "Matches";
+  ConstraintOperator2[ConstraintOperator2["NotMatches"] = 11] = "NotMatches";
+  return ConstraintOperator2;
+})(ConstraintOperator || {});
+function getConstraintOperatorEncoder() {
+  return getEnumEncoder(ConstraintOperator);
+}
+function getConstraintOperatorDecoder() {
+  return getEnumDecoder(ConstraintOperator);
+}
+function getConstraintOperatorCodec() {
+  return combineCodec(
+    getConstraintOperatorEncoder(),
+    getConstraintOperatorDecoder()
+  );
+}
+var CredentialKind = /* @__PURE__ */ ((CredentialKind2) => {
+  CredentialKind2[CredentialKind2["AgentIdentity"] = 0] = "AgentIdentity";
+  CredentialKind2[CredentialKind2["ReputationScore"] = 1] = "ReputationScore";
+  CredentialKind2[CredentialKind2["JobCompletion"] = 2] = "JobCompletion";
+  CredentialKind2[CredentialKind2["DelegatedSigner"] = 3] = "DelegatedSigner";
+  CredentialKind2[CredentialKind2["Custom"] = 4] = "Custom";
+  return CredentialKind2;
+})(CredentialKind || {});
+function getCredentialKindEncoder() {
+  return getEnumEncoder(CredentialKind);
+}
+function getCredentialKindDecoder() {
+  return getEnumDecoder(CredentialKind);
+}
+function getCredentialKindCodec() {
+  return combineCodec(getCredentialKindEncoder(), getCredentialKindDecoder());
+}
+var CredentialStatus = /* @__PURE__ */ ((CredentialStatus2) => {
+  CredentialStatus2[CredentialStatus2["Pending"] = 0] = "Pending";
+  CredentialStatus2[CredentialStatus2["Active"] = 1] = "Active";
+  CredentialStatus2[CredentialStatus2["Revoked"] = 2] = "Revoked";
+  CredentialStatus2[CredentialStatus2["Expired"] = 3] = "Expired";
+  return CredentialStatus2;
+})(CredentialStatus || {});
+function getCredentialStatusEncoder() {
+  return getEnumEncoder(CredentialStatus);
+}
+function getCredentialStatusDecoder() {
+  return getEnumDecoder(CredentialStatus);
+}
+function getCredentialStatusCodec() {
+  return combineCodec(
+    getCredentialStatusEncoder(),
+    getCredentialStatusDecoder()
+  );
+}
+var CrossChainStatus = /* @__PURE__ */ ((CrossChainStatus2) => {
+  CrossChainStatus2[CrossChainStatus2["NotSynced"] = 0] = "NotSynced";
+  CrossChainStatus2[CrossChainStatus2["SyncPending"] = 1] = "SyncPending";
+  CrossChainStatus2[CrossChainStatus2["SyncedToCrossmint"] = 2] = "SyncedToCrossmint";
+  CrossChainStatus2[CrossChainStatus2["SyncFailed"] = 3] = "SyncFailed";
+  return CrossChainStatus2;
+})(CrossChainStatus || {});
+function getCrossChainStatusEncoder() {
+  return getEnumEncoder(CrossChainStatus);
+}
+function getCrossChainStatusDecoder() {
+  return getEnumDecoder(CrossChainStatus);
+}
+function getCrossChainStatusCodec() {
+  return combineCodec(
+    getCrossChainStatusEncoder(),
+    getCrossChainStatusDecoder()
+  );
+}
+var DataAccessLevel = /* @__PURE__ */ ((DataAccessLevel2) => {
+  DataAccessLevel2[DataAccessLevel2["Public"] = 0] = "Public";
+  DataAccessLevel2[DataAccessLevel2["Internal"] = 1] = "Internal";
+  DataAccessLevel2[DataAccessLevel2["Confidential"] = 2] = "Confidential";
+  DataAccessLevel2[DataAccessLevel2["Restricted"] = 3] = "Restricted";
+  DataAccessLevel2[DataAccessLevel2["TopSecret"] = 4] = "TopSecret";
+  return DataAccessLevel2;
+})(DataAccessLevel || {});
+function getDataAccessLevelEncoder() {
+  return getEnumEncoder(DataAccessLevel);
+}
+function getDataAccessLevelDecoder() {
+  return getEnumDecoder(DataAccessLevel);
+}
+function getDataAccessLevelCodec() {
+  return combineCodec(getDataAccessLevelEncoder(), getDataAccessLevelDecoder());
+}
+function getDataProtectionPoliciesEncoder() {
+  return getStructEncoder([
+    ["encryptionRequired", getBooleanEncoder()],
+    ["classificationRequired", getBooleanEncoder()],
+    ["dlpEnabled", getBooleanEncoder()]
+  ]);
+}
+function getDataProtectionPoliciesDecoder() {
+  return getStructDecoder([
+    ["encryptionRequired", getBooleanDecoder()],
+    ["classificationRequired", getBooleanDecoder()],
+    ["dlpEnabled", getBooleanDecoder()]
+  ]);
+}
+function getDataProtectionPoliciesCodec() {
+  return combineCodec(
+    getDataProtectionPoliciesEncoder(),
+    getDataProtectionPoliciesDecoder()
+  );
+}
+var DegradationHandling = /* @__PURE__ */ ((DegradationHandling2) => {
+  DegradationHandling2[DegradationHandling2["RequireRefresh"] = 0] = "RequireRefresh";
+  DegradationHandling2[DegradationHandling2["GradualDegradation"] = 1] = "GradualDegradation";
+  DegradationHandling2[DegradationHandling2["ImmediateExpiry"] = 2] = "ImmediateExpiry";
+  DegradationHandling2[DegradationHandling2["AdaptiveThreshold"] = 3] = "AdaptiveThreshold";
+  return DegradationHandling2;
+})(DegradationHandling || {});
+function getDegradationHandlingEncoder() {
+  return getEnumEncoder(DegradationHandling);
+}
+function getDegradationHandlingDecoder() {
+  return getEnumDecoder(DegradationHandling);
+}
+function getDegradationHandlingCodec() {
+  return combineCodec(
+    getDegradationHandlingEncoder(),
+    getDegradationHandlingDecoder()
+  );
+}
+function getDelegationInfoEncoder() {
+  return getStructEncoder([
+    ["delegator", getAddressEncoder()],
+    ["delegatedAt", getI64Encoder()],
+    ["scope", getDelegationScopeEncoder()],
+    ["expiresAt", getOptionEncoder(getI64Encoder())]
+  ]);
+}
+function getDelegationInfoDecoder() {
+  return getStructDecoder([
+    ["delegator", getAddressDecoder()],
+    ["delegatedAt", getI64Decoder()],
+    ["scope", getDelegationScopeDecoder()],
+    ["expiresAt", getOptionDecoder(getI64Decoder())]
+  ]);
+}
+function getDelegationInfoCodec() {
+  return combineCodec(getDelegationInfoEncoder(), getDelegationInfoDecoder());
+}
+function getDelegationScopeEncoder() {
+  return getDiscriminatedUnionEncoder([
+    ["All", getUnitEncoder()],
+    [
+      "ProposalType",
+      getStructEncoder([
+        ["fields", getTupleEncoder([getProposalTypeEncoder()])]
+      ])
+    ],
+    ["SingleProposal", getUnitEncoder()],
+    ["Limited", getUnitEncoder()]
+  ]);
+}
+function getDelegationScopeDecoder() {
+  return getDiscriminatedUnionDecoder([
+    ["All", getUnitDecoder()],
+    [
+      "ProposalType",
+      getStructDecoder([
+        ["fields", getTupleDecoder([getProposalTypeDecoder()])]
+      ])
+    ],
+    ["SingleProposal", getUnitDecoder()],
+    ["Limited", getUnitDecoder()]
+  ]);
+}
+function getDelegationScopeCodec() {
+  return combineCodec(getDelegationScopeEncoder(), getDelegationScopeDecoder());
+}
+function delegationScope(kind, data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
+}
+function isDelegationScope(kind, value) {
+  return value.__kind === kind;
+}
+function getDeliverySubmittedEventEncoder() {
+  return getStructEncoder([
+    ["escrowId", getU64Encoder()],
+    ["agent", getAddressEncoder()],
+    ["deliveryProof", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getDeliverySubmittedEventDecoder() {
+  return getStructDecoder([
+    ["escrowId", getU64Decoder()],
+    ["agent", getAddressDecoder()],
+    ["deliveryProof", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getDeliverySubmittedEventCodec() {
+  return combineCodec(
+    getDeliverySubmittedEventEncoder(),
+    getDeliverySubmittedEventDecoder()
+  );
+}
+function getDisputeFiledEventEncoder() {
+  return getStructEncoder([
+    ["escrowId", getU64Encoder()],
+    ["client", getAddressEncoder()],
+    ["reason", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getDisputeFiledEventDecoder() {
+  return getStructDecoder([
+    ["escrowId", getU64Decoder()],
+    ["client", getAddressDecoder()],
+    ["reason", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getDisputeFiledEventCodec() {
+  return combineCodec(
+    getDisputeFiledEventEncoder(),
+    getDisputeFiledEventDecoder()
+  );
+}
+function getDisputeResolvedEventEncoder() {
+  return getStructEncoder([
+    ["escrowId", getU64Encoder()],
+    ["decision", getArbitratorDecisionEncoder()],
+    ["arbitrator", getAddressEncoder()]
+  ]);
+}
+function getDisputeResolvedEventDecoder() {
+  return getStructDecoder([
+    ["escrowId", getU64Decoder()],
+    ["decision", getArbitratorDecisionDecoder()],
+    ["arbitrator", getAddressDecoder()]
+  ]);
+}
+function getDisputeResolvedEventCodec() {
+  return combineCodec(
+    getDisputeResolvedEventEncoder(),
+    getDisputeResolvedEventDecoder()
+  );
+}
+function getEmergencyAccessConfigEncoder() {
+  return getStructEncoder([
+    ["breakGlassEnabled", getBooleanEncoder()],
+    ["emergencyContacts", getArrayEncoder(getAddressEncoder())],
+    ["approvalRequired", getBooleanEncoder()]
+  ]);
+}
+function getEmergencyAccessConfigDecoder() {
+  return getStructDecoder([
+    ["breakGlassEnabled", getBooleanDecoder()],
+    ["emergencyContacts", getArrayDecoder(getAddressDecoder())],
+    ["approvalRequired", getBooleanDecoder()]
+  ]);
+}
+function getEmergencyAccessConfigCodec() {
+  return combineCodec(
+    getEmergencyAccessConfigEncoder(),
+    getEmergencyAccessConfigDecoder()
+  );
+}
+function getEmergencyConfigEncoder() {
+  return getStructEncoder([
+    ["emergencyContacts", getArrayEncoder(getAddressEncoder())],
+    ["emergencyThreshold", getU8Encoder()],
+    ["emergencyTimeout", getI64Encoder()],
+    ["emergencyTransactionTypes", getArrayEncoder(getTransactionTypeEncoder())],
+    ["freezeEnabled", getBooleanEncoder()],
+    ["frozen", getBooleanEncoder()],
+    ["frozenAt", getOptionEncoder(getI64Encoder())],
+    ["autoUnfreezeDuration", getOptionEncoder(getI64Encoder())]
+  ]);
+}
+function getEmergencyConfigDecoder() {
+  return getStructDecoder([
+    ["emergencyContacts", getArrayDecoder(getAddressDecoder())],
+    ["emergencyThreshold", getU8Decoder()],
+    ["emergencyTimeout", getI64Decoder()],
+    ["emergencyTransactionTypes", getArrayDecoder(getTransactionTypeDecoder())],
+    ["freezeEnabled", getBooleanDecoder()],
+    ["frozen", getBooleanDecoder()],
+    ["frozenAt", getOptionDecoder(getI64Decoder())],
+    ["autoUnfreezeDuration", getOptionDecoder(getI64Decoder())]
+  ]);
+}
+function getEmergencyConfigCodec() {
+  return combineCodec(getEmergencyConfigEncoder(), getEmergencyConfigDecoder());
+}
+var EnforcementLevel = /* @__PURE__ */ ((EnforcementLevel2) => {
+  EnforcementLevel2[EnforcementLevel2["Hard"] = 0] = "Hard";
+  EnforcementLevel2[EnforcementLevel2["Soft"] = 1] = "Soft";
+  EnforcementLevel2[EnforcementLevel2["Advisory"] = 2] = "Advisory";
+  EnforcementLevel2[EnforcementLevel2["ExceptionBased"] = 3] = "ExceptionBased";
+  return EnforcementLevel2;
+})(EnforcementLevel || {});
+function getEnforcementLevelEncoder() {
+  return getEnumEncoder(EnforcementLevel);
+}
+function getEnforcementLevelDecoder() {
+  return getEnumDecoder(EnforcementLevel);
+}
+function getEnforcementLevelCodec() {
+  return combineCodec(
+    getEnforcementLevelEncoder(),
+    getEnforcementLevelDecoder()
+  );
+}
+function getEscrowCompletedEventEncoder() {
+  return getStructEncoder([
+    ["escrowId", getU64Encoder()],
+    ["agent", getAddressEncoder()],
+    ["amount", getU64Encoder()]
+  ]);
+}
+function getEscrowCompletedEventDecoder() {
+  return getStructDecoder([
+    ["escrowId", getU64Decoder()],
+    ["agent", getAddressDecoder()],
+    ["amount", getU64Decoder()]
+  ]);
+}
+function getEscrowCompletedEventCodec() {
+  return combineCodec(
+    getEscrowCompletedEventEncoder(),
+    getEscrowCompletedEventDecoder()
+  );
+}
+function getEscrowCreatedEventEncoder() {
+  return getStructEncoder([
+    ["escrowId", getU64Encoder()],
+    ["client", getAddressEncoder()],
+    ["agent", getAddressEncoder()],
+    ["amount", getU64Encoder()],
+    ["deadline", getI64Encoder()]
+  ]);
+}
+function getEscrowCreatedEventDecoder() {
+  return getStructDecoder([
+    ["escrowId", getU64Decoder()],
+    ["client", getAddressDecoder()],
+    ["agent", getAddressDecoder()],
+    ["amount", getU64Decoder()],
+    ["deadline", getI64Decoder()]
+  ]);
+}
+function getEscrowCreatedEventCodec() {
+  return combineCodec(
+    getEscrowCreatedEventEncoder(),
+    getEscrowCreatedEventDecoder()
+  );
+}
+var EscrowStatus = /* @__PURE__ */ ((EscrowStatus2) => {
+  EscrowStatus2[EscrowStatus2["Active"] = 0] = "Active";
+  EscrowStatus2[EscrowStatus2["Completed"] = 1] = "Completed";
+  EscrowStatus2[EscrowStatus2["Disputed"] = 2] = "Disputed";
+  EscrowStatus2[EscrowStatus2["Cancelled"] = 3] = "Cancelled";
+  return EscrowStatus2;
+})(EscrowStatus || {});
+function getEscrowStatusEncoder() {
+  return getEnumEncoder(EscrowStatus);
+}
+function getEscrowStatusDecoder() {
+  return getEnumDecoder(EscrowStatus);
+}
+function getEscrowStatusCodec() {
+  return combineCodec(getEscrowStatusEncoder(), getEscrowStatusDecoder());
+}
+function getExecutionConditionEncoder() {
+  return getStructEncoder([
+    ["conditionType", getConditionTypeEncoder()],
+    ["targetValue", getU64Encoder()],
+    ["currentValue", getU64Encoder()],
+    ["met", getBooleanEncoder()],
+    ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getExecutionConditionDecoder() {
+  return getStructDecoder([
+    ["conditionType", getConditionTypeDecoder()],
+    ["targetValue", getU64Decoder()],
+    ["currentValue", getU64Decoder()],
+    ["met", getBooleanDecoder()],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getExecutionConditionCodec() {
+  return combineCodec(
+    getExecutionConditionEncoder(),
+    getExecutionConditionDecoder()
+  );
+}
+function getExecutionParamsEncoder() {
+  return getStructEncoder([
+    ["instructions", getArrayEncoder(getProposalInstructionEncoder())],
+    ["executionDelay", getI64Encoder()],
+    ["executionConditions", getArrayEncoder(getExecutionConditionEncoder())],
+    ["cancellable", getBooleanEncoder()],
+    ["autoExecute", getBooleanEncoder()],
+    ["executionAuthority", getAddressEncoder()]
+  ]);
+}
+function getExecutionParamsDecoder() {
+  return getStructDecoder([
+    ["instructions", getArrayDecoder(getProposalInstructionDecoder())],
+    ["executionDelay", getI64Decoder()],
+    ["executionConditions", getArrayDecoder(getExecutionConditionDecoder())],
+    ["cancellable", getBooleanDecoder()],
+    ["autoExecute", getBooleanDecoder()],
+    ["executionAuthority", getAddressDecoder()]
+  ]);
+}
+function getExecutionParamsCodec() {
+  return combineCodec(getExecutionParamsEncoder(), getExecutionParamsDecoder());
+}
+function getExternalIdentifierEncoder() {
+  return getStructEncoder([
+    ["platform", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["externalId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["verified", getBooleanEncoder()],
+    ["verifiedAt", getI64Encoder()]
+  ]);
+}
+function getExternalIdentifierDecoder() {
+  return getStructDecoder([
+    ["platform", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["externalId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["verified", getBooleanDecoder()],
+    ["verifiedAt", getI64Decoder()]
+  ]);
+}
+function getExternalIdentifierCodec() {
+  return combineCodec(
+    getExternalIdentifierEncoder(),
+    getExternalIdentifierDecoder()
+  );
+}
+function getGeographicRegionEncoder() {
+  return getStructEncoder([
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["latitudeRange", getLatitudeRangeEncoder()],
+    ["longitudeRange", getLongitudeRangeEncoder()],
+    ["radius", getOptionEncoder(getU32Encoder())]
+  ]);
+}
+function getGeographicRegionDecoder() {
+  return getStructDecoder([
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["latitudeRange", getLatitudeRangeDecoder()],
+    ["longitudeRange", getLongitudeRangeDecoder()],
+    ["radius", getOptionDecoder(getU32Decoder())]
+  ]);
+}
+function getGeographicRegionCodec() {
+  return combineCodec(
+    getGeographicRegionEncoder(),
+    getGeographicRegionDecoder()
+  );
+}
+function getGhostSlashedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["amount", getU64Encoder()],
+    ["reason", getSlashReasonEncoder()],
+    ["newTier", getAccessTierEncoder()]
+  ]);
+}
+function getGhostSlashedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["amount", getU64Decoder()],
+    ["reason", getSlashReasonDecoder()],
+    ["newTier", getAccessTierDecoder()]
+  ]);
+}
+function getGhostSlashedEventCodec() {
+  return combineCodec(
+    getGhostSlashedEventEncoder(),
+    getGhostSlashedEventDecoder()
+  );
+}
+function getGhostStakedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["amount", getU64Encoder()],
+    ["unlockAt", getI64Encoder()],
+    ["reputationBoostBps", getU16Encoder()],
+    ["tier", getAccessTierEncoder()],
+    ["dailyApiCalls", getU32Encoder()],
+    ["votingPower", getU64Encoder()]
+  ]);
+}
+function getGhostStakedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["amount", getU64Decoder()],
+    ["unlockAt", getI64Decoder()],
+    ["reputationBoostBps", getU16Decoder()],
+    ["tier", getAccessTierDecoder()],
+    ["dailyApiCalls", getU32Decoder()],
+    ["votingPower", getU64Decoder()]
+  ]);
+}
+function getGhostStakedEventCodec() {
+  return combineCodec(
+    getGhostStakedEventEncoder(),
+    getGhostStakedEventDecoder()
+  );
+}
+function getGhostUnstakedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["amount", getU64Encoder()]
+  ]);
+}
+function getGhostUnstakedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["amount", getU64Decoder()]
+  ]);
+}
+function getGhostUnstakedEventCodec() {
+  return combineCodec(
+    getGhostUnstakedEventEncoder(),
+    getGhostUnstakedEventDecoder()
+  );
+}
+function getGovernanceProposalCreatedEventEncoder() {
+  return getStructEncoder([
+    ["proposal", getAddressEncoder()],
+    ["proposalId", getU64Encoder()],
+    ["proposer", getAddressEncoder()],
+    ["title", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getGovernanceProposalCreatedEventDecoder() {
+  return getStructDecoder([
+    ["proposal", getAddressDecoder()],
+    ["proposalId", getU64Decoder()],
+    ["proposer", getAddressDecoder()],
+    ["title", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getGovernanceProposalCreatedEventCodec() {
+  return combineCodec(
+    getGovernanceProposalCreatedEventEncoder(),
+    getGovernanceProposalCreatedEventDecoder()
+  );
+}
+function getHierarchicalBoundaryEncoder() {
+  return getStructEncoder([
+    ["level", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["value", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["includeDescendants", getBooleanEncoder()]
+  ]);
+}
+function getHierarchicalBoundaryDecoder() {
+  return getStructDecoder([
+    ["level", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["value", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["includeDescendants", getBooleanDecoder()]
+  ]);
+}
+function getHierarchicalBoundaryCodec() {
+  return combineCodec(
+    getHierarchicalBoundaryEncoder(),
+    getHierarchicalBoundaryDecoder()
+  );
+}
+function getIncidentResponsePoliciesEncoder() {
+  return getStructEncoder([
+    ["responseTeam", getArrayEncoder(getAddressEncoder())],
+    [
+      "escalationProcedures",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "notificationRequirements",
+      getArrayEncoder(getNotificationRequirementEncoder())
+    ]
+  ]);
+}
+function getIncidentResponsePoliciesDecoder() {
+  return getStructDecoder([
+    ["responseTeam", getArrayDecoder(getAddressDecoder())],
+    [
+      "escalationProcedures",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "notificationRequirements",
+      getArrayDecoder(getNotificationRequirementDecoder())
+    ]
+  ]);
+}
+function getIncidentResponsePoliciesCodec() {
+  return combineCodec(
+    getIncidentResponsePoliciesEncoder(),
+    getIncidentResponsePoliciesDecoder()
+  );
+}
+function getLatitudeRangeEncoder() {
+  return getStructEncoder([
+    ["min", getF64Encoder()],
+    ["max", getF64Encoder()]
+  ]);
+}
+function getLatitudeRangeDecoder() {
+  return getStructDecoder([
+    ["min", getF64Decoder()],
+    ["max", getF64Decoder()]
+  ]);
+}
+function getLatitudeRangeCodec() {
+  return combineCodec(getLatitudeRangeEncoder(), getLatitudeRangeDecoder());
+}
+function getLocationConstraintsEncoder() {
+  return getStructEncoder([
+    [
+      "allowedCountries",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "blockedCountries",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "allowedIpRanges",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "blockedIpRanges",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["geofencingEnabled", getBooleanEncoder()],
+    ["allowedRegions", getArrayEncoder(getGeographicRegionEncoder())]
+  ]);
+}
+function getLocationConstraintsDecoder() {
+  return getStructDecoder([
+    [
+      "allowedCountries",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "blockedCountries",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "allowedIpRanges",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "blockedIpRanges",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["geofencingEnabled", getBooleanDecoder()],
+    ["allowedRegions", getArrayDecoder(getGeographicRegionDecoder())]
+  ]);
+}
+function getLocationConstraintsCodec() {
+  return combineCodec(
+    getLocationConstraintsEncoder(),
+    getLocationConstraintsDecoder()
+  );
+}
+function getLongitudeRangeEncoder() {
+  return getStructEncoder([
+    ["min", getF64Encoder()],
+    ["max", getF64Encoder()]
+  ]);
+}
+function getLongitudeRangeDecoder() {
+  return getStructDecoder([
+    ["min", getF64Decoder()],
+    ["max", getF64Decoder()]
+  ]);
+}
+function getLongitudeRangeCodec() {
+  return combineCodec(getLongitudeRangeEncoder(), getLongitudeRangeDecoder());
+}
+function getMultisigConfigEncoder() {
+  return getStructEncoder([
+    ["threshold", getU8Encoder()]
+  ]);
+}
+function getMultisigConfigDecoder() {
+  return getStructDecoder([
+    ["threshold", getU8Decoder()]
+  ]);
+}
+function getMultisigConfigCodec() {
+  return combineCodec(getMultisigConfigEncoder(), getMultisigConfigDecoder());
+}
+function getMultisigCreatedEventEncoder() {
+  return getStructEncoder([
+    ["multisigId", getU64Encoder()],
+    ["multisigType", getMultisigTypeEncoder()],
+    ["owner", getAddressEncoder()],
+    ["threshold", getU8Encoder()],
+    ["signerCount", getU8Encoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getMultisigCreatedEventDecoder() {
+  return getStructDecoder([
+    ["multisigId", getU64Decoder()],
+    ["multisigType", getMultisigTypeDecoder()],
+    ["owner", getAddressDecoder()],
+    ["threshold", getU8Decoder()],
+    ["signerCount", getU8Decoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getMultisigCreatedEventCodec() {
+  return combineCodec(
+    getMultisigCreatedEventEncoder(),
+    getMultisigCreatedEventDecoder()
+  );
+}
+function getMultisigSignatureEncoder() {
+  return getStructEncoder([
+    ["signer", getAddressEncoder()],
+    ["signature", fixEncoderSize(getBytesEncoder(), 64)],
+    ["signedAt", getI64Encoder()],
+    [
+      "signatureMethod",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    [
+      "verificationData",
+      getOptionEncoder(
+        addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())
+      )
+    ]
+  ]);
+}
+function getMultisigSignatureDecoder() {
+  return getStructDecoder([
+    ["signer", getAddressDecoder()],
+    ["signature", fixDecoderSize(getBytesDecoder(), 64)],
+    ["signedAt", getI64Decoder()],
+    [
+      "signatureMethod",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    [
+      "verificationData",
+      getOptionDecoder(
+        addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())
+      )
+    ]
+  ]);
+}
+function getMultisigSignatureCodec() {
+  return combineCodec(
+    getMultisigSignatureEncoder(),
+    getMultisigSignatureDecoder()
+  );
+}
+var MultisigType = /* @__PURE__ */ ((MultisigType2) => {
+  MultisigType2[MultisigType2["Protocol"] = 0] = "Protocol";
+  MultisigType2[MultisigType2["Dao"] = 1] = "Dao";
+  MultisigType2[MultisigType2["Dispute"] = 2] = "Dispute";
+  MultisigType2[MultisigType2["AgentConsortium"] = 3] = "AgentConsortium";
+  MultisigType2[MultisigType2["AgentTreasury"] = 4] = "AgentTreasury";
+  MultisigType2[MultisigType2["Custom"] = 5] = "Custom";
+  return MultisigType2;
+})(MultisigType || {});
+function getMultisigTypeEncoder() {
+  return getEnumEncoder(MultisigType);
+}
+function getMultisigTypeDecoder() {
+  return getEnumDecoder(MultisigType);
+}
+function getMultisigTypeCodec() {
+  return combineCodec(getMultisigTypeEncoder(), getMultisigTypeDecoder());
+}
+function getMultisigTypeConfigEncoder() {
+  return getStructEncoder([
+    ["multisigType", getMultisigTypeEncoder()],
+    ["timelockSeconds", getI64Encoder()],
+    ["minSigners", getU8Encoder()],
+    ["maxSigners", getU8Encoder()],
+    ["minReputationScore", getU16Encoder()],
+    ["requiresTokenHoldings", getBooleanEncoder()],
+    ["minTokenBalance", getU64Encoder()]
+  ]);
+}
+function getMultisigTypeConfigDecoder() {
+  return getStructDecoder([
+    ["multisigType", getMultisigTypeDecoder()],
+    ["timelockSeconds", getI64Decoder()],
+    ["minSigners", getU8Decoder()],
+    ["maxSigners", getU8Decoder()],
+    ["minReputationScore", getU16Decoder()],
+    ["requiresTokenHoldings", getBooleanDecoder()],
+    ["minTokenBalance", getU64Decoder()]
+  ]);
+}
+function getMultisigTypeConfigCodec() {
+  return combineCodec(
+    getMultisigTypeConfigEncoder(),
+    getMultisigTypeConfigDecoder()
+  );
+}
+function getNetworkSecurityPoliciesEncoder() {
+  return getStructEncoder([
+    ["firewallRequired", getBooleanEncoder()],
+    ["intrusionDetection", getBooleanEncoder()],
+    ["trafficMonitoring", getBooleanEncoder()]
+  ]);
+}
+function getNetworkSecurityPoliciesDecoder() {
+  return getStructDecoder([
+    ["firewallRequired", getBooleanDecoder()],
+    ["intrusionDetection", getBooleanDecoder()],
+    ["trafficMonitoring", getBooleanDecoder()]
+  ]);
+}
+function getNetworkSecurityPoliciesCodec() {
+  return combineCodec(
+    getNetworkSecurityPoliciesEncoder(),
+    getNetworkSecurityPoliciesDecoder()
+  );
+}
+var NotificationMethod = /* @__PURE__ */ ((NotificationMethod2) => {
+  NotificationMethod2[NotificationMethod2["OnChain"] = 0] = "OnChain";
+  NotificationMethod2[NotificationMethod2["Email"] = 1] = "Email";
+  NotificationMethod2[NotificationMethod2["Sms"] = 2] = "Sms";
+  NotificationMethod2[NotificationMethod2["Push"] = 3] = "Push";
+  NotificationMethod2[NotificationMethod2["InApp"] = 4] = "InApp";
+  NotificationMethod2[NotificationMethod2["All"] = 5] = "All";
+  return NotificationMethod2;
+})(NotificationMethod || {});
+function getNotificationMethodEncoder() {
+  return getEnumEncoder(NotificationMethod);
+}
+function getNotificationMethodDecoder() {
+  return getEnumDecoder(NotificationMethod);
+}
+function getNotificationMethodCodec() {
+  return combineCodec(
+    getNotificationMethodEncoder(),
+    getNotificationMethodDecoder()
+  );
+}
+var NotificationPriority = /* @__PURE__ */ ((NotificationPriority2) => {
+  NotificationPriority2[NotificationPriority2["Low"] = 0] = "Low";
+  NotificationPriority2[NotificationPriority2["Medium"] = 1] = "Medium";
+  NotificationPriority2[NotificationPriority2["High"] = 2] = "High";
+  NotificationPriority2[NotificationPriority2["Critical"] = 3] = "Critical";
+  NotificationPriority2[NotificationPriority2["Emergency"] = 4] = "Emergency";
+  return NotificationPriority2;
+})(NotificationPriority || {});
+function getNotificationPriorityEncoder() {
+  return getEnumEncoder(NotificationPriority);
+}
+function getNotificationPriorityDecoder() {
+  return getEnumDecoder(NotificationPriority);
+}
+function getNotificationPriorityCodec() {
+  return combineCodec(
+    getNotificationPriorityEncoder(),
+    getNotificationPriorityDecoder()
+  );
+}
+function getNotificationRequirementEncoder() {
+  return getStructEncoder([
+    ["eventType", getSecurityEventTypeEncoder()],
+    ["targets", getArrayEncoder(getNotificationTargetEncoder())],
+    ["method", getNotificationMethodEncoder()],
+    ["timing", getNotificationTimingEncoder()]
+  ]);
+}
+function getNotificationRequirementDecoder() {
+  return getStructDecoder([
+    ["eventType", getSecurityEventTypeDecoder()],
+    ["targets", getArrayDecoder(getNotificationTargetDecoder())],
+    ["method", getNotificationMethodDecoder()],
+    ["timing", getNotificationTimingDecoder()]
+  ]);
+}
+function getNotificationRequirementCodec() {
+  return combineCodec(
+    getNotificationRequirementEncoder(),
+    getNotificationRequirementDecoder()
+  );
+}
+function getNotificationTargetEncoder() {
+  return getStructEncoder([
+    ["targetType", getNotificationTargetTypeEncoder()],
+    ["targetId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["priority", getNotificationPriorityEncoder()]
+  ]);
+}
+function getNotificationTargetDecoder() {
+  return getStructDecoder([
+    ["targetType", getNotificationTargetTypeDecoder()],
+    ["targetId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["priority", getNotificationPriorityDecoder()]
+  ]);
+}
+function getNotificationTargetCodec() {
+  return combineCodec(
+    getNotificationTargetEncoder(),
+    getNotificationTargetDecoder()
+  );
+}
+var NotificationTargetType = /* @__PURE__ */ ((NotificationTargetType2) => {
+  NotificationTargetType2[NotificationTargetType2["User"] = 0] = "User";
+  NotificationTargetType2[NotificationTargetType2["Administrator"] = 1] = "Administrator";
+  NotificationTargetType2[NotificationTargetType2["SecurityTeam"] = 2] = "SecurityTeam";
+  NotificationTargetType2[NotificationTargetType2["ComplianceTeam"] = 3] = "ComplianceTeam";
+  NotificationTargetType2[NotificationTargetType2["Manager"] = 4] = "Manager";
+  NotificationTargetType2[NotificationTargetType2["AuditTeam"] = 5] = "AuditTeam";
+  NotificationTargetType2[NotificationTargetType2["ExternalSystem"] = 6] = "ExternalSystem";
+  return NotificationTargetType2;
+})(NotificationTargetType || {});
+function getNotificationTargetTypeEncoder() {
+  return getEnumEncoder(NotificationTargetType);
+}
+function getNotificationTargetTypeDecoder() {
+  return getEnumDecoder(NotificationTargetType);
+}
+function getNotificationTargetTypeCodec() {
+  return combineCodec(
+    getNotificationTargetTypeEncoder(),
+    getNotificationTargetTypeDecoder()
+  );
+}
+var NotificationTiming = /* @__PURE__ */ ((NotificationTiming2) => {
+  NotificationTiming2[NotificationTiming2["Immediate"] = 0] = "Immediate";
+  NotificationTiming2[NotificationTiming2["Delayed"] = 1] = "Delayed";
+  NotificationTiming2[NotificationTiming2["Batched"] = 2] = "Batched";
+  NotificationTiming2[NotificationTiming2["Scheduled"] = 3] = "Scheduled";
+  return NotificationTiming2;
+})(NotificationTiming || {});
+function getNotificationTimingEncoder() {
+  return getEnumEncoder(NotificationTiming);
+}
+function getNotificationTimingDecoder() {
+  return getEnumDecoder(NotificationTiming);
+}
+function getNotificationTimingCodec() {
+  return combineCodec(
+    getNotificationTimingEncoder(),
+    getNotificationTimingDecoder()
+  );
+}
+function getPasswordPoliciesEncoder() {
+  return getStructEncoder([
+    ["minimumLength", getU8Encoder()],
+    [
+      "complexityRequirements",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["historyCount", getU8Encoder()],
+    ["maxAge", getI64Encoder()]
+  ]);
+}
+function getPasswordPoliciesDecoder() {
+  return getStructDecoder([
+    ["minimumLength", getU8Decoder()],
+    [
+      "complexityRequirements",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["historyCount", getU8Decoder()],
+    ["maxAge", getI64Decoder()]
+  ]);
+}
+function getPasswordPoliciesCodec() {
+  return combineCodec(
+    getPasswordPoliciesEncoder(),
+    getPasswordPoliciesDecoder()
+  );
+}
+function getPendingTransactionEncoder() {
+  return getStructEncoder([
+    ["transactionId", getU64Encoder()],
+    ["transactionType", getTransactionTypeEncoder()],
+    ["target", getAddressEncoder()],
+    ["data", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+    ["requiredSignatures", getU8Encoder()],
+    ["signatures", getArrayEncoder(getMultisigSignatureEncoder())],
+    ["createdAt", getI64Encoder()],
+    ["expiresAt", getI64Encoder()],
+    ["priority", getTransactionPriorityEncoder()],
+    ["executionConditions", getArrayEncoder(getExecutionConditionEncoder())],
+    ["status", getTransactionStatusEncoder()],
+    ["timeLock", getOptionEncoder(getTimeLockEncoder())]
+  ]);
+}
+function getPendingTransactionDecoder() {
+  return getStructDecoder([
+    ["transactionId", getU64Decoder()],
+    ["transactionType", getTransactionTypeDecoder()],
+    ["target", getAddressDecoder()],
+    ["data", addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())],
+    ["requiredSignatures", getU8Decoder()],
+    ["signatures", getArrayDecoder(getMultisigSignatureDecoder())],
+    ["createdAt", getI64Decoder()],
+    ["expiresAt", getI64Decoder()],
+    ["priority", getTransactionPriorityDecoder()],
+    ["executionConditions", getArrayDecoder(getExecutionConditionDecoder())],
+    ["status", getTransactionStatusDecoder()],
+    ["timeLock", getOptionDecoder(getTimeLockDecoder())]
+  ]);
+}
+function getPendingTransactionCodec() {
+  return combineCodec(
+    getPendingTransactionEncoder(),
+    getPendingTransactionDecoder()
+  );
+}
+function getPermissionEncoder() {
+  return getStructEncoder([
+    ["permissionId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["resourceType", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["actions", getArrayEncoder(getActionEncoder())],
+    ["scope", getPermissionScopeEncoder()],
+    ["constraints", getArrayEncoder(getPermissionConstraintEncoder())],
+    ["metadata", getPermissionMetadataEncoder()]
+  ]);
+}
+function getPermissionDecoder() {
+  return getStructDecoder([
+    ["permissionId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["resourceType", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["actions", getArrayDecoder(getActionDecoder())],
+    ["scope", getPermissionScopeDecoder()],
+    ["constraints", getArrayDecoder(getPermissionConstraintDecoder())],
+    ["metadata", getPermissionMetadataDecoder()]
+  ]);
+}
+function getPermissionCodec() {
+  return combineCodec(getPermissionEncoder(), getPermissionDecoder());
+}
+function getPermissionConstraintEncoder() {
+  return getStructEncoder([
+    ["constraintType", getPermissionConstraintTypeEncoder()],
+    ["conditions", getArrayEncoder(getConstraintConditionEncoder())],
+    ["enforcement", getEnforcementLevelEncoder()]
+  ]);
+}
+function getPermissionConstraintDecoder() {
+  return getStructDecoder([
+    ["constraintType", getPermissionConstraintTypeDecoder()],
+    ["conditions", getArrayDecoder(getConstraintConditionDecoder())],
+    ["enforcement", getEnforcementLevelDecoder()]
+  ]);
+}
+function getPermissionConstraintCodec() {
+  return combineCodec(
+    getPermissionConstraintEncoder(),
+    getPermissionConstraintDecoder()
+  );
+}
+var PermissionConstraintType = /* @__PURE__ */ ((PermissionConstraintType2) => {
+  PermissionConstraintType2[PermissionConstraintType2["Temporal"] = 0] = "Temporal";
+  PermissionConstraintType2[PermissionConstraintType2["Contextual"] = 1] = "Contextual";
+  PermissionConstraintType2[PermissionConstraintType2["Conditional"] = 2] = "Conditional";
+  PermissionConstraintType2[PermissionConstraintType2["ResourceBased"] = 3] = "ResourceBased";
+  PermissionConstraintType2[PermissionConstraintType2["AttributeBased"] = 4] = "AttributeBased";
+  PermissionConstraintType2[PermissionConstraintType2["RiskBased"] = 5] = "RiskBased";
+  return PermissionConstraintType2;
+})(PermissionConstraintType || {});
+function getPermissionConstraintTypeEncoder() {
+  return getEnumEncoder(PermissionConstraintType);
+}
+function getPermissionConstraintTypeDecoder() {
+  return getEnumDecoder(PermissionConstraintType);
+}
+function getPermissionConstraintTypeCodec() {
+  return combineCodec(
+    getPermissionConstraintTypeEncoder(),
+    getPermissionConstraintTypeDecoder()
+  );
+}
+function getPermissionMetadataEncoder() {
+  return getStructEncoder([
+    [
+      "businessJustification",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["riskAssessment", getRiskAssessmentEncoder()],
+    [
+      "complianceMapping",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "relatedPermissions",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["owner", getOptionEncoder(getAddressEncoder())],
+    ["lastReview", getOptionEncoder(getI64Encoder())],
+    ["reviewFrequency", getI64Encoder()]
+  ]);
+}
+function getPermissionMetadataDecoder() {
+  return getStructDecoder([
+    [
+      "businessJustification",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["riskAssessment", getRiskAssessmentDecoder()],
+    [
+      "complianceMapping",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "relatedPermissions",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["owner", getOptionDecoder(getAddressDecoder())],
+    ["lastReview", getOptionDecoder(getI64Decoder())],
+    ["reviewFrequency", getI64Decoder()]
+  ]);
+}
+function getPermissionMetadataCodec() {
+  return combineCodec(
+    getPermissionMetadataEncoder(),
+    getPermissionMetadataDecoder()
+  );
+}
+function getPermissionScopeEncoder() {
+  return getStructEncoder([
+    ["scopeType", getScopeTypeEncoder()],
+    ["boundaries", getScopeBoundariesEncoder()],
+    ["hierarchical", getBooleanEncoder()],
+    ["inherited", getBooleanEncoder()]
+  ]);
+}
+function getPermissionScopeDecoder() {
+  return getStructDecoder([
+    ["scopeType", getScopeTypeDecoder()],
+    ["boundaries", getScopeBoundariesDecoder()],
+    ["hierarchical", getBooleanDecoder()],
+    ["inherited", getBooleanDecoder()]
+  ]);
+}
+function getPermissionScopeCodec() {
+  return combineCodec(getPermissionScopeEncoder(), getPermissionScopeDecoder());
+}
+function getPolicyMetadataEncoder() {
+  return getStructEncoder([
+    ["author", getOptionEncoder(getAddressEncoder())],
+    ["approver", getOptionEncoder(getAddressEncoder())],
+    ["approvalDate", getOptionEncoder(getI64Encoder())],
+    [
+      "businessJustification",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    [
+      "complianceReferences",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "riskAssessment",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["reviewSchedule", getReviewScheduleEncoder()]
+  ]);
+}
+function getPolicyMetadataDecoder() {
+  return getStructDecoder([
+    ["author", getOptionDecoder(getAddressDecoder())],
+    ["approver", getOptionDecoder(getAddressDecoder())],
+    ["approvalDate", getOptionDecoder(getI64Decoder())],
+    [
+      "businessJustification",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    [
+      "complianceReferences",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "riskAssessment",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["reviewSchedule", getReviewScheduleDecoder()]
+  ]);
+}
+function getPolicyMetadataCodec() {
+  return combineCodec(getPolicyMetadataEncoder(), getPolicyMetadataDecoder());
+}
+function getPolicyRuleEncoder() {
+  return getStructEncoder([
+    ["ruleId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["conditions", getArrayEncoder(getRuleConditionEncoder())],
+    ["effect", getRuleEffectEncoder()],
+    ["priority", getU8Encoder()],
+    ["enabled", getBooleanEncoder()]
+  ]);
+}
+function getPolicyRuleDecoder() {
+  return getStructDecoder([
+    ["ruleId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["conditions", getArrayDecoder(getRuleConditionDecoder())],
+    ["effect", getRuleEffectDecoder()],
+    ["priority", getU8Decoder()],
+    ["enabled", getBooleanDecoder()]
+  ]);
+}
+function getPolicyRuleCodec() {
+  return combineCodec(getPolicyRuleEncoder(), getPolicyRuleDecoder());
+}
+function getPolicyScopeEncoder() {
+  return getStructEncoder([
+    [
+      "subjects",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "resources",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "actions",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["inheritance", getScopeInheritanceEncoder()]
+  ]);
+}
+function getPolicyScopeDecoder() {
+  return getStructDecoder([
+    [
+      "subjects",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "resources",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "actions",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["inheritance", getScopeInheritanceDecoder()]
+  ]);
+}
+function getPolicyScopeCodec() {
+  return combineCodec(getPolicyScopeEncoder(), getPolicyScopeDecoder());
+}
+var PolicyStatus = /* @__PURE__ */ ((PolicyStatus2) => {
+  PolicyStatus2[PolicyStatus2["Active"] = 0] = "Active";
+  PolicyStatus2[PolicyStatus2["Inactive"] = 1] = "Inactive";
+  PolicyStatus2[PolicyStatus2["Draft"] = 2] = "Draft";
+  PolicyStatus2[PolicyStatus2["UnderReview"] = 3] = "UnderReview";
+  PolicyStatus2[PolicyStatus2["Deprecated"] = 4] = "Deprecated";
+  PolicyStatus2[PolicyStatus2["Suspended"] = 5] = "Suspended";
+  return PolicyStatus2;
+})(PolicyStatus || {});
+function getPolicyStatusEncoder() {
+  return getEnumEncoder(PolicyStatus);
+}
+function getPolicyStatusDecoder() {
+  return getEnumDecoder(PolicyStatus);
+}
+function getPolicyStatusCodec() {
+  return combineCodec(getPolicyStatusEncoder(), getPolicyStatusDecoder());
+}
+var PolicyType = /* @__PURE__ */ ((PolicyType2) => {
+  PolicyType2[PolicyType2["Allow"] = 0] = "Allow";
+  PolicyType2[PolicyType2["Deny"] = 1] = "Deny";
+  PolicyType2[PolicyType2["Conditional"] = 2] = "Conditional";
+  PolicyType2[PolicyType2["Delegated"] = 3] = "Delegated";
+  PolicyType2[PolicyType2["Temporary"] = 4] = "Temporary";
+  PolicyType2[PolicyType2["Emergency"] = 5] = "Emergency";
+  return PolicyType2;
+})(PolicyType || {});
+function getPolicyTypeEncoder() {
+  return getEnumEncoder(PolicyType);
+}
+function getPolicyTypeDecoder() {
+  return getEnumDecoder(PolicyType);
+}
+function getPolicyTypeCodec() {
+  return combineCodec(getPolicyTypeEncoder(), getPolicyTypeDecoder());
+}
+var PricingModel = /* @__PURE__ */ ((PricingModel2) => {
+  PricingModel2[PricingModel2["Fixed"] = 0] = "Fixed";
+  PricingModel2[PricingModel2["Hourly"] = 1] = "Hourly";
+  PricingModel2[PricingModel2["PerTask"] = 2] = "PerTask";
+  PricingModel2[PricingModel2["Subscription"] = 3] = "Subscription";
+  PricingModel2[PricingModel2["Auction"] = 4] = "Auction";
+  PricingModel2[PricingModel2["Dynamic"] = 5] = "Dynamic";
+  PricingModel2[PricingModel2["RevenueShare"] = 6] = "RevenueShare";
+  PricingModel2[PricingModel2["Tiered"] = 7] = "Tiered";
+  return PricingModel2;
+})(PricingModel || {});
+function getPricingModelEncoder() {
+  return getEnumEncoder(PricingModel);
+}
+function getPricingModelDecoder() {
+  return getEnumDecoder(PricingModel);
+}
+function getPricingModelCodec() {
+  return combineCodec(getPricingModelEncoder(), getPricingModelDecoder());
+}
+function getProposalAccountEncoder() {
+  return getStructEncoder([
+    ["pubkey", getAddressEncoder()],
+    ["isSigner", getBooleanEncoder()],
+    ["isWritable", getBooleanEncoder()],
+    ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getProposalAccountDecoder() {
+  return getStructDecoder([
+    ["pubkey", getAddressDecoder()],
+    ["isSigner", getBooleanDecoder()],
+    ["isWritable", getBooleanDecoder()],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getProposalAccountCodec() {
+  return combineCodec(getProposalAccountEncoder(), getProposalAccountDecoder());
+}
+function getProposalInstructionEncoder() {
+  return getStructEncoder([
+    ["programId", getAddressEncoder()],
+    ["accounts", getArrayEncoder(getProposalAccountEncoder())],
+    ["data", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+    ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getProposalInstructionDecoder() {
+  return getStructDecoder([
+    ["programId", getAddressDecoder()],
+    ["accounts", getArrayDecoder(getProposalAccountDecoder())],
+    ["data", addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getProposalInstructionCodec() {
+  return combineCodec(
+    getProposalInstructionEncoder(),
+    getProposalInstructionDecoder()
+  );
+}
+function getProposalMetadataEncoder() {
+  return getStructEncoder([
+    [
+      "ipfsHash",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "externalReferences",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "tags",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "riskAssessment",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "impactAnalysis",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "implementationTimeline",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getProposalMetadataDecoder() {
+  return getStructDecoder([
+    [
+      "ipfsHash",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "externalReferences",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "tags",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "riskAssessment",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "impactAnalysis",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "implementationTimeline",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getProposalMetadataCodec() {
+  return combineCodec(
+    getProposalMetadataEncoder(),
+    getProposalMetadataDecoder()
+  );
+}
+var ProposalStatus = /* @__PURE__ */ ((ProposalStatus2) => {
+  ProposalStatus2[ProposalStatus2["Draft"] = 0] = "Draft";
+  ProposalStatus2[ProposalStatus2["Active"] = 1] = "Active";
+  ProposalStatus2[ProposalStatus2["Passed"] = 2] = "Passed";
+  ProposalStatus2[ProposalStatus2["Failed"] = 3] = "Failed";
+  ProposalStatus2[ProposalStatus2["Executed"] = 4] = "Executed";
+  ProposalStatus2[ProposalStatus2["Cancelled"] = 5] = "Cancelled";
+  ProposalStatus2[ProposalStatus2["Expired"] = 6] = "Expired";
+  ProposalStatus2[ProposalStatus2["Queued"] = 7] = "Queued";
+  return ProposalStatus2;
+})(ProposalStatus || {});
+function getProposalStatusEncoder() {
+  return getEnumEncoder(ProposalStatus);
+}
+function getProposalStatusDecoder() {
+  return getEnumDecoder(ProposalStatus);
+}
+function getProposalStatusCodec() {
+  return combineCodec(getProposalStatusEncoder(), getProposalStatusDecoder());
+}
+var ProposalType = /* @__PURE__ */ ((ProposalType2) => {
+  ProposalType2[ProposalType2["ParameterUpdate"] = 0] = "ParameterUpdate";
+  ProposalType2[ProposalType2["ProtocolUpgrade"] = 1] = "ProtocolUpgrade";
+  ProposalType2[ProposalType2["TreasuryOperation"] = 2] = "TreasuryOperation";
+  ProposalType2[ProposalType2["FeeUpdate"] = 3] = "FeeUpdate";
+  ProposalType2[ProposalType2["SecurityUpdate"] = 4] = "SecurityUpdate";
+  ProposalType2[ProposalType2["GovernanceUpdate"] = 5] = "GovernanceUpdate";
+  ProposalType2[ProposalType2["EmergencyAction"] = 6] = "EmergencyAction";
+  ProposalType2[ProposalType2["Custom"] = 7] = "Custom";
+  return ProposalType2;
+})(ProposalType || {});
+function getProposalTypeEncoder() {
+  return getEnumEncoder(ProposalType);
+}
+function getProposalTypeDecoder() {
+  return getEnumDecoder(ProposalType);
+}
+function getProposalTypeCodec() {
+  return combineCodec(getProposalTypeEncoder(), getProposalTypeDecoder());
+}
+function getProtocolConfigUpdatedEventEncoder() {
+  return getStructEncoder([
+    ["authority", getAddressEncoder()],
+    ["feesEnabled", getBooleanEncoder()],
+    ["escrowFeeBps", getU16Encoder()],
+    ["agentRegistrationFee", getU64Encoder()],
+    ["listingFee", getU64Encoder()],
+    ["disputeFeeBps", getU16Encoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getProtocolConfigUpdatedEventDecoder() {
+  return getStructDecoder([
+    ["authority", getAddressDecoder()],
+    ["feesEnabled", getBooleanDecoder()],
+    ["escrowFeeBps", getU16Decoder()],
+    ["agentRegistrationFee", getU64Decoder()],
+    ["listingFee", getU64Decoder()],
+    ["disputeFeeBps", getU16Decoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getProtocolConfigUpdatedEventCodec() {
+  return combineCodec(
+    getProtocolConfigUpdatedEventEncoder(),
+    getProtocolConfigUpdatedEventDecoder()
+  );
+}
+var QuorumMethod = /* @__PURE__ */ ((QuorumMethod2) => {
+  QuorumMethod2[QuorumMethod2["Absolute"] = 0] = "Absolute";
+  QuorumMethod2[QuorumMethod2["Relative"] = 1] = "Relative";
+  QuorumMethod2[QuorumMethod2["Weighted"] = 2] = "Weighted";
+  QuorumMethod2[QuorumMethod2["Dynamic"] = 3] = "Dynamic";
+  return QuorumMethod2;
+})(QuorumMethod || {});
+function getQuorumMethodEncoder() {
+  return getEnumEncoder(QuorumMethod);
+}
+function getQuorumMethodDecoder() {
+  return getEnumDecoder(QuorumMethod);
+}
+function getQuorumMethodCodec() {
+  return combineCodec(getQuorumMethodEncoder(), getQuorumMethodDecoder());
+}
+function getQuorumRequirementsEncoder() {
+  return getStructEncoder([
+    ["minimumParticipation", getU8Encoder()],
+    ["approvalThreshold", getU8Encoder()],
+    ["superMajorityRequired", getBooleanEncoder()],
+    ["minimumVotingPower", getU64Encoder()],
+    ["quorumMethod", getQuorumMethodEncoder()]
+  ]);
+}
+function getQuorumRequirementsDecoder() {
+  return getStructDecoder([
+    ["minimumParticipation", getU8Decoder()],
+    ["approvalThreshold", getU8Decoder()],
+    ["superMajorityRequired", getBooleanDecoder()],
+    ["minimumVotingPower", getU64Decoder()],
+    ["quorumMethod", getQuorumMethodDecoder()]
+  ]);
+}
+function getQuorumRequirementsCodec() {
+  return combineCodec(
+    getQuorumRequirementsEncoder(),
+    getQuorumRequirementsDecoder()
+  );
+}
+function getRbacConfigInitializedEventEncoder() {
+  return getStructEncoder([
+    ["rbacConfig", getAddressEncoder()],
+    ["authority", getAddressEncoder()],
+    ["rolesCount", getU32Encoder()]
+  ]);
+}
+function getRbacConfigInitializedEventDecoder() {
+  return getStructDecoder([
+    ["rbacConfig", getAddressDecoder()],
+    ["authority", getAddressDecoder()],
+    ["rolesCount", getU32Decoder()]
+  ]);
+}
+function getRbacConfigInitializedEventCodec() {
+  return combineCodec(
+    getRbacConfigInitializedEventEncoder(),
+    getRbacConfigInitializedEventDecoder()
+  );
+}
+var ReentrancyState = /* @__PURE__ */ ((ReentrancyState2) => {
+  ReentrancyState2[ReentrancyState2["Unlocked"] = 0] = "Unlocked";
+  ReentrancyState2[ReentrancyState2["Locked"] = 1] = "Locked";
+  return ReentrancyState2;
+})(ReentrancyState || {});
+function getReentrancyStateEncoder() {
+  return getEnumEncoder(ReentrancyState);
+}
+function getReentrancyStateDecoder() {
+  return getEnumDecoder(ReentrancyState);
+}
+function getReentrancyStateCodec() {
+  return combineCodec(getReentrancyStateEncoder(), getReentrancyStateDecoder());
+}
+function getReportDataEncoder() {
+  return getStructEncoder([
+    ["summary", getReportSummaryEncoder()],
+    ["entries", getArrayEncoder(getReportEntryEncoder())],
+    ["complianceMetrics", getComplianceMetricsEncoder()],
+    ["riskIndicators", getArrayEncoder(getRiskIndicatorEncoder())],
+    [
+      "recommendations",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getReportDataDecoder() {
+  return getStructDecoder([
+    ["summary", getReportSummaryDecoder()],
+    ["entries", getArrayDecoder(getReportEntryDecoder())],
+    ["complianceMetrics", getComplianceMetricsDecoder()],
+    ["riskIndicators", getArrayDecoder(getRiskIndicatorDecoder())],
+    [
+      "recommendations",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getReportDataCodec() {
+  return combineCodec(getReportDataEncoder(), getReportDataDecoder());
+}
+function getReportEntryEncoder() {
+  return getStructEncoder([
+    ["data", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getReportEntryDecoder() {
+  return getStructDecoder([
+    ["data", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getReportEntryCodec() {
+  return combineCodec(getReportEntryEncoder(), getReportEntryDecoder());
+}
+var ReportingFrequency = /* @__PURE__ */ ((ReportingFrequency2) => {
+  ReportingFrequency2[ReportingFrequency2["Daily"] = 0] = "Daily";
+  ReportingFrequency2[ReportingFrequency2["Weekly"] = 1] = "Weekly";
+  ReportingFrequency2[ReportingFrequency2["Monthly"] = 2] = "Monthly";
+  ReportingFrequency2[ReportingFrequency2["Quarterly"] = 3] = "Quarterly";
+  ReportingFrequency2[ReportingFrequency2["Annually"] = 4] = "Annually";
+  ReportingFrequency2[ReportingFrequency2["OnDemand"] = 5] = "OnDemand";
+  return ReportingFrequency2;
+})(ReportingFrequency || {});
+function getReportingFrequencyEncoder() {
+  return getEnumEncoder(ReportingFrequency);
+}
+function getReportingFrequencyDecoder() {
+  return getEnumDecoder(ReportingFrequency);
+}
+function getReportingFrequencyCodec() {
+  return combineCodec(
+    getReportingFrequencyEncoder(),
+    getReportingFrequencyDecoder()
+  );
+}
+var ReportStatus = /* @__PURE__ */ ((ReportStatus2) => {
+  ReportStatus2[ReportStatus2["Draft"] = 0] = "Draft";
+  ReportStatus2[ReportStatus2["Generated"] = 1] = "Generated";
+  ReportStatus2[ReportStatus2["Reviewed"] = 2] = "Reviewed";
+  ReportStatus2[ReportStatus2["Approved"] = 3] = "Approved";
+  ReportStatus2[ReportStatus2["Submitted"] = 4] = "Submitted";
+  ReportStatus2[ReportStatus2["Acknowledged"] = 5] = "Acknowledged";
+  ReportStatus2[ReportStatus2["Rejected"] = 6] = "Rejected";
+  return ReportStatus2;
+})(ReportStatus || {});
+function getReportStatusEncoder() {
+  return getEnumEncoder(ReportStatus);
+}
+function getReportStatusDecoder() {
+  return getEnumDecoder(ReportStatus);
+}
+function getReportStatusCodec() {
+  return combineCodec(getReportStatusEncoder(), getReportStatusDecoder());
+}
+function getReportSummaryEncoder() {
+  return getStructEncoder([
+    ["totalTransactions", getU64Encoder()],
+    ["totalVolume", getU64Encoder()],
+    ["highRiskTransactions", getU64Encoder()],
+    ["complianceViolations", getU64Encoder()],
+    ["securityIncidents", getU64Encoder()],
+    ["averageRiskScore", getU8Encoder()]
+  ]);
+}
+function getReportSummaryDecoder() {
+  return getStructDecoder([
+    ["totalTransactions", getU64Decoder()],
+    ["totalVolume", getU64Decoder()],
+    ["highRiskTransactions", getU64Decoder()],
+    ["complianceViolations", getU64Decoder()],
+    ["securityIncidents", getU64Decoder()],
+    ["averageRiskScore", getU8Decoder()]
+  ]);
+}
+function getReportSummaryCodec() {
+  return combineCodec(getReportSummaryEncoder(), getReportSummaryDecoder());
+}
+var ReportType = /* @__PURE__ */ ((ReportType2) => {
+  ReportType2[ReportType2["FinancialTransactions"] = 0] = "FinancialTransactions";
+  ReportType2[ReportType2["SuspiciousActivity"] = 1] = "SuspiciousActivity";
+  ReportType2[ReportType2["RegulatoryCompliance"] = 2] = "RegulatoryCompliance";
+  ReportType2[ReportType2["SecurityIncidents"] = 3] = "SecurityIncidents";
+  ReportType2[ReportType2["AuditSummary"] = 4] = "AuditSummary";
+  ReportType2[ReportType2["RiskAssessment"] = 5] = "RiskAssessment";
+  ReportType2[ReportType2["GovernanceActivity"] = 6] = "GovernanceActivity";
+  ReportType2[ReportType2["DataPrivacyCompliance"] = 7] = "DataPrivacyCompliance";
+  return ReportType2;
+})(ReportType || {});
+function getReportTypeEncoder() {
+  return getEnumEncoder(ReportType);
+}
+function getReportTypeDecoder() {
+  return getEnumDecoder(ReportType);
+}
+function getReportTypeCodec() {
+  return combineCodec(getReportTypeEncoder(), getReportTypeDecoder());
+}
+function getReputationComponentEncoder() {
+  return getStructEncoder([
+    ["sourceType", getReputationSourceTypeEncoder()],
+    ["score", getU64Encoder()],
+    ["weight", getU32Encoder()],
+    ["lastUpdated", getI64Encoder()],
+    ["dataPoints", getU64Encoder()]
+  ]);
+}
+function getReputationComponentDecoder() {
+  return getStructDecoder([
+    ["sourceType", getReputationSourceTypeDecoder()],
+    ["score", getU64Decoder()],
+    ["weight", getU32Decoder()],
+    ["lastUpdated", getI64Decoder()],
+    ["dataPoints", getU64Decoder()]
+  ]);
+}
+function getReputationComponentCodec() {
+  return combineCodec(
+    getReputationComponentEncoder(),
+    getReputationComponentDecoder()
+  );
+}
+function getReputationMetricsInitializedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getReputationMetricsInitializedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getReputationMetricsInitializedEventCodec() {
+  return combineCodec(
+    getReputationMetricsInitializedEventEncoder(),
+    getReputationMetricsInitializedEventDecoder()
+  );
+}
+function getReputationPaymentRecordedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    [
+      "paymentSignature",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["amount", getU64Encoder()],
+    ["responseTimeMs", getU64Encoder()],
+    ["success", getBooleanEncoder()],
+    ["newReputationScore", getU64Encoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getReputationPaymentRecordedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    [
+      "paymentSignature",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["amount", getU64Decoder()],
+    ["responseTimeMs", getU64Decoder()],
+    ["success", getBooleanDecoder()],
+    ["newReputationScore", getU64Decoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getReputationPaymentRecordedEventCodec() {
+  return combineCodec(
+    getReputationPaymentRecordedEventEncoder(),
+    getReputationPaymentRecordedEventDecoder()
+  );
+}
+function getReputationRatingSubmittedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["client", getAddressEncoder()],
+    ["rating", getU8Encoder()],
+    ["newReputationScore", getU64Encoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getReputationRatingSubmittedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["client", getAddressDecoder()],
+    ["rating", getU8Decoder()],
+    ["newReputationScore", getU64Decoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getReputationRatingSubmittedEventCodec() {
+  return combineCodec(
+    getReputationRatingSubmittedEventEncoder(),
+    getReputationRatingSubmittedEventDecoder()
+  );
+}
+var ReputationSourceType = /* @__PURE__ */ ((ReputationSourceType2) => {
+  ReputationSourceType2[ReputationSourceType2["AccountAge"] = 0] = "AccountAge";
+  ReputationSourceType2[ReputationSourceType2["X402Transactions"] = 1] = "X402Transactions";
+  ReputationSourceType2[ReputationSourceType2["UserReviews"] = 2] = "UserReviews";
+  ReputationSourceType2[ReputationSourceType2["ElizaOSReputation"] = 3] = "ElizaOSReputation";
+  ReputationSourceType2[ReputationSourceType2["CrossmintVerification"] = 4] = "CrossmintVerification";
+  ReputationSourceType2[ReputationSourceType2["EndpointReliability"] = 5] = "EndpointReliability";
+  ReputationSourceType2[ReputationSourceType2["JobCompletions"] = 6] = "JobCompletions";
+  ReputationSourceType2[ReputationSourceType2["SkillEndorsements"] = 7] = "SkillEndorsements";
+  return ReputationSourceType2;
+})(ReputationSourceType || {});
+function getReputationSourceTypeEncoder() {
+  return getEnumEncoder(ReputationSourceType);
+}
+function getReputationSourceTypeDecoder() {
+  return getEnumDecoder(ReputationSourceType);
+}
+function getReputationSourceTypeCodec() {
+  return combineCodec(
+    getReputationSourceTypeEncoder(),
+    getReputationSourceTypeDecoder()
+  );
+}
+function getReputationTagsUpdatedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["totalTags", getU32Encoder()],
+    ["skillTagsCount", getU32Encoder()],
+    ["behaviorTagsCount", getU32Encoder()],
+    ["complianceTagsCount", getU32Encoder()],
+    ["tagScoresCount", getU32Encoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getReputationTagsUpdatedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["totalTags", getU32Decoder()],
+    ["skillTagsCount", getU32Decoder()],
+    ["behaviorTagsCount", getU32Decoder()],
+    ["complianceTagsCount", getU32Decoder()],
+    ["tagScoresCount", getU32Decoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getReputationTagsUpdatedEventCodec() {
+  return combineCodec(
+    getReputationTagsUpdatedEventEncoder(),
+    getReputationTagsUpdatedEventDecoder()
+  );
+}
+function getResourceConstraintsEncoder() {
+  return getStructEncoder([
+    ["maxUsage", getU8Encoder()]
+  ]);
+}
+function getResourceConstraintsDecoder() {
+  return getStructDecoder([
+    ["maxUsage", getU8Decoder()]
+  ]);
+}
+function getResourceConstraintsCodec() {
+  return combineCodec(getResourceConstraintsEncoder(), getResourceConstraintsDecoder());
+}
+function getReviewScheduleEncoder() {
+  return getStructEncoder([
+    ["frequency", getI64Encoder()],
+    ["lastReview", getOptionEncoder(getI64Encoder())],
+    ["nextReview", getI64Encoder()],
+    ["reviewOwners", getArrayEncoder(getAddressEncoder())],
+    [
+      "reviewCriteria",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getReviewScheduleDecoder() {
+  return getStructDecoder([
+    ["frequency", getI64Decoder()],
+    ["lastReview", getOptionDecoder(getI64Decoder())],
+    ["nextReview", getI64Decoder()],
+    ["reviewOwners", getArrayDecoder(getAddressDecoder())],
+    [
+      "reviewCriteria",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getReviewScheduleCodec() {
+  return combineCodec(getReviewScheduleEncoder(), getReviewScheduleDecoder());
+}
+function getRiskAcceptanceEncoder() {
+  return getStructEncoder([
+    ["accepted", getBooleanEncoder()],
+    ["acceptingAuthority", getOptionEncoder(getAddressEncoder())],
+    ["acceptanceDate", getOptionEncoder(getI64Encoder())],
+    [
+      "reasoning",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["reviewDate", getOptionEncoder(getI64Encoder())]
+  ]);
+}
+function getRiskAcceptanceDecoder() {
+  return getStructDecoder([
+    ["accepted", getBooleanDecoder()],
+    ["acceptingAuthority", getOptionDecoder(getAddressDecoder())],
+    ["acceptanceDate", getOptionDecoder(getI64Decoder())],
+    [
+      "reasoning",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["reviewDate", getOptionDecoder(getI64Decoder())]
+  ]);
+}
+function getRiskAcceptanceCodec() {
+  return combineCodec(getRiskAcceptanceEncoder(), getRiskAcceptanceDecoder());
+}
+function getRiskAssessmentEncoder() {
+  return getStructEncoder([
+    ["riskScore", getU8Encoder()],
+    ["riskFactors", getArrayEncoder(getRiskFactorEncoder())],
+    [
+      "mitigationMeasures",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["riskAcceptance", getRiskAcceptanceEncoder()]
+  ]);
+}
+function getRiskAssessmentDecoder() {
+  return getStructDecoder([
+    ["riskScore", getU8Decoder()],
+    ["riskFactors", getArrayDecoder(getRiskFactorDecoder())],
+    [
+      "mitigationMeasures",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["riskAcceptance", getRiskAcceptanceDecoder()]
+  ]);
+}
+function getRiskAssessmentCodec() {
+  return combineCodec(getRiskAssessmentEncoder(), getRiskAssessmentDecoder());
+}
+var RiskCategory = /* @__PURE__ */ ((RiskCategory2) => {
+  RiskCategory2[RiskCategory2["Operational"] = 0] = "Operational";
+  RiskCategory2[RiskCategory2["Financial"] = 1] = "Financial";
+  RiskCategory2[RiskCategory2["Compliance"] = 2] = "Compliance";
+  RiskCategory2[RiskCategory2["Security"] = 3] = "Security";
+  RiskCategory2[RiskCategory2["Reputational"] = 4] = "Reputational";
+  RiskCategory2[RiskCategory2["Technical"] = 5] = "Technical";
+  RiskCategory2[RiskCategory2["Legal"] = 6] = "Legal";
+  return RiskCategory2;
+})(RiskCategory || {});
+function getRiskCategoryEncoder() {
+  return getEnumEncoder(RiskCategory);
+}
+function getRiskCategoryDecoder() {
+  return getEnumDecoder(RiskCategory);
+}
+function getRiskCategoryCodec() {
+  return combineCodec(getRiskCategoryEncoder(), getRiskCategoryDecoder());
+}
+function getRiskFactorEncoder() {
+  return getStructEncoder([
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["category", getRiskCategoryEncoder()],
+    ["impact", getU8Encoder()],
+    ["likelihood", getU8Encoder()],
+    ["riskScore", getU8Encoder()]
+  ]);
+}
+function getRiskFactorDecoder() {
+  return getStructDecoder([
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["category", getRiskCategoryDecoder()],
+    ["impact", getU8Decoder()],
+    ["likelihood", getU8Decoder()],
+    ["riskScore", getU8Decoder()]
+  ]);
+}
+function getRiskFactorCodec() {
+  return combineCodec(getRiskFactorEncoder(), getRiskFactorDecoder());
+}
+function getRiskIndicatorEncoder() {
+  return getStructEncoder([
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["currentValue", getU64Encoder()],
+    ["thresholdValue", getU64Encoder()],
+    ["trend", getTrendDirectionEncoder()],
+    ["severity", getViolationSeverityEncoder()],
+    [
+      "recommendedActions",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getRiskIndicatorDecoder() {
+  return getStructDecoder([
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["currentValue", getU64Decoder()],
+    ["thresholdValue", getU64Decoder()],
+    ["trend", getTrendDirectionDecoder()],
+    ["severity", getViolationSeverityDecoder()],
+    [
+      "recommendedActions",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getRiskIndicatorCodec() {
+  return combineCodec(getRiskIndicatorEncoder(), getRiskIndicatorDecoder());
+}
+var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
+  RiskLevel2[RiskLevel2["Low"] = 0] = "Low";
+  RiskLevel2[RiskLevel2["Medium"] = 1] = "Medium";
+  RiskLevel2[RiskLevel2["High"] = 2] = "High";
+  RiskLevel2[RiskLevel2["Critical"] = 3] = "Critical";
+  return RiskLevel2;
+})(RiskLevel || {});
+function getRiskLevelEncoder() {
+  return getEnumEncoder(RiskLevel);
+}
+function getRiskLevelDecoder() {
+  return getEnumDecoder(RiskLevel);
+}
+function getRiskLevelCodec() {
+  return combineCodec(getRiskLevelEncoder(), getRiskLevelDecoder());
+}
+function getRoleEncoder() {
+  return getStructEncoder([
+    ["roleId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["roleType", getRoleTypeEncoder()],
+    [
+      "permissions",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["constraints", getRoleConstraintsEncoder()],
+    [
+      "inheritsFrom",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["metadata", getRoleMetadataEncoder()],
+    ["status", getRoleStatusEncoder()],
+    ["createdAt", getI64Encoder()],
+    ["modifiedAt", getI64Encoder()]
+  ]);
+}
+function getRoleDecoder() {
+  return getStructDecoder([
+    ["roleId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["roleType", getRoleTypeDecoder()],
+    [
+      "permissions",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["constraints", getRoleConstraintsDecoder()],
+    [
+      "inheritsFrom",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["metadata", getRoleMetadataDecoder()],
+    ["status", getRoleStatusDecoder()],
+    ["createdAt", getI64Decoder()],
+    ["modifiedAt", getI64Decoder()]
+  ]);
+}
+function getRoleCodec() {
+  return combineCodec(getRoleEncoder(), getRoleDecoder());
+}
+function getRoleConstraintsEncoder() {
+  return getStructEncoder([
+    ["timeConstraints", getOptionEncoder(getTimeConstraintsEncoder())],
+    ["locationConstraints", getOptionEncoder(getLocationConstraintsEncoder())],
+    ["resourceConstraints", getOptionEncoder(getResourceConstraintsEncoder())],
+    ["sessionConstraints", getOptionEncoder(getSessionConstraintsEncoder())],
+    ["sodConstraints", getArrayEncoder(getSodConstraintEncoder())],
+    ["maxConcurrentSessions", getOptionEncoder(getU32Encoder())],
+    [
+      "activationRequirements",
+      getArrayEncoder(getActivationRequirementEncoder())
+    ]
+  ]);
+}
+function getRoleConstraintsDecoder() {
+  return getStructDecoder([
+    ["timeConstraints", getOptionDecoder(getTimeConstraintsDecoder())],
+    ["locationConstraints", getOptionDecoder(getLocationConstraintsDecoder())],
+    ["resourceConstraints", getOptionDecoder(getResourceConstraintsDecoder())],
+    ["sessionConstraints", getOptionDecoder(getSessionConstraintsDecoder())],
+    ["sodConstraints", getArrayDecoder(getSodConstraintDecoder())],
+    ["maxConcurrentSessions", getOptionDecoder(getU32Decoder())],
+    [
+      "activationRequirements",
+      getArrayDecoder(getActivationRequirementDecoder())
+    ]
+  ]);
+}
+function getRoleConstraintsCodec() {
+  return combineCodec(getRoleConstraintsEncoder(), getRoleConstraintsDecoder());
+}
+function getRoleMetadataEncoder() {
+  return getStructEncoder([
+    [
+      "businessPurpose",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["riskLevel", getRiskLevelEncoder()],
+    ["dataAccessLevel", getDataAccessLevelEncoder()],
+    [
+      "complianceRequirements",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["roleOwner", getOptionEncoder(getAddressEncoder())],
+    ["roleCustodian", getOptionEncoder(getAddressEncoder())],
+    ["reviewFrequency", getI64Encoder()],
+    ["lastReview", getOptionEncoder(getI64Encoder())],
+    ["nextReview", getOptionEncoder(getI64Encoder())]
+  ]);
+}
+function getRoleMetadataDecoder() {
+  return getStructDecoder([
+    [
+      "businessPurpose",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["riskLevel", getRiskLevelDecoder()],
+    ["dataAccessLevel", getDataAccessLevelDecoder()],
+    [
+      "complianceRequirements",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["roleOwner", getOptionDecoder(getAddressDecoder())],
+    ["roleCustodian", getOptionDecoder(getAddressDecoder())],
+    ["reviewFrequency", getI64Decoder()],
+    ["lastReview", getOptionDecoder(getI64Decoder())],
+    ["nextReview", getOptionDecoder(getI64Decoder())]
+  ]);
+}
+function getRoleMetadataCodec() {
+  return combineCodec(getRoleMetadataEncoder(), getRoleMetadataDecoder());
+}
+var RoleStatus = /* @__PURE__ */ ((RoleStatus2) => {
+  RoleStatus2[RoleStatus2["Active"] = 0] = "Active";
+  RoleStatus2[RoleStatus2["Inactive"] = 1] = "Inactive";
+  RoleStatus2[RoleStatus2["Deprecated"] = 2] = "Deprecated";
+  RoleStatus2[RoleStatus2["UnderReview"] = 3] = "UnderReview";
+  RoleStatus2[RoleStatus2["Suspended"] = 4] = "Suspended";
+  return RoleStatus2;
+})(RoleStatus || {});
+function getRoleStatusEncoder() {
+  return getEnumEncoder(RoleStatus);
+}
+function getRoleStatusDecoder() {
+  return getEnumDecoder(RoleStatus);
+}
+function getRoleStatusCodec() {
+  return combineCodec(getRoleStatusEncoder(), getRoleStatusDecoder());
+}
+var RoleType = /* @__PURE__ */ ((RoleType2) => {
+  RoleType2[RoleType2["Administrative"] = 0] = "Administrative";
+  RoleType2[RoleType2["Operational"] = 1] = "Operational";
+  RoleType2[RoleType2["ReadOnly"] = 2] = "ReadOnly";
+  RoleType2[RoleType2["Compliance"] = 3] = "Compliance";
+  RoleType2[RoleType2["Emergency"] = 4] = "Emergency";
+  RoleType2[RoleType2["Custom"] = 5] = "Custom";
+  RoleType2[RoleType2["Service"] = 6] = "Service";
+  RoleType2[RoleType2["Guest"] = 7] = "Guest";
+  return RoleType2;
+})(RoleType || {});
+function getRoleTypeEncoder() {
+  return getEnumEncoder(RoleType);
+}
+function getRoleTypeDecoder() {
+  return getEnumDecoder(RoleType);
+}
+function getRoleTypeCodec() {
+  return combineCodec(getRoleTypeEncoder(), getRoleTypeDecoder());
+}
+function getRuleConditionEncoder() {
+  return getStructEncoder([
+    ["expression", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getRuleConditionDecoder() {
+  return getStructDecoder([
+    ["expression", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getRuleConditionCodec() {
+  return combineCodec(getRuleConditionEncoder(), getRuleConditionDecoder());
+}
+var RuleEffect = /* @__PURE__ */ ((RuleEffect2) => {
+  RuleEffect2[RuleEffect2["Allow"] = 0] = "Allow";
+  RuleEffect2[RuleEffect2["Deny"] = 1] = "Deny";
+  RuleEffect2[RuleEffect2["AuditOnly"] = 2] = "AuditOnly";
+  RuleEffect2[RuleEffect2["RequireApproval"] = 3] = "RequireApproval";
+  RuleEffect2[RuleEffect2["RequireMfa"] = 4] = "RequireMfa";
+  RuleEffect2[RuleEffect2["RequireJustification"] = 5] = "RequireJustification";
+  return RuleEffect2;
+})(RuleEffect || {});
+function getRuleEffectEncoder() {
+  return getEnumEncoder(RuleEffect);
+}
+function getRuleEffectDecoder() {
+  return getEnumDecoder(RuleEffect);
+}
+function getRuleEffectCodec() {
+  return combineCodec(getRuleEffectEncoder(), getRuleEffectDecoder());
+}
+function getScopeBoundariesEncoder() {
+  return getStructEncoder([
+    [
+      "includedResources",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "excludedResources",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "resourcePatterns",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    [
+      "hierarchicalBoundaries",
+      getArrayEncoder(getHierarchicalBoundaryEncoder())
+    ]
+  ]);
+}
+function getScopeBoundariesDecoder() {
+  return getStructDecoder([
+    [
+      "includedResources",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "excludedResources",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "resourcePatterns",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    [
+      "hierarchicalBoundaries",
+      getArrayDecoder(getHierarchicalBoundaryDecoder())
+    ]
+  ]);
+}
+function getScopeBoundariesCodec() {
+  return combineCodec(getScopeBoundariesEncoder(), getScopeBoundariesDecoder());
+}
+var ScopeInheritance = /* @__PURE__ */ ((ScopeInheritance2) => {
+  ScopeInheritance2[ScopeInheritance2["None"] = 0] = "None";
+  ScopeInheritance2[ScopeInheritance2["Hierarchical"] = 1] = "Hierarchical";
+  ScopeInheritance2[ScopeInheritance2["Delegated"] = 2] = "Delegated";
+  ScopeInheritance2[ScopeInheritance2["Inherited"] = 3] = "Inherited";
+  return ScopeInheritance2;
+})(ScopeInheritance || {});
+function getScopeInheritanceEncoder() {
+  return getEnumEncoder(ScopeInheritance);
+}
+function getScopeInheritanceDecoder() {
+  return getEnumDecoder(ScopeInheritance);
+}
+function getScopeInheritanceCodec() {
+  return combineCodec(
+    getScopeInheritanceEncoder(),
+    getScopeInheritanceDecoder()
+  );
+}
+var ScopeType = /* @__PURE__ */ ((ScopeType2) => {
+  ScopeType2[ScopeType2["Global"] = 0] = "Global";
+  ScopeType2[ScopeType2["Organization"] = 1] = "Organization";
+  ScopeType2[ScopeType2["Department"] = 2] = "Department";
+  ScopeType2[ScopeType2["Project"] = 3] = "Project";
+  ScopeType2[ScopeType2["Resource"] = 4] = "Resource";
+  ScopeType2[ScopeType2["Individual"] = 5] = "Individual";
+  return ScopeType2;
+})(ScopeType || {});
+function getScopeTypeEncoder() {
+  return getEnumEncoder(ScopeType);
+}
+function getScopeTypeDecoder() {
+  return getEnumDecoder(ScopeType);
+}
+function getScopeTypeCodec() {
+  return combineCodec(getScopeTypeEncoder(), getScopeTypeDecoder());
+}
+var SecurityEventType = /* @__PURE__ */ ((SecurityEventType2) => {
+  SecurityEventType2[SecurityEventType2["AccountLockout"] = 0] = "AccountLockout";
+  SecurityEventType2[SecurityEventType2["PasswordChange"] = 1] = "PasswordChange";
+  SecurityEventType2[SecurityEventType2["PrivilegeEscalation"] = 2] = "PrivilegeEscalation";
+  SecurityEventType2[SecurityEventType2["SuspiciousActivity"] = 3] = "SuspiciousActivity";
+  SecurityEventType2[SecurityEventType2["PolicyViolation"] = 4] = "PolicyViolation";
+  SecurityEventType2[SecurityEventType2["AccessDenied"] = 5] = "AccessDenied";
+  SecurityEventType2[SecurityEventType2["DataBreach"] = 6] = "DataBreach";
+  SecurityEventType2[SecurityEventType2["SystemCompromise"] = 7] = "SystemCompromise";
+  return SecurityEventType2;
+})(SecurityEventType || {});
+function getSecurityEventTypeEncoder() {
+  return getEnumEncoder(SecurityEventType);
+}
+function getSecurityEventTypeDecoder() {
+  return getEnumDecoder(SecurityEventType);
+}
+function getSecurityEventTypeCodec() {
+  return combineCodec(
+    getSecurityEventTypeEncoder(),
+    getSecurityEventTypeDecoder()
+  );
+}
+function getSecurityPoliciesEncoder() {
+  return getStructEncoder([
+    ["authentication", getAuthenticationPoliciesEncoder()],
+    ["authorization", getAuthorizationPoliciesEncoder()],
+    ["password", getPasswordPoliciesEncoder()],
+    ["session", getSessionPoliciesEncoder()],
+    ["dataProtection", getDataProtectionPoliciesEncoder()],
+    ["networkSecurity", getNetworkSecurityPoliciesEncoder()],
+    ["incidentResponse", getIncidentResponsePoliciesEncoder()],
+    ["compliance", getCompliancePoliciesEncoder()]
+  ]);
+}
+function getSecurityPoliciesDecoder() {
+  return getStructDecoder([
+    ["authentication", getAuthenticationPoliciesDecoder()],
+    ["authorization", getAuthorizationPoliciesDecoder()],
+    ["password", getPasswordPoliciesDecoder()],
+    ["session", getSessionPoliciesDecoder()],
+    ["dataProtection", getDataProtectionPoliciesDecoder()],
+    ["networkSecurity", getNetworkSecurityPoliciesDecoder()],
+    ["incidentResponse", getIncidentResponsePoliciesDecoder()],
+    ["compliance", getCompliancePoliciesDecoder()]
+  ]);
+}
+function getSecurityPoliciesCodec() {
+  return combineCodec(
+    getSecurityPoliciesEncoder(),
+    getSecurityPoliciesDecoder()
+  );
+}
+function getServiceEndpointEncoder() {
+  return getStructEncoder([
+    ["id", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["serviceType", getServiceEndpointTypeEncoder()],
+    [
+      "serviceEndpoint",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getServiceEndpointDecoder() {
+  return getStructDecoder([
+    ["id", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["serviceType", getServiceEndpointTypeDecoder()],
+    [
+      "serviceEndpoint",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getServiceEndpointCodec() {
+  return combineCodec(getServiceEndpointEncoder(), getServiceEndpointDecoder());
+}
+var ServiceEndpointType = /* @__PURE__ */ ((ServiceEndpointType2) => {
+  ServiceEndpointType2[ServiceEndpointType2["AIAgentService"] = 0] = "AIAgentService";
+  ServiceEndpointType2[ServiceEndpointType2["DIDCommMessaging"] = 1] = "DIDCommMessaging";
+  ServiceEndpointType2[ServiceEndpointType2["CredentialRepository"] = 2] = "CredentialRepository";
+  ServiceEndpointType2[ServiceEndpointType2["LinkedDomains"] = 3] = "LinkedDomains";
+  ServiceEndpointType2[ServiceEndpointType2["Custom"] = 4] = "Custom";
+  return ServiceEndpointType2;
+})(ServiceEndpointType || {});
+function getServiceEndpointTypeEncoder() {
+  return getEnumEncoder(ServiceEndpointType);
+}
+function getServiceEndpointTypeDecoder() {
+  return getEnumDecoder(ServiceEndpointType);
+}
+function getServiceEndpointTypeCodec() {
+  return combineCodec(
+    getServiceEndpointTypeEncoder(),
+    getServiceEndpointTypeDecoder()
+  );
+}
+function getSessionConstraintsEncoder() {
+  return getStructEncoder([
+    ["maxSessionDuration", getI64Encoder()],
+    ["idleTimeout", getI64Encoder()],
+    ["reauthInterval", getI64Encoder()],
+    ["mfaRequired", getBooleanEncoder()],
+    ["deviceFingerprinting", getBooleanEncoder()],
+    ["sessionEncryption", getBooleanEncoder()]
+  ]);
+}
+function getSessionConstraintsDecoder() {
+  return getStructDecoder([
+    ["maxSessionDuration", getI64Decoder()],
+    ["idleTimeout", getI64Decoder()],
+    ["reauthInterval", getI64Decoder()],
+    ["mfaRequired", getBooleanDecoder()],
+    ["deviceFingerprinting", getBooleanDecoder()],
+    ["sessionEncryption", getBooleanDecoder()]
+  ]);
+}
+function getSessionConstraintsCodec() {
+  return combineCodec(
+    getSessionConstraintsEncoder(),
+    getSessionConstraintsDecoder()
+  );
+}
+function getSessionPoliciesEncoder() {
+  return getStructEncoder([
+    ["maxSessionDuration", getI64Encoder()],
+    ["idleTimeout", getI64Encoder()],
+    ["concurrentSessions", getU8Encoder()]
+  ]);
+}
+function getSessionPoliciesDecoder() {
+  return getStructDecoder([
+    ["maxSessionDuration", getI64Decoder()],
+    ["idleTimeout", getI64Decoder()],
+    ["concurrentSessions", getU8Decoder()]
+  ]);
+}
+function getSessionPoliciesCodec() {
+  return combineCodec(getSessionPoliciesEncoder(), getSessionPoliciesDecoder());
+}
+var SlashReason = /* @__PURE__ */ ((SlashReason2) => {
+  SlashReason2[SlashReason2["Fraud"] = 0] = "Fraud";
+  SlashReason2[SlashReason2["DisputeLoss"] = 1] = "DisputeLoss";
+  SlashReason2[SlashReason2["Custom"] = 2] = "Custom";
+  return SlashReason2;
+})(SlashReason || {});
+function getSlashReasonEncoder() {
+  return getEnumEncoder(SlashReason);
+}
+function getSlashReasonDecoder() {
+  return getEnumDecoder(SlashReason);
+}
+function getSlashReasonCodec() {
+  return combineCodec(getSlashReasonEncoder(), getSlashReasonDecoder());
+}
+function getSodConstraintEncoder() {
+  return getStructEncoder([
+    ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    [
+      "conflictingRoles",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["constraintType", getSodConstraintTypeEncoder()],
+    ["enforcementLevel", getEnforcementLevelEncoder()],
+    [
+      "exceptionProcedures",
+      getArrayEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getSodConstraintDecoder() {
+  return getStructDecoder([
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    [
+      "conflictingRoles",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["constraintType", getSodConstraintTypeDecoder()],
+    ["enforcementLevel", getEnforcementLevelDecoder()],
+    [
+      "exceptionProcedures",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getSodConstraintCodec() {
+  return combineCodec(getSodConstraintEncoder(), getSodConstraintDecoder());
+}
+var SodConstraintType = /* @__PURE__ */ ((SodConstraintType2) => {
+  SodConstraintType2[SodConstraintType2["Static"] = 0] = "Static";
+  SodConstraintType2[SodConstraintType2["Dynamic"] = 1] = "Dynamic";
+  SodConstraintType2[SodConstraintType2["Temporal"] = 2] = "Temporal";
+  SodConstraintType2[SodConstraintType2["Contextual"] = 3] = "Contextual";
+  return SodConstraintType2;
+})(SodConstraintType || {});
+function getSodConstraintTypeEncoder() {
+  return getEnumEncoder(SodConstraintType);
+}
+function getSodConstraintTypeDecoder() {
+  return getEnumDecoder(SodConstraintType);
+}
+function getSodConstraintTypeCodec() {
+  return combineCodec(
+    getSodConstraintTypeEncoder(),
+    getSodConstraintTypeDecoder()
+  );
+}
+function getSourceReputationUpdatedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["sourceName", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["sourceScore", getU16Encoder()],
+    ["weightedAggregateScore", getU64Encoder()],
+    ["hasConflict", getBooleanEncoder()],
+    ["totalSources", getU32Encoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getSourceReputationUpdatedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["sourceName", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["sourceScore", getU16Decoder()],
+    ["weightedAggregateScore", getU64Decoder()],
+    ["hasConflict", getBooleanDecoder()],
+    ["totalSources", getU32Decoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getSourceReputationUpdatedEventCodec() {
+  return combineCodec(
+    getSourceReputationUpdatedEventEncoder(),
+    getSourceReputationUpdatedEventDecoder()
+  );
+}
+function getSourceScoreEncoder() {
+  return getStructEncoder([
+    ["sourceName", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["score", getU16Encoder()],
+    ["weight", getU16Encoder()],
+    ["dataPoints", getU32Encoder()],
+    ["reliability", getU16Encoder()],
+    ["lastUpdated", getI64Encoder()]
+  ]);
+}
+function getSourceScoreDecoder() {
+  return getStructDecoder([
+    ["sourceName", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["score", getU16Decoder()],
+    ["weight", getU16Decoder()],
+    ["dataPoints", getU32Decoder()],
+    ["reliability", getU16Decoder()],
+    ["lastUpdated", getI64Decoder()]
+  ]);
+}
+function getSourceScoreCodec() {
+  return combineCodec(getSourceScoreEncoder(), getSourceScoreDecoder());
+}
+var StepUpTrigger = /* @__PURE__ */ ((StepUpTrigger2) => {
+  StepUpTrigger2[StepUpTrigger2["HighRiskAction"] = 0] = "HighRiskAction";
+  StepUpTrigger2[StepUpTrigger2["SensitiveData"] = 1] = "SensitiveData";
+  StepUpTrigger2[StepUpTrigger2["LargeTransaction"] = 2] = "LargeTransaction";
+  StepUpTrigger2[StepUpTrigger2["NewDevice"] = 3] = "NewDevice";
+  StepUpTrigger2[StepUpTrigger2["UnusualLocation"] = 4] = "UnusualLocation";
+  StepUpTrigger2[StepUpTrigger2["TimeBasedRisk"] = 5] = "TimeBasedRisk";
+  StepUpTrigger2[StepUpTrigger2["BehaviorAnomaly"] = 6] = "BehaviorAnomaly";
+  return StepUpTrigger2;
+})(StepUpTrigger || {});
+function getStepUpTriggerEncoder() {
+  return getEnumEncoder(StepUpTrigger);
+}
+function getStepUpTriggerDecoder() {
+  return getEnumDecoder(StepUpTrigger);
+}
+function getStepUpTriggerCodec() {
+  return combineCodec(getStepUpTriggerEncoder(), getStepUpTriggerDecoder());
+}
+function getSubmissionDetailsEncoder() {
+  return getStructEncoder([
+    ["submittedAt", getI64Encoder()],
+    ["regulatoryBody", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    [
+      "submissionReference",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["acknowledged", getBooleanEncoder()],
+    ["acknowledgedAt", getOptionEncoder(getI64Encoder())],
+    [
+      "regulatoryResponse",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ]
+  ]);
+}
+function getSubmissionDetailsDecoder() {
+  return getStructDecoder([
+    ["submittedAt", getI64Decoder()],
+    ["regulatoryBody", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    [
+      "submissionReference",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["acknowledged", getBooleanDecoder()],
+    ["acknowledgedAt", getOptionDecoder(getI64Decoder())],
+    [
+      "regulatoryResponse",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ]
+  ]);
+}
+function getSubmissionDetailsCodec() {
+  return combineCodec(
+    getSubmissionDetailsEncoder(),
+    getSubmissionDetailsDecoder()
+  );
+}
+function getTagDecayAppliedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["tagsRemoved", getU32Encoder()],
+    ["remainingTags", getU32Encoder()],
+    ["timestamp", getI64Encoder()]
+  ]);
+}
+function getTagDecayAppliedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["tagsRemoved", getU32Decoder()],
+    ["remainingTags", getU32Decoder()],
+    ["timestamp", getI64Decoder()]
+  ]);
+}
+function getTagDecayAppliedEventCodec() {
+  return combineCodec(
+    getTagDecayAppliedEventEncoder(),
+    getTagDecayAppliedEventDecoder()
+  );
+}
+function getTagScoreEncoder() {
+  return getStructEncoder([
+    ["tagName", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["confidence", getU16Encoder()],
+    ["evidenceCount", getU32Encoder()],
+    ["lastUpdated", getI64Encoder()]
+  ]);
+}
+function getTagScoreDecoder() {
+  return getStructDecoder([
+    ["tagName", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["confidence", getU16Decoder()],
+    ["evidenceCount", getU32Decoder()],
+    ["lastUpdated", getI64Decoder()]
+  ]);
+}
+function getTagScoreCodec() {
+  return combineCodec(getTagScoreEncoder(), getTagScoreDecoder());
+}
+function getTierUpdatedEventEncoder() {
+  return getStructEncoder([
+    ["agent", getAddressEncoder()],
+    ["oldTier", getAccessTierEncoder()],
+    ["newTier", getAccessTierEncoder()],
+    ["totalStaked", getU64Encoder()],
+    ["dailyApiCalls", getU32Encoder()],
+    ["votingPower", getU64Encoder()]
+  ]);
+}
+function getTierUpdatedEventDecoder() {
+  return getStructDecoder([
+    ["agent", getAddressDecoder()],
+    ["oldTier", getAccessTierDecoder()],
+    ["newTier", getAccessTierDecoder()],
+    ["totalStaked", getU64Decoder()],
+    ["dailyApiCalls", getU32Decoder()],
+    ["votingPower", getU64Decoder()]
+  ]);
+}
+function getTierUpdatedEventCodec() {
+  return combineCodec(
+    getTierUpdatedEventEncoder(),
+    getTierUpdatedEventDecoder()
+  );
+}
+function getTimeConstraintsEncoder() {
+  return getStructEncoder([
+    ["allowedHours", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+    ["allowedDays", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+    ["timezone", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["maxSessionDuration", getOptionEncoder(getI64Encoder())],
+    ["expiresAt", getOptionEncoder(getI64Encoder())],
+    ["reactivationPeriod", getOptionEncoder(getI64Encoder())]
+  ]);
+}
+function getTimeConstraintsDecoder() {
+  return getStructDecoder([
+    ["allowedHours", addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())],
+    ["allowedDays", addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())],
+    ["timezone", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["maxSessionDuration", getOptionDecoder(getI64Decoder())],
+    ["expiresAt", getOptionDecoder(getI64Decoder())],
+    ["reactivationPeriod", getOptionDecoder(getI64Decoder())]
+  ]);
+}
+function getTimeConstraintsCodec() {
+  return combineCodec(getTimeConstraintsEncoder(), getTimeConstraintsDecoder());
+}
+function getTimeLockEncoder() {
+  return getStructEncoder([
+    ["duration", getI64Encoder()],
+    ["lockedAt", getI64Encoder()],
+    ["unlocksAt", getI64Encoder()],
+    ["earlyUnlockConditions", getArrayEncoder(getExecutionConditionEncoder())],
+    ["lockType", getTimeLockTypeEncoder()],
+    ["cancellable", getBooleanEncoder()]
+  ]);
+}
+function getTimeLockDecoder() {
+  return getStructDecoder([
+    ["duration", getI64Decoder()],
+    ["lockedAt", getI64Decoder()],
+    ["unlocksAt", getI64Decoder()],
+    ["earlyUnlockConditions", getArrayDecoder(getExecutionConditionDecoder())],
+    ["lockType", getTimeLockTypeDecoder()],
+    ["cancellable", getBooleanDecoder()]
+  ]);
+}
+function getTimeLockCodec() {
+  return combineCodec(getTimeLockEncoder(), getTimeLockDecoder());
+}
+var TimeLockType = /* @__PURE__ */ ((TimeLockType2) => {
+  TimeLockType2[TimeLockType2["Standard"] = 0] = "Standard";
+  TimeLockType2[TimeLockType2["Vesting"] = 1] = "Vesting";
+  TimeLockType2[TimeLockType2["Emergency"] = 2] = "Emergency";
+  TimeLockType2[TimeLockType2["Governance"] = 3] = "Governance";
+  return TimeLockType2;
+})(TimeLockType || {});
+function getTimeLockTypeEncoder() {
+  return getEnumEncoder(TimeLockType);
+}
+function getTimeLockTypeDecoder() {
+  return getEnumDecoder(TimeLockType);
+}
+function getTimeLockTypeCodec() {
+  return combineCodec(getTimeLockTypeEncoder(), getTimeLockTypeDecoder());
+}
+var TransactionPriority = /* @__PURE__ */ ((TransactionPriority2) => {
+  TransactionPriority2[TransactionPriority2["Low"] = 0] = "Low";
+  TransactionPriority2[TransactionPriority2["Normal"] = 1] = "Normal";
+  TransactionPriority2[TransactionPriority2["High"] = 2] = "High";
+  TransactionPriority2[TransactionPriority2["Critical"] = 3] = "Critical";
+  TransactionPriority2[TransactionPriority2["Emergency"] = 4] = "Emergency";
+  return TransactionPriority2;
+})(TransactionPriority || {});
+function getTransactionPriorityEncoder() {
+  return getEnumEncoder(TransactionPriority);
+}
+function getTransactionPriorityDecoder() {
+  return getEnumDecoder(TransactionPriority);
+}
+function getTransactionPriorityCodec() {
+  return combineCodec(
+    getTransactionPriorityEncoder(),
+    getTransactionPriorityDecoder()
+  );
+}
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2[TransactionStatus2["Pending"] = 0] = "Pending";
+  TransactionStatus2[TransactionStatus2["PartiallyApproved"] = 1] = "PartiallyApproved";
+  TransactionStatus2[TransactionStatus2["FullyApproved"] = 2] = "FullyApproved";
+  TransactionStatus2[TransactionStatus2["Executed"] = 3] = "Executed";
+  TransactionStatus2[TransactionStatus2["Cancelled"] = 4] = "Cancelled";
+  TransactionStatus2[TransactionStatus2["Expired"] = 5] = "Expired";
+  TransactionStatus2[TransactionStatus2["Failed"] = 6] = "Failed";
+  return TransactionStatus2;
+})(TransactionStatus || {});
+function getTransactionStatusEncoder() {
+  return getEnumEncoder(TransactionStatus);
+}
+function getTransactionStatusDecoder() {
+  return getEnumDecoder(TransactionStatus);
+}
+function getTransactionStatusCodec() {
+  return combineCodec(
+    getTransactionStatusEncoder(),
+    getTransactionStatusDecoder()
+  );
+}
+var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
+  TransactionType2[TransactionType2["Transfer"] = 0] = "Transfer";
+  TransactionType2[TransactionType2["Withdrawal"] = 1] = "Withdrawal";
+  TransactionType2[TransactionType2["EscrowRelease"] = 2] = "EscrowRelease";
+  TransactionType2[TransactionType2["ProposalCreation"] = 3] = "ProposalCreation";
+  TransactionType2[TransactionType2["VoteExecution"] = 4] = "VoteExecution";
+  TransactionType2[TransactionType2["ParameterUpdate"] = 5] = "ParameterUpdate";
+  TransactionType2[TransactionType2["SignerAddition"] = 6] = "SignerAddition";
+  TransactionType2[TransactionType2["SignerRemoval"] = 7] = "SignerRemoval";
+  TransactionType2[TransactionType2["ThresholdUpdate"] = 8] = "ThresholdUpdate";
+  TransactionType2[TransactionType2["ConfigUpdate"] = 9] = "ConfigUpdate";
+  TransactionType2[TransactionType2["EmergencyFreeze"] = 10] = "EmergencyFreeze";
+  TransactionType2[TransactionType2["EmergencyUnfreeze"] = 11] = "EmergencyUnfreeze";
+  TransactionType2[TransactionType2["SecurityPolicyUpdate"] = 12] = "SecurityPolicyUpdate";
+  TransactionType2[TransactionType2["ProtocolUpgrade"] = 13] = "ProtocolUpgrade";
+  TransactionType2[TransactionType2["FeatureToggle"] = 14] = "FeatureToggle";
+  TransactionType2[TransactionType2["RiskParameterUpdate"] = 15] = "RiskParameterUpdate";
+  TransactionType2[TransactionType2["CustomInstruction"] = 16] = "CustomInstruction";
+  return TransactionType2;
+})(TransactionType || {});
+function getTransactionTypeEncoder() {
+  return getEnumEncoder(TransactionType);
+}
+function getTransactionTypeDecoder() {
+  return getEnumDecoder(TransactionType);
+}
+function getTransactionTypeCodec() {
+  return combineCodec(getTransactionTypeEncoder(), getTransactionTypeDecoder());
+}
+var TrendDirection = /* @__PURE__ */ ((TrendDirection2) => {
+  TrendDirection2[TrendDirection2["Increasing"] = 0] = "Increasing";
+  TrendDirection2[TrendDirection2["Decreasing"] = 1] = "Decreasing";
+  TrendDirection2[TrendDirection2["Stable"] = 2] = "Stable";
+  TrendDirection2[TrendDirection2["Unknown"] = 3] = "Unknown";
+  return TrendDirection2;
+})(TrendDirection || {});
+function getTrendDirectionEncoder() {
+  return getEnumEncoder(TrendDirection);
+}
+function getTrendDirectionDecoder() {
+  return getEnumDecoder(TrendDirection);
+}
+function getTrendDirectionCodec() {
+  return combineCodec(getTrendDirectionEncoder(), getTrendDirectionDecoder());
+}
+var UnlockMethod = /* @__PURE__ */ ((UnlockMethod2) => {
+  UnlockMethod2[UnlockMethod2["TimeBasedAutoUnlock"] = 0] = "TimeBasedAutoUnlock";
+  UnlockMethod2[UnlockMethod2["AdminUnlock"] = 1] = "AdminUnlock";
+  UnlockMethod2[UnlockMethod2["SelfServiceUnlock"] = 2] = "SelfServiceUnlock";
+  UnlockMethod2[UnlockMethod2["MultiFactorUnlock"] = 3] = "MultiFactorUnlock";
+  UnlockMethod2[UnlockMethod2["SupervisorUnlock"] = 4] = "SupervisorUnlock";
+  return UnlockMethod2;
+})(UnlockMethod || {});
+function getUnlockMethodEncoder() {
+  return getEnumEncoder(UnlockMethod);
+}
+function getUnlockMethodDecoder() {
+  return getEnumDecoder(UnlockMethod);
+}
+function getUnlockMethodCodec() {
+  return combineCodec(getUnlockMethodEncoder(), getUnlockMethodDecoder());
+}
+var ValueType = /* @__PURE__ */ ((ValueType2) => {
+  ValueType2[ValueType2["String"] = 0] = "String";
+  ValueType2[ValueType2["Number"] = 1] = "Number";
+  ValueType2[ValueType2["Boolean"] = 2] = "Boolean";
+  ValueType2[ValueType2["Date"] = 3] = "Date";
+  ValueType2[ValueType2["Time"] = 4] = "Time";
+  ValueType2[ValueType2["Duration"] = 5] = "Duration";
+  ValueType2[ValueType2["List"] = 6] = "List";
+  ValueType2[ValueType2["Object"] = 7] = "Object";
+  return ValueType2;
+})(ValueType || {});
+function getValueTypeEncoder() {
+  return getEnumEncoder(ValueType);
+}
+function getValueTypeDecoder() {
+  return getEnumDecoder(ValueType);
+}
+function getValueTypeCodec() {
+  return combineCodec(getValueTypeEncoder(), getValueTypeDecoder());
+}
+function getVerificationMethodEncoder() {
+  return getStructEncoder([
+    ["id", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["methodType", getVerificationMethodTypeEncoder()],
+    ["controller", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    [
+      "publicKeyMultibase",
+      addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+    ],
+    ["relationships", getArrayEncoder(getVerificationRelationshipEncoder())],
+    ["createdAt", getI64Encoder()],
+    ["revoked", getBooleanEncoder()]
+  ]);
+}
+function getVerificationMethodDecoder() {
+  return getStructDecoder([
+    ["id", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["methodType", getVerificationMethodTypeDecoder()],
+    ["controller", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    [
+      "publicKeyMultibase",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["relationships", getArrayDecoder(getVerificationRelationshipDecoder())],
+    ["createdAt", getI64Decoder()],
+    ["revoked", getBooleanDecoder()]
+  ]);
+}
+function getVerificationMethodCodec() {
+  return combineCodec(
+    getVerificationMethodEncoder(),
+    getVerificationMethodDecoder()
+  );
+}
+var VerificationMethodType = /* @__PURE__ */ ((VerificationMethodType2) => {
+  VerificationMethodType2[VerificationMethodType2["Ed25519VerificationKey2020"] = 0] = "Ed25519VerificationKey2020";
+  VerificationMethodType2[VerificationMethodType2["X25519KeyAgreementKey2020"] = 1] = "X25519KeyAgreementKey2020";
+  VerificationMethodType2[VerificationMethodType2["EcdsaSecp256k1VerificationKey2019"] = 2] = "EcdsaSecp256k1VerificationKey2019";
+  return VerificationMethodType2;
+})(VerificationMethodType || {});
+function getVerificationMethodTypeEncoder() {
+  return getEnumEncoder(VerificationMethodType);
+}
+function getVerificationMethodTypeDecoder() {
+  return getEnumDecoder(VerificationMethodType);
+}
+function getVerificationMethodTypeCodec() {
+  return combineCodec(
+    getVerificationMethodTypeEncoder(),
+    getVerificationMethodTypeDecoder()
+  );
+}
+var VerificationRelationship = /* @__PURE__ */ ((VerificationRelationship2) => {
+  VerificationRelationship2[VerificationRelationship2["Authentication"] = 0] = "Authentication";
+  VerificationRelationship2[VerificationRelationship2["AssertionMethod"] = 1] = "AssertionMethod";
+  VerificationRelationship2[VerificationRelationship2["KeyAgreement"] = 2] = "KeyAgreement";
+  VerificationRelationship2[VerificationRelationship2["CapabilityInvocation"] = 3] = "CapabilityInvocation";
+  VerificationRelationship2[VerificationRelationship2["CapabilityDelegation"] = 4] = "CapabilityDelegation";
+  return VerificationRelationship2;
+})(VerificationRelationship || {});
+function getVerificationRelationshipEncoder() {
+  return getEnumEncoder(VerificationRelationship);
+}
+function getVerificationRelationshipDecoder() {
+  return getEnumDecoder(VerificationRelationship);
+}
+function getVerificationRelationshipCodec() {
+  return combineCodec(
+    getVerificationRelationshipEncoder(),
+    getVerificationRelationshipDecoder()
+  );
+}
+var ViolationSeverity = /* @__PURE__ */ ((ViolationSeverity2) => {
+  ViolationSeverity2[ViolationSeverity2["Low"] = 0] = "Low";
+  ViolationSeverity2[ViolationSeverity2["Medium"] = 1] = "Medium";
+  ViolationSeverity2[ViolationSeverity2["High"] = 2] = "High";
+  ViolationSeverity2[ViolationSeverity2["Critical"] = 3] = "Critical";
+  return ViolationSeverity2;
+})(ViolationSeverity || {});
+function getViolationSeverityEncoder() {
+  return getEnumEncoder(ViolationSeverity);
+}
+function getViolationSeverityDecoder() {
+  return getEnumDecoder(ViolationSeverity);
+}
+function getViolationSeverityCodec() {
+  return combineCodec(
+    getViolationSeverityEncoder(),
+    getViolationSeverityDecoder()
+  );
+}
+function getVoteEncoder() {
+  return getStructEncoder([
+    ["voter", getAddressEncoder()],
+    ["choice", getVoteChoiceEncoder()],
+    ["votingPower", getU64Encoder()],
+    ["votedAt", getI64Encoder()],
+    [
+      "reasoning",
+      getOptionEncoder(addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder()))
+    ],
+    ["delegationInfo", getOptionEncoder(getDelegationInfoEncoder())]
+  ]);
+}
+function getVoteDecoder() {
+  return getStructDecoder([
+    ["voter", getAddressDecoder()],
+    ["choice", getVoteChoiceDecoder()],
+    ["votingPower", getU64Decoder()],
+    ["votedAt", getI64Decoder()],
+    [
+      "reasoning",
+      getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["delegationInfo", getOptionDecoder(getDelegationInfoDecoder())]
+  ]);
+}
+function getVoteCodec() {
+  return combineCodec(getVoteEncoder(), getVoteDecoder());
+}
+var VoteChoice = /* @__PURE__ */ ((VoteChoice2) => {
+  VoteChoice2[VoteChoice2["For"] = 0] = "For";
+  VoteChoice2[VoteChoice2["Against"] = 1] = "Against";
+  VoteChoice2[VoteChoice2["Abstain"] = 2] = "Abstain";
+  return VoteChoice2;
+})(VoteChoice || {});
+function getVoteChoiceEncoder() {
+  return getEnumEncoder(VoteChoice);
+}
+function getVoteChoiceDecoder() {
+  return getEnumDecoder(VoteChoice);
+}
+function getVoteChoiceCodec() {
+  return combineCodec(getVoteChoiceEncoder(), getVoteChoiceDecoder());
+}
+function getVotingResultsEncoder() {
+  return getStructEncoder([
+    ["votesFor", getU64Encoder()],
+    ["votesAgainst", getU64Encoder()],
+    ["votesAbstain", getU64Encoder()],
+    ["totalVotingPower", getU64Encoder()],
+    ["participationRate", getU8Encoder()],
+    ["individualVotes", getArrayEncoder(getVoteEncoder())],
+    ["weightedVoting", getBooleanEncoder()],
+    ["quorumReached", getBooleanEncoder()],
+    ["approvalThresholdMet", getBooleanEncoder()]
+  ]);
+}
+function getVotingResultsDecoder() {
+  return getStructDecoder([
+    ["votesFor", getU64Decoder()],
+    ["votesAgainst", getU64Decoder()],
+    ["votesAbstain", getU64Decoder()],
+    ["totalVotingPower", getU64Decoder()],
+    ["participationRate", getU8Decoder()],
+    ["individualVotes", getArrayDecoder(getVoteDecoder())],
+    ["weightedVoting", getBooleanDecoder()],
+    ["quorumReached", getBooleanDecoder()],
+    ["approvalThresholdMet", getBooleanDecoder()]
+  ]);
+}
+function getVotingResultsCodec() {
+  return combineCodec(getVotingResultsEncoder(), getVotingResultsDecoder());
+}
+
+// src/generated/accounts/agent.ts
+var AGENT_DISCRIMINATOR = new Uint8Array([
+  47,
+  166,
+  112,
+  147,
+  155,
+  197,
+  86,
+  7
+]);
+function getAgentDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(AGENT_DISCRIMINATOR);
+}
+function getAgentEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["owner", getOptionEncoder(getAddressEncoder())],
+      ["status", getAgentStatusEncoder()],
+      ["agentId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      [
+        "firstTxSignature",
+        addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+      ],
+      ["firstSeenTimestamp", getI64Encoder()],
+      [
+        "discoverySource",
+        addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+      ],
+      ["claimedAt", getOptionEncoder(getI64Encoder())],
+      ["agentType", getU8Encoder()],
+      ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      ["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      [
+        "capabilities",
+        getArrayEncoder(
+          addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+        )
+      ],
+      ["pricingModel", getPricingModelEncoder()],
+      ["reputationScore", getU32Encoder()],
+      ["totalJobsCompleted", getU32Encoder()],
+      ["totalEarnings", getU64Encoder()],
+      ["isActive", getBooleanEncoder()],
+      ["createdAt", getI64Encoder()],
+      ["updatedAt", getI64Encoder()],
+      ["originalPrice", getU64Encoder()],
+      ["genomeHash", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      ["isReplicable", getBooleanEncoder()],
+      ["replicationFee", getU64Encoder()],
+      [
+        "serviceEndpoint",
+        addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+      ],
+      ["isVerified", getBooleanEncoder()],
+      ["verificationTimestamp", getI64Encoder()],
+      ["metadataUri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      [
+        "frameworkOrigin",
+        addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+      ],
+      ["supportedTokens", getArrayEncoder(getAddressEncoder())],
+      ["cnftMint", getOptionEncoder(getAddressEncoder())],
+      ["merkleTree", getOptionEncoder(getAddressEncoder())],
+      ["supportsA2a", getBooleanEncoder()],
+      ["transferHook", getOptionEncoder(getAddressEncoder())],
+      ["parentAgent", getOptionEncoder(getAddressEncoder())],
+      ["generation", getU32Encoder()],
+      ["x402Enabled", getBooleanEncoder()],
+      ["x402PaymentAddress", getAddressEncoder()],
+      ["x402AcceptedTokens", getArrayEncoder(getAddressEncoder())],
+      ["x402PricePerCall", getU64Encoder()],
+      [
+        "x402ServiceEndpoint",
+        addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+      ],
+      ["x402TotalPayments", getU64Encoder()],
+      ["x402TotalCalls", getU64Encoder()],
+      ["lastPaymentTimestamp", getI64Encoder()],
+      ["externalIdentifiers", getArrayEncoder(getExternalIdentifierEncoder())],
+      ["ghostScore", getU64Encoder()],
+      [
+        "reputationComponents",
+        getArrayEncoder(getReputationComponentEncoder())
+      ],
+      ["didAddress", getOptionEncoder(getAddressEncoder())],
+      ["credentials", getArrayEncoder(getAddressEncoder())],
+      ["apiSpecUri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      ["apiVersion", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      ["bump", getU8Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: AGENT_DISCRIMINATOR })
+  );
+}
+function getAgentDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["owner", getOptionDecoder(getAddressDecoder())],
+    ["status", getAgentStatusDecoder()],
+    ["agentId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    [
+      "firstTxSignature",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["firstSeenTimestamp", getI64Decoder()],
+    [
+      "discoverySource",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["claimedAt", getOptionDecoder(getI64Decoder())],
+    ["agentType", getU8Decoder()],
+    ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    [
+      "capabilities",
+      getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
+    ],
+    ["pricingModel", getPricingModelDecoder()],
+    ["reputationScore", getU32Decoder()],
+    ["totalJobsCompleted", getU32Decoder()],
+    ["totalEarnings", getU64Decoder()],
+    ["isActive", getBooleanDecoder()],
+    ["createdAt", getI64Decoder()],
+    ["updatedAt", getI64Decoder()],
+    ["originalPrice", getU64Decoder()],
+    ["genomeHash", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["isReplicable", getBooleanDecoder()],
+    ["replicationFee", getU64Decoder()],
+    [
+      "serviceEndpoint",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["isVerified", getBooleanDecoder()],
+    ["verificationTimestamp", getI64Decoder()],
+    ["metadataUri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    [
+      "frameworkOrigin",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["supportedTokens", getArrayDecoder(getAddressDecoder())],
+    ["cnftMint", getOptionDecoder(getAddressDecoder())],
+    ["merkleTree", getOptionDecoder(getAddressDecoder())],
+    ["supportsA2a", getBooleanDecoder()],
+    ["transferHook", getOptionDecoder(getAddressDecoder())],
+    ["parentAgent", getOptionDecoder(getAddressDecoder())],
+    ["generation", getU32Decoder()],
+    ["x402Enabled", getBooleanDecoder()],
+    ["x402PaymentAddress", getAddressDecoder()],
+    ["x402AcceptedTokens", getArrayDecoder(getAddressDecoder())],
+    ["x402PricePerCall", getU64Decoder()],
+    [
+      "x402ServiceEndpoint",
+      addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
+    ],
+    ["x402TotalPayments", getU64Decoder()],
+    ["x402TotalCalls", getU64Decoder()],
+    ["lastPaymentTimestamp", getI64Decoder()],
+    ["externalIdentifiers", getArrayDecoder(getExternalIdentifierDecoder())],
+    ["ghostScore", getU64Decoder()],
+    ["reputationComponents", getArrayDecoder(getReputationComponentDecoder())],
+    ["didAddress", getOptionDecoder(getAddressDecoder())],
+    ["credentials", getArrayDecoder(getAddressDecoder())],
+    ["apiSpecUri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["apiVersion", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["bump", getU8Decoder()]
+  ]);
+}
+function getAgentCodec() {
+  return combineCodec(getAgentEncoder(), getAgentDecoder());
+}
+function decodeAgent(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getAgentDecoder()
+  );
+}
+async function fetchAgent(rpc, address, config) {
+  const maybeAccount = await fetchMaybeAgent(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeAgent(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeAgent(maybeAccount);
+}
+async function fetchAllAgent(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeAgent(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeAgent(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAgent(maybeAccount));
+}
+
+export { AGENT_DISCRIMINATOR, AccessTier, ActivationRequirementType, AgentStatus, AuditAction, AuthenticationLevel, AuthenticationMethod, BackupFrequency, BiometricStorageMethod, BiometricType, ConditionType, ConstraintOperator, CredentialKind, CredentialStatus, CrossChainStatus, DataAccessLevel, DegradationHandling, EnforcementLevel, EscrowStatus, MultisigType, NotificationMethod, NotificationPriority, NotificationTargetType, NotificationTiming, PermissionConstraintType, PolicyStatus, PolicyType, PricingModel, ProposalStatus, ProposalType, QuorumMethod, ReentrancyState, ReportStatus, ReportType, ReportingFrequency, ReputationSourceType, RiskCategory, RiskLevel, RoleStatus, RoleType, RuleEffect, ScopeInheritance, ScopeType, SecurityEventType, ServiceEndpointType, SlashReason, SodConstraintType, StepUpTrigger, TimeLockType, TransactionPriority, TransactionStatus, TransactionType, TrendDirection, UnlockMethod, ValueType, VerificationMethodType, VerificationRelationship, ViolationSeverity, VoteChoice, arbitratorDecision, decodeAgent, delegationScope, fetchAgent, fetchAllAgent, fetchAllMaybeAgent, fetchMaybeAgent, getAccessAuditConfigCodec, getAccessAuditConfigDecoder, getAccessAuditConfigEncoder, getAccessPolicyCodec, getAccessPolicyDecoder, getAccessPolicyEncoder, getAccessTierCodec, getAccessTierDecoder, getAccessTierEncoder, getAccountLockoutPoliciesCodec, getAccountLockoutPoliciesDecoder, getAccountLockoutPoliciesEncoder, getActionCodec, getActionDecoder, getActionEncoder, getActivationRequirementCodec, getActivationRequirementDecoder, getActivationRequirementEncoder, getActivationRequirementTypeCodec, getActivationRequirementTypeDecoder, getActivationRequirementTypeEncoder, getAgentCodec, getAgentDecoder, getAgentDiscriminatorBytes, getAgentEncoder, getAgentRegisteredEventCodec, getAgentRegisteredEventDecoder, getAgentRegisteredEventEncoder, getAgentServiceUpdatedEventCodec, getAgentServiceUpdatedEventDecoder, getAgentServiceUpdatedEventEncoder, getAgentStatusChangedEventCodec, getAgentStatusChangedEventDecoder, getAgentStatusChangedEventEncoder, getAgentStatusCodec, getAgentStatusDecoder, getAgentStatusEncoder, getAgentUpdatedEventCodec, getAgentUpdatedEventDecoder, getAgentUpdatedEventEncoder, getAgentVerificationDataCodec, getAgentVerificationDataDecoder, getAgentVerificationDataEncoder, getAgingPolicyCodec, getAgingPolicyDecoder, getAgingPolicyEncoder, getApprovalLevelCodec, getApprovalLevelDecoder, getApprovalLevelEncoder, getArbitratorDecisionCodec, getArbitratorDecisionDecoder, getArbitratorDecisionEncoder, getAuditActionCodec, getAuditActionDecoder, getAuditActionEncoder, getAuditConfigCodec, getAuditConfigDecoder, getAuditConfigEncoder, getAuditContextCodec, getAuditContextDecoder, getAuditContextEncoder, getAuditEntryCodec, getAuditEntryDecoder, getAuditEntryEncoder, getAuditTrailInitializedEventCodec, getAuditTrailInitializedEventDecoder, getAuditTrailInitializedEventEncoder, getAuthenticationLevelCodec, getAuthenticationLevelDecoder, getAuthenticationLevelEncoder, getAuthenticationMethodCodec, getAuthenticationMethodDecoder, getAuthenticationMethodEncoder, getAuthenticationPoliciesCodec, getAuthenticationPoliciesDecoder, getAuthenticationPoliciesEncoder, getAuthenticationStrengthCodec, getAuthenticationStrengthDecoder, getAuthenticationStrengthEncoder, getAuthorizationPoliciesCodec, getAuthorizationPoliciesDecoder, getAuthorizationPoliciesEncoder, getBackupFrequencyCodec, getBackupFrequencyDecoder, getBackupFrequencyEncoder, getBiometricPoliciesCodec, getBiometricPoliciesDecoder, getBiometricPoliciesEncoder, getBiometricProtectionCodec, getBiometricProtectionDecoder, getBiometricProtectionEncoder, getBiometricQualityCodec, getBiometricQualityDecoder, getBiometricQualityEncoder, getBiometricStorageMethodCodec, getBiometricStorageMethodDecoder, getBiometricStorageMethodEncoder, getBiometricTypeCodec, getBiometricTypeDecoder, getBiometricTypeEncoder, getComplianceFlagsCodec, getComplianceFlagsDecoder, getComplianceFlagsEncoder, getComplianceMetricsCodec, getComplianceMetricsDecoder, getComplianceMetricsEncoder, getCompliancePoliciesCodec, getCompliancePoliciesDecoder, getCompliancePoliciesEncoder, getComplianceReportGeneratedEventCodec, getComplianceReportGeneratedEventDecoder, getComplianceReportGeneratedEventEncoder, getComplianceStatusCodec, getComplianceStatusDecoder, getComplianceStatusEncoder, getCompressedAgentCreatedEventCodec, getCompressedAgentCreatedEventDecoder, getCompressedAgentCreatedEventEncoder, getConditionTypeCodec, getConditionTypeDecoder, getConditionTypeEncoder, getConstraintConditionCodec, getConstraintConditionDecoder, getConstraintConditionEncoder, getConstraintOperatorCodec, getConstraintOperatorDecoder, getConstraintOperatorEncoder, getCredentialKindCodec, getCredentialKindDecoder, getCredentialKindEncoder, getCredentialStatusCodec, getCredentialStatusDecoder, getCredentialStatusEncoder, getCrossChainStatusCodec, getCrossChainStatusDecoder, getCrossChainStatusEncoder, getDataAccessLevelCodec, getDataAccessLevelDecoder, getDataAccessLevelEncoder, getDataProtectionPoliciesCodec, getDataProtectionPoliciesDecoder, getDataProtectionPoliciesEncoder, getDegradationHandlingCodec, getDegradationHandlingDecoder, getDegradationHandlingEncoder, getDelegationInfoCodec, getDelegationInfoDecoder, getDelegationInfoEncoder, getDelegationScopeCodec, getDelegationScopeDecoder, getDelegationScopeEncoder, getDeliverySubmittedEventCodec, getDeliverySubmittedEventDecoder, getDeliverySubmittedEventEncoder, getDisputeFiledEventCodec, getDisputeFiledEventDecoder, getDisputeFiledEventEncoder, getDisputeResolvedEventCodec, getDisputeResolvedEventDecoder, getDisputeResolvedEventEncoder, getEmergencyAccessConfigCodec, getEmergencyAccessConfigDecoder, getEmergencyAccessConfigEncoder, getEmergencyConfigCodec, getEmergencyConfigDecoder, getEmergencyConfigEncoder, getEnforcementLevelCodec, getEnforcementLevelDecoder, getEnforcementLevelEncoder, getEscrowCompletedEventCodec, getEscrowCompletedEventDecoder, getEscrowCompletedEventEncoder, getEscrowCreatedEventCodec, getEscrowCreatedEventDecoder, getEscrowCreatedEventEncoder, getEscrowStatusCodec, getEscrowStatusDecoder, getEscrowStatusEncoder, getExecutionConditionCodec, getExecutionConditionDecoder, getExecutionConditionEncoder, getExecutionParamsCodec, getExecutionParamsDecoder, getExecutionParamsEncoder, getExternalIdentifierCodec, getExternalIdentifierDecoder, getExternalIdentifierEncoder, getGeographicRegionCodec, getGeographicRegionDecoder, getGeographicRegionEncoder, getGhostSlashedEventCodec, getGhostSlashedEventDecoder, getGhostSlashedEventEncoder, getGhostStakedEventCodec, getGhostStakedEventDecoder, getGhostStakedEventEncoder, getGhostUnstakedEventCodec, getGhostUnstakedEventDecoder, getGhostUnstakedEventEncoder, getGovernanceProposalCreatedEventCodec, getGovernanceProposalCreatedEventDecoder, getGovernanceProposalCreatedEventEncoder, getHierarchicalBoundaryCodec, getHierarchicalBoundaryDecoder, getHierarchicalBoundaryEncoder, getIncidentResponsePoliciesCodec, getIncidentResponsePoliciesDecoder, getIncidentResponsePoliciesEncoder, getLatitudeRangeCodec, getLatitudeRangeDecoder, getLatitudeRangeEncoder, getLocationConstraintsCodec, getLocationConstraintsDecoder, getLocationConstraintsEncoder, getLongitudeRangeCodec, getLongitudeRangeDecoder, getLongitudeRangeEncoder, getMultisigConfigCodec, getMultisigConfigDecoder, getMultisigConfigEncoder, getMultisigCreatedEventCodec, getMultisigCreatedEventDecoder, getMultisigCreatedEventEncoder, getMultisigSignatureCodec, getMultisigSignatureDecoder, getMultisigSignatureEncoder, getMultisigTypeCodec, getMultisigTypeConfigCodec, getMultisigTypeConfigDecoder, getMultisigTypeConfigEncoder, getMultisigTypeDecoder, getMultisigTypeEncoder, getNetworkSecurityPoliciesCodec, getNetworkSecurityPoliciesDecoder, getNetworkSecurityPoliciesEncoder, getNotificationMethodCodec, getNotificationMethodDecoder, getNotificationMethodEncoder, getNotificationPriorityCodec, getNotificationPriorityDecoder, getNotificationPriorityEncoder, getNotificationRequirementCodec, getNotificationRequirementDecoder, getNotificationRequirementEncoder, getNotificationTargetCodec, getNotificationTargetDecoder, getNotificationTargetEncoder, getNotificationTargetTypeCodec, getNotificationTargetTypeDecoder, getNotificationTargetTypeEncoder, getNotificationTimingCodec, getNotificationTimingDecoder, getNotificationTimingEncoder, getPasswordPoliciesCodec, getPasswordPoliciesDecoder, getPasswordPoliciesEncoder, getPendingTransactionCodec, getPendingTransactionDecoder, getPendingTransactionEncoder, getPermissionCodec, getPermissionConstraintCodec, getPermissionConstraintDecoder, getPermissionConstraintEncoder, getPermissionConstraintTypeCodec, getPermissionConstraintTypeDecoder, getPermissionConstraintTypeEncoder, getPermissionDecoder, getPermissionEncoder, getPermissionMetadataCodec, getPermissionMetadataDecoder, getPermissionMetadataEncoder, getPermissionScopeCodec, getPermissionScopeDecoder, getPermissionScopeEncoder, getPolicyMetadataCodec, getPolicyMetadataDecoder, getPolicyMetadataEncoder, getPolicyRuleCodec, getPolicyRuleDecoder, getPolicyRuleEncoder, getPolicyScopeCodec, getPolicyScopeDecoder, getPolicyScopeEncoder, getPolicyStatusCodec, getPolicyStatusDecoder, getPolicyStatusEncoder, getPolicyTypeCodec, getPolicyTypeDecoder, getPolicyTypeEncoder, getPricingModelCodec, getPricingModelDecoder, getPricingModelEncoder, getProposalAccountCodec, getProposalAccountDecoder, getProposalAccountEncoder, getProposalInstructionCodec, getProposalInstructionDecoder, getProposalInstructionEncoder, getProposalMetadataCodec, getProposalMetadataDecoder, getProposalMetadataEncoder, getProposalStatusCodec, getProposalStatusDecoder, getProposalStatusEncoder, getProposalTypeCodec, getProposalTypeDecoder, getProposalTypeEncoder, getProtocolConfigUpdatedEventCodec, getProtocolConfigUpdatedEventDecoder, getProtocolConfigUpdatedEventEncoder, getQuorumMethodCodec, getQuorumMethodDecoder, getQuorumMethodEncoder, getQuorumRequirementsCodec, getQuorumRequirementsDecoder, getQuorumRequirementsEncoder, getRbacConfigInitializedEventCodec, getRbacConfigInitializedEventDecoder, getRbacConfigInitializedEventEncoder, getReentrancyStateCodec, getReentrancyStateDecoder, getReentrancyStateEncoder, getReportDataCodec, getReportDataDecoder, getReportDataEncoder, getReportEntryCodec, getReportEntryDecoder, getReportEntryEncoder, getReportStatusCodec, getReportStatusDecoder, getReportStatusEncoder, getReportSummaryCodec, getReportSummaryDecoder, getReportSummaryEncoder, getReportTypeCodec, getReportTypeDecoder, getReportTypeEncoder, getReportingFrequencyCodec, getReportingFrequencyDecoder, getReportingFrequencyEncoder, getReputationComponentCodec, getReputationComponentDecoder, getReputationComponentEncoder, getReputationMetricsInitializedEventCodec, getReputationMetricsInitializedEventDecoder, getReputationMetricsInitializedEventEncoder, getReputationPaymentRecordedEventCodec, getReputationPaymentRecordedEventDecoder, getReputationPaymentRecordedEventEncoder, getReputationRatingSubmittedEventCodec, getReputationRatingSubmittedEventDecoder, getReputationRatingSubmittedEventEncoder, getReputationSourceTypeCodec, getReputationSourceTypeDecoder, getReputationSourceTypeEncoder, getReputationTagsUpdatedEventCodec, getReputationTagsUpdatedEventDecoder, getReputationTagsUpdatedEventEncoder, getResourceConstraintsCodec, getResourceConstraintsDecoder, getResourceConstraintsEncoder, getReviewScheduleCodec, getReviewScheduleDecoder, getReviewScheduleEncoder, getRiskAcceptanceCodec, getRiskAcceptanceDecoder, getRiskAcceptanceEncoder, getRiskAssessmentCodec, getRiskAssessmentDecoder, getRiskAssessmentEncoder, getRiskCategoryCodec, getRiskCategoryDecoder, getRiskCategoryEncoder, getRiskFactorCodec, getRiskFactorDecoder, getRiskFactorEncoder, getRiskIndicatorCodec, getRiskIndicatorDecoder, getRiskIndicatorEncoder, getRiskLevelCodec, getRiskLevelDecoder, getRiskLevelEncoder, getRoleCodec, getRoleConstraintsCodec, getRoleConstraintsDecoder, getRoleConstraintsEncoder, getRoleDecoder, getRoleEncoder, getRoleMetadataCodec, getRoleMetadataDecoder, getRoleMetadataEncoder, getRoleStatusCodec, getRoleStatusDecoder, getRoleStatusEncoder, getRoleTypeCodec, getRoleTypeDecoder, getRoleTypeEncoder, getRuleConditionCodec, getRuleConditionDecoder, getRuleConditionEncoder, getRuleEffectCodec, getRuleEffectDecoder, getRuleEffectEncoder, getScopeBoundariesCodec, getScopeBoundariesDecoder, getScopeBoundariesEncoder, getScopeInheritanceCodec, getScopeInheritanceDecoder, getScopeInheritanceEncoder, getScopeTypeCodec, getScopeTypeDecoder, getScopeTypeEncoder, getSecurityEventTypeCodec, getSecurityEventTypeDecoder, getSecurityEventTypeEncoder, getSecurityPoliciesCodec, getSecurityPoliciesDecoder, getSecurityPoliciesEncoder, getServiceEndpointCodec, getServiceEndpointDecoder, getServiceEndpointEncoder, getServiceEndpointTypeCodec, getServiceEndpointTypeDecoder, getServiceEndpointTypeEncoder, getSessionConstraintsCodec, getSessionConstraintsDecoder, getSessionConstraintsEncoder, getSessionPoliciesCodec, getSessionPoliciesDecoder, getSessionPoliciesEncoder, getSlashReasonCodec, getSlashReasonDecoder, getSlashReasonEncoder, getSodConstraintCodec, getSodConstraintDecoder, getSodConstraintEncoder, getSodConstraintTypeCodec, getSodConstraintTypeDecoder, getSodConstraintTypeEncoder, getSourceReputationUpdatedEventCodec, getSourceReputationUpdatedEventDecoder, getSourceReputationUpdatedEventEncoder, getSourceScoreCodec, getSourceScoreDecoder, getSourceScoreEncoder, getStepUpTriggerCodec, getStepUpTriggerDecoder, getStepUpTriggerEncoder, getSubmissionDetailsCodec, getSubmissionDetailsDecoder, getSubmissionDetailsEncoder, getTagDecayAppliedEventCodec, getTagDecayAppliedEventDecoder, getTagDecayAppliedEventEncoder, getTagScoreCodec, getTagScoreDecoder, getTagScoreEncoder, getTierUpdatedEventCodec, getTierUpdatedEventDecoder, getTierUpdatedEventEncoder, getTimeConstraintsCodec, getTimeConstraintsDecoder, getTimeConstraintsEncoder, getTimeLockCodec, getTimeLockDecoder, getTimeLockEncoder, getTimeLockTypeCodec, getTimeLockTypeDecoder, getTimeLockTypeEncoder, getTransactionPriorityCodec, getTransactionPriorityDecoder, getTransactionPriorityEncoder, getTransactionStatusCodec, getTransactionStatusDecoder, getTransactionStatusEncoder, getTransactionTypeCodec, getTransactionTypeDecoder, getTransactionTypeEncoder, getTrendDirectionCodec, getTrendDirectionDecoder, getTrendDirectionEncoder, getUnlockMethodCodec, getUnlockMethodDecoder, getUnlockMethodEncoder, getValueTypeCodec, getValueTypeDecoder, getValueTypeEncoder, getVerificationMethodCodec, getVerificationMethodDecoder, getVerificationMethodEncoder, getVerificationMethodTypeCodec, getVerificationMethodTypeDecoder, getVerificationMethodTypeEncoder, getVerificationRelationshipCodec, getVerificationRelationshipDecoder, getVerificationRelationshipEncoder, getViolationSeverityCodec, getViolationSeverityDecoder, getViolationSeverityEncoder, getVoteChoiceCodec, getVoteChoiceDecoder, getVoteChoiceEncoder, getVoteCodec, getVoteDecoder, getVoteEncoder, getVotingResultsCodec, getVotingResultsDecoder, getVotingResultsEncoder, isArbitratorDecision, isDelegationScope };
+//# sourceMappingURL=chunk-5QZVFUXB.js.map
+//# sourceMappingURL=chunk-5QZVFUXB.js.map