@cascade-fyi/sati-sdk 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,1322 @@
+import { Account, AccountMeta, AccountSignerMeta, Address, Address as Address$1, Codec, Decoder, EncodedAccount, Encoder, FetchAccountConfig, FetchAccountsConfig, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, Instruction, InstructionWithAccounts, InstructionWithData, KeyPairSigner, MaybeAccount, MaybeEncodedAccount, Option, OptionOrNullable, ReadonlyAccount, ReadonlySignerAccount, ReadonlyUint8Array, SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, SolanaError, TransactionSigner, WritableAccount, WritableSignerAccount, address, fetchEncodedAccount, fetchEncodedAccounts } from "@solana/kit";
+import * as sas_lib0 from "sas-lib";
+import { SOLANA_ATTESTATION_SERVICE_PROGRAM_ADDRESS, deriveAttestationPda, deriveCredentialPda, deriveEventAuthorityAddress, deriveSchemaPda, deserializeAttestationData, fetchAllMaybeSchema, fetchAttestation, fetchMaybeCredential, fetchMaybeSchema, fetchSchema, getCloseAttestationInstruction, getCreateAttestationInstruction, getCreateCredentialInstruction, getCreateSchemaInstruction, serializeAttestationData } from "sas-lib";
+
+//#region src/generated/accounts/registryConfig.d.ts
+
+declare const REGISTRY_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getRegistryConfigDiscriminatorBytes(): ReadonlyUint8Array;
+type RegistryConfig = {
+  discriminator: ReadonlyUint8Array;
+  /** SATI TokenGroup mint address */
+  groupMint: Address$1;
+  /**
+   * Authority that can update registry settings
+   * Set to Pubkey::default() to make immutable
+   */
+  authority: Address$1;
+  /** Total agents registered (counter) */
+  totalAgents: bigint;
+  /** PDA bump seed (stored for efficient CPI signing) */
+  bump: number;
+};
+type RegistryConfigArgs = {
+  /** SATI TokenGroup mint address */
+  groupMint: Address$1;
+  /**
+   * Authority that can update registry settings
+   * Set to Pubkey::default() to make immutable
+   */
+  authority: Address$1;
+  /** Total agents registered (counter) */
+  totalAgents: number | bigint;
+  /** PDA bump seed (stored for efficient CPI signing) */
+  bump: number;
+};
+/** Gets the encoder for {@link RegistryConfigArgs} account data. */
+declare function getRegistryConfigEncoder(): FixedSizeEncoder<RegistryConfigArgs>;
+/** Gets the decoder for {@link RegistryConfig} account data. */
+declare function getRegistryConfigDecoder(): FixedSizeDecoder<RegistryConfig>;
+/** Gets the codec for {@link RegistryConfig} account data. */
+declare function getRegistryConfigCodec(): FixedSizeCodec<RegistryConfigArgs, RegistryConfig>;
+declare function decodeRegistryConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<RegistryConfig, TAddress>;
+declare function decodeRegistryConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<RegistryConfig, TAddress>;
+declare function fetchRegistryConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address$1<TAddress>, config?: FetchAccountConfig): Promise<Account<RegistryConfig, TAddress>>;
+declare function fetchMaybeRegistryConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address$1<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<RegistryConfig, TAddress>>;
+declare function fetchAllRegistryConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address$1>, config?: FetchAccountsConfig): Promise<Account<RegistryConfig>[]>;
+declare function fetchAllMaybeRegistryConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address$1>, config?: FetchAccountsConfig): Promise<MaybeAccount<RegistryConfig>[]>;
+declare function getRegistryConfigSize(): number;
+//#endregion
+//#region src/generated/errors/satiRegistry.d.ts
+/** InvalidGroupMint: Invalid group mint - must be owned by Token-2022 with TokenGroup extension */
+declare const SATI_REGISTRY_ERROR__INVALID_GROUP_MINT = 6000;
+/** InvalidAuthority: Invalid authority */
+declare const SATI_REGISTRY_ERROR__INVALID_AUTHORITY = 6001;
+/** ImmutableAuthority: Authority is immutable (renounced) */
+declare const SATI_REGISTRY_ERROR__IMMUTABLE_AUTHORITY = 6002;
+/** NameTooLong: Name too long (max 32 bytes) */
+declare const SATI_REGISTRY_ERROR__NAME_TOO_LONG = 6003;
+/** SymbolTooLong: Symbol too long (max 10 bytes) */
+declare const SATI_REGISTRY_ERROR__SYMBOL_TOO_LONG = 6004;
+/** UriTooLong: URI too long (max 200 bytes) */
+declare const SATI_REGISTRY_ERROR__URI_TOO_LONG = 6005;
+/** TooManyMetadataEntries: Too many metadata entries (max 10) */
+declare const SATI_REGISTRY_ERROR__TOO_MANY_METADATA_ENTRIES = 6006;
+/** MetadataKeyTooLong: Metadata key too long (max 32 bytes) */
+declare const SATI_REGISTRY_ERROR__METADATA_KEY_TOO_LONG = 6007;
+/** MetadataValueTooLong: Metadata value too long (max 200 bytes) */
+declare const SATI_REGISTRY_ERROR__METADATA_VALUE_TOO_LONG = 6008;
+/** Overflow: Arithmetic overflow */
+declare const SATI_REGISTRY_ERROR__OVERFLOW = 6009;
+/** MintAuthorityNotRenounced: Failed to renounce mint authority - supply guarantee violated */
+declare const SATI_REGISTRY_ERROR__MINT_AUTHORITY_NOT_RENOUNCED = 6010;
+type SatiRegistryError = typeof SATI_REGISTRY_ERROR__IMMUTABLE_AUTHORITY | typeof SATI_REGISTRY_ERROR__INVALID_AUTHORITY | typeof SATI_REGISTRY_ERROR__INVALID_GROUP_MINT | typeof SATI_REGISTRY_ERROR__METADATA_KEY_TOO_LONG | typeof SATI_REGISTRY_ERROR__METADATA_VALUE_TOO_LONG | typeof SATI_REGISTRY_ERROR__MINT_AUTHORITY_NOT_RENOUNCED | typeof SATI_REGISTRY_ERROR__NAME_TOO_LONG | typeof SATI_REGISTRY_ERROR__OVERFLOW | typeof SATI_REGISTRY_ERROR__SYMBOL_TOO_LONG | typeof SATI_REGISTRY_ERROR__TOO_MANY_METADATA_ENTRIES | typeof SATI_REGISTRY_ERROR__URI_TOO_LONG;
+declare function getSatiRegistryErrorMessage(code: SatiRegistryError): string;
+declare function isSatiRegistryError<TProgramErrorCode extends SatiRegistryError>(error: unknown, transactionMessage: {
+  instructions: Record<number, {
+    programAddress: Address$1;
+  }>;
+}, code?: TProgramErrorCode): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> & Readonly<{
+  context: Readonly<{
+    code: TProgramErrorCode;
+  }>;
+}>;
+//#endregion
+//#region src/generated/programs/satiRegistry.d.ts
+declare const SATI_REGISTRY_PROGRAM_ADDRESS: Address$1<"satiFVb9MDmfR4ZfRedyKPLGLCg3saQ7Wbxtx9AEeeF">;
+declare enum SatiRegistryAccount {
+  RegistryConfig = 0,
+}
+declare function identifySatiRegistryAccount(account: {
+  data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): SatiRegistryAccount;
+declare enum SatiRegistryInstruction {
+  Initialize = 0,
+  RegisterAgent = 1,
+  UpdateRegistryAuthority = 2,
+}
+declare function identifySatiRegistryInstruction(instruction: {
+  data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): SatiRegistryInstruction;
+type ParsedSatiRegistryInstruction<TProgram extends string = "satiFVb9MDmfR4ZfRedyKPLGLCg3saQ7Wbxtx9AEeeF"> = ({
+  instructionType: SatiRegistryInstruction.Initialize;
+} & ParsedInitializeInstruction<TProgram>) | ({
+  instructionType: SatiRegistryInstruction.RegisterAgent;
+} & ParsedRegisterAgentInstruction<TProgram>) | ({
+  instructionType: SatiRegistryInstruction.UpdateRegistryAuthority;
+} & ParsedUpdateRegistryAuthorityInstruction<TProgram>);
+//#endregion
+//#region src/generated/instructions/initialize.d.ts
+declare const INITIALIZE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitializeDiscriminatorBytes(): ReadonlyUint8Array;
+type InitializeInstruction<TProgram extends string = typeof SATI_REGISTRY_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountRegistryConfig extends string | AccountMeta<string> = string, TAccountGroupMint extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountAuthority extends string ? WritableSignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority, TAccountRegistryConfig extends string ? WritableAccount<TAccountRegistryConfig> : TAccountRegistryConfig, TAccountGroupMint extends string ? WritableAccount<TAccountGroupMint> : TAccountGroupMint, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+type InitializeInstructionData = {
+  discriminator: ReadonlyUint8Array;
+};
+type InitializeInstructionDataArgs = {};
+declare function getInitializeInstructionDataEncoder(): FixedSizeEncoder<InitializeInstructionDataArgs>;
+declare function getInitializeInstructionDataDecoder(): FixedSizeDecoder<InitializeInstructionData>;
+declare function getInitializeInstructionDataCodec(): FixedSizeCodec<InitializeInstructionDataArgs, InitializeInstructionData>;
+type InitializeAsyncInput<TAccountAuthority extends string = string, TAccountRegistryConfig extends string = string, TAccountGroupMint extends string = string, TAccountSystemProgram extends string = string> = {
+  /** Initial registry authority (will be multisig in production) */
+  authority: TransactionSigner<TAccountAuthority>;
+  /** Registry configuration PDA */
+  registryConfig?: Address$1<TAccountRegistryConfig>;
+  /** TokenGroup mint - created and initialized by client, then finalized here */
+  groupMint: Address$1<TAccountGroupMint>;
+  systemProgram?: Address$1<TAccountSystemProgram>;
+};
+declare function getInitializeInstructionAsync<TAccountAuthority extends string, TAccountRegistryConfig extends string, TAccountGroupMint extends string, TAccountSystemProgram extends string, TProgramAddress extends Address$1 = typeof SATI_REGISTRY_PROGRAM_ADDRESS>(input: InitializeAsyncInput<TAccountAuthority, TAccountRegistryConfig, TAccountGroupMint, TAccountSystemProgram>, config?: {
+  programAddress?: TProgramAddress;
+}): Promise<InitializeInstruction<TProgramAddress, TAccountAuthority, TAccountRegistryConfig, TAccountGroupMint, TAccountSystemProgram>>;
+type InitializeInput<TAccountAuthority extends string = string, TAccountRegistryConfig extends string = string, TAccountGroupMint extends string = string, TAccountSystemProgram extends string = string> = {
+  /** Initial registry authority (will be multisig in production) */
+  authority: TransactionSigner<TAccountAuthority>;
+  /** Registry configuration PDA */
+  registryConfig: Address$1<TAccountRegistryConfig>;
+  /** TokenGroup mint - created and initialized by client, then finalized here */
+  groupMint: Address$1<TAccountGroupMint>;
+  systemProgram?: Address$1<TAccountSystemProgram>;
+};
+declare function getInitializeInstruction<TAccountAuthority extends string, TAccountRegistryConfig extends string, TAccountGroupMint extends string, TAccountSystemProgram extends string, TProgramAddress extends Address$1 = typeof SATI_REGISTRY_PROGRAM_ADDRESS>(input: InitializeInput<TAccountAuthority, TAccountRegistryConfig, TAccountGroupMint, TAccountSystemProgram>, config?: {
+  programAddress?: TProgramAddress;
+}): InitializeInstruction<TProgramAddress, TAccountAuthority, TAccountRegistryConfig, TAccountGroupMint, TAccountSystemProgram>;
+type ParsedInitializeInstruction<TProgram extends string = typeof SATI_REGISTRY_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+  programAddress: Address$1<TProgram>;
+  accounts: {
+    /** Initial registry authority (will be multisig in production) */
+    authority: TAccountMetas[0];
+    /** Registry configuration PDA */
+    registryConfig: TAccountMetas[1];
+    /** TokenGroup mint - created and initialized by client, then finalized here */
+    groupMint: TAccountMetas[2];
+    systemProgram: TAccountMetas[3];
+  };
+  data: InitializeInstructionData;
+};
+declare function parseInitializeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitializeInstruction<TProgram, TAccountMetas>;
+//#endregion
+//#region src/generated/types/agentRegistered.d.ts
+type AgentRegistered = {
+  mint: Address$1;
+  owner: Address$1;
+  memberNumber: bigint;
+  name: string;
+  uri: string;
+  nonTransferable: boolean;
+};
+type AgentRegisteredArgs = {
+  mint: Address$1;
+  owner: Address$1;
+  memberNumber: number | bigint;
+  name: string;
+  uri: string;
+  nonTransferable: boolean;
+};
+declare function getAgentRegisteredEncoder(): Encoder<AgentRegisteredArgs>;
+declare function getAgentRegisteredDecoder(): Decoder<AgentRegistered>;
+declare function getAgentRegisteredCodec(): Codec<AgentRegisteredArgs, AgentRegistered>;
+//#endregion
+//#region src/generated/types/metadataEntry.d.ts
+/**
+ * Metadata key-value pair for agent registration
+ * Used as instruction argument (Anchor-compatible)
+ */
+type MetadataEntry = {
+  key: string;
+  value: string;
+};
+type MetadataEntryArgs = MetadataEntry;
+declare function getMetadataEntryEncoder(): Encoder<MetadataEntryArgs>;
+declare function getMetadataEntryDecoder(): Decoder<MetadataEntry>;
+declare function getMetadataEntryCodec(): Codec<MetadataEntryArgs, MetadataEntry>;
+//#endregion
+//#region src/generated/types/registryAuthorityUpdated.d.ts
+type RegistryAuthorityUpdated = {
+  oldAuthority: Address$1;
+  newAuthority: Option<Address$1>;
+};
+type RegistryAuthorityUpdatedArgs = {
+  oldAuthority: Address$1;
+  newAuthority: OptionOrNullable<Address$1>;
+};
+declare function getRegistryAuthorityUpdatedEncoder(): Encoder<RegistryAuthorityUpdatedArgs>;
+declare function getRegistryAuthorityUpdatedDecoder(): Decoder<RegistryAuthorityUpdated>;
+declare function getRegistryAuthorityUpdatedCodec(): Codec<RegistryAuthorityUpdatedArgs, RegistryAuthorityUpdated>;
+//#endregion
+//#region src/generated/types/registryInitialized.d.ts
+type RegistryInitialized = {
+  authority: Address$1;
+  groupMint: Address$1;
+};
+type RegistryInitializedArgs = RegistryInitialized;
+declare function getRegistryInitializedEncoder(): FixedSizeEncoder<RegistryInitializedArgs>;
+declare function getRegistryInitializedDecoder(): FixedSizeDecoder<RegistryInitialized>;
+declare function getRegistryInitializedCodec(): FixedSizeCodec<RegistryInitializedArgs, RegistryInitialized>;
+//#endregion
+//#region src/generated/instructions/registerAgent.d.ts
+declare const REGISTER_AGENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getRegisterAgentDiscriminatorBytes(): ReadonlyUint8Array;
+type RegisterAgentInstruction<TProgram extends string = typeof SATI_REGISTRY_PROGRAM_ADDRESS, TAccountPayer extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountRegistryConfig extends string | AccountMeta<string> = string, TAccountGroupMint extends string | AccountMeta<string> = string, TAccountAgentMint extends string | AccountMeta<string> = string, TAccountAgentTokenAccount extends string | AccountMeta<string> = string, TAccountToken2022Program extends string | AccountMeta<string> = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb", TAccountAssociatedTokenProgram extends string | AccountMeta<string> = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner, TAccountRegistryConfig extends string ? WritableAccount<TAccountRegistryConfig> : TAccountRegistryConfig, TAccountGroupMint extends string ? WritableAccount<TAccountGroupMint> : TAccountGroupMint, TAccountAgentMint extends string ? WritableSignerAccount<TAccountAgentMint> & AccountSignerMeta<TAccountAgentMint> : TAccountAgentMint, TAccountAgentTokenAccount extends string ? WritableAccount<TAccountAgentTokenAccount> : TAccountAgentTokenAccount, TAccountToken2022Program extends string ? ReadonlyAccount<TAccountToken2022Program> : TAccountToken2022Program, TAccountAssociatedTokenProgram extends string ? ReadonlyAccount<TAccountAssociatedTokenProgram> : TAccountAssociatedTokenProgram, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+type RegisterAgentInstructionData = {
+  discriminator: ReadonlyUint8Array;
+  name: string;
+  symbol: string;
+  uri: string;
+  additionalMetadata: Option<Array<MetadataEntry>>;
+  nonTransferable: boolean;
+};
+type RegisterAgentInstructionDataArgs = {
+  name: string;
+  symbol: string;
+  uri: string;
+  additionalMetadata: OptionOrNullable<Array<MetadataEntryArgs>>;
+  nonTransferable: boolean;
+};
+declare function getRegisterAgentInstructionDataEncoder(): Encoder<RegisterAgentInstructionDataArgs>;
+declare function getRegisterAgentInstructionDataDecoder(): Decoder<RegisterAgentInstructionData>;
+declare function getRegisterAgentInstructionDataCodec(): Codec<RegisterAgentInstructionDataArgs, RegisterAgentInstructionData>;
+type RegisterAgentAsyncInput<TAccountPayer extends string = string, TAccountOwner extends string = string, TAccountRegistryConfig extends string = string, TAccountGroupMint extends string = string, TAccountAgentMint extends string = string, TAccountAgentTokenAccount extends string = string, TAccountToken2022Program extends string = string, TAccountAssociatedTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
+  /** Pays for account creation */
+  payer: TransactionSigner<TAccountPayer>;
+  /** Agent NFT owner (default: payer) */
+  owner: Address$1<TAccountOwner>;
+  /** Registry configuration */
+  registryConfig?: Address$1<TAccountRegistryConfig>;
+  /** TokenGroup mint (for membership) */
+  groupMint: Address$1<TAccountGroupMint>;
+  /** New agent NFT mint (randomly generated keypair) */
+  agentMint: TransactionSigner<TAccountAgentMint>;
+  /** Owner's ATA for agent NFT */
+  agentTokenAccount: Address$1<TAccountAgentTokenAccount>;
+  token2022Program?: Address$1<TAccountToken2022Program>;
+  associatedTokenProgram?: Address$1<TAccountAssociatedTokenProgram>;
+  systemProgram?: Address$1<TAccountSystemProgram>;
+  name: RegisterAgentInstructionDataArgs["name"];
+  symbol: RegisterAgentInstructionDataArgs["symbol"];
+  uri: RegisterAgentInstructionDataArgs["uri"];
+  additionalMetadata: RegisterAgentInstructionDataArgs["additionalMetadata"];
+  nonTransferable: RegisterAgentInstructionDataArgs["nonTransferable"];
+};
+declare function getRegisterAgentInstructionAsync<TAccountPayer extends string, TAccountOwner extends string, TAccountRegistryConfig extends string, TAccountGroupMint extends string, TAccountAgentMint extends string, TAccountAgentTokenAccount extends string, TAccountToken2022Program extends string, TAccountAssociatedTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address$1 = typeof SATI_REGISTRY_PROGRAM_ADDRESS>(input: RegisterAgentAsyncInput<TAccountPayer, TAccountOwner, TAccountRegistryConfig, TAccountGroupMint, TAccountAgentMint, TAccountAgentTokenAccount, TAccountToken2022Program, TAccountAssociatedTokenProgram, TAccountSystemProgram>, config?: {
+  programAddress?: TProgramAddress;
+}): Promise<RegisterAgentInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountRegistryConfig, TAccountGroupMint, TAccountAgentMint, TAccountAgentTokenAccount, TAccountToken2022Program, TAccountAssociatedTokenProgram, TAccountSystemProgram>>;
+type RegisterAgentInput<TAccountPayer extends string = string, TAccountOwner extends string = string, TAccountRegistryConfig extends string = string, TAccountGroupMint extends string = string, TAccountAgentMint extends string = string, TAccountAgentTokenAccount extends string = string, TAccountToken2022Program extends string = string, TAccountAssociatedTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
+  /** Pays for account creation */
+  payer: TransactionSigner<TAccountPayer>;
+  /** Agent NFT owner (default: payer) */
+  owner: Address$1<TAccountOwner>;
+  /** Registry configuration */
+  registryConfig: Address$1<TAccountRegistryConfig>;
+  /** TokenGroup mint (for membership) */
+  groupMint: Address$1<TAccountGroupMint>;
+  /** New agent NFT mint (randomly generated keypair) */
+  agentMint: TransactionSigner<TAccountAgentMint>;
+  /** Owner's ATA for agent NFT */
+  agentTokenAccount: Address$1<TAccountAgentTokenAccount>;
+  token2022Program?: Address$1<TAccountToken2022Program>;
+  associatedTokenProgram?: Address$1<TAccountAssociatedTokenProgram>;
+  systemProgram?: Address$1<TAccountSystemProgram>;
+  name: RegisterAgentInstructionDataArgs["name"];
+  symbol: RegisterAgentInstructionDataArgs["symbol"];
+  uri: RegisterAgentInstructionDataArgs["uri"];
+  additionalMetadata: RegisterAgentInstructionDataArgs["additionalMetadata"];
+  nonTransferable: RegisterAgentInstructionDataArgs["nonTransferable"];
+};
+declare function getRegisterAgentInstruction<TAccountPayer extends string, TAccountOwner extends string, TAccountRegistryConfig extends string, TAccountGroupMint extends string, TAccountAgentMint extends string, TAccountAgentTokenAccount extends string, TAccountToken2022Program extends string, TAccountAssociatedTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address$1 = typeof SATI_REGISTRY_PROGRAM_ADDRESS>(input: RegisterAgentInput<TAccountPayer, TAccountOwner, TAccountRegistryConfig, TAccountGroupMint, TAccountAgentMint, TAccountAgentTokenAccount, TAccountToken2022Program, TAccountAssociatedTokenProgram, TAccountSystemProgram>, config?: {
+  programAddress?: TProgramAddress;
+}): RegisterAgentInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountRegistryConfig, TAccountGroupMint, TAccountAgentMint, TAccountAgentTokenAccount, TAccountToken2022Program, TAccountAssociatedTokenProgram, TAccountSystemProgram>;
+type ParsedRegisterAgentInstruction<TProgram extends string = typeof SATI_REGISTRY_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+  programAddress: Address$1<TProgram>;
+  accounts: {
+    /** Pays for account creation */
+    payer: TAccountMetas[0];
+    /** Agent NFT owner (default: payer) */
+    owner: TAccountMetas[1];
+    /** Registry configuration */
+    registryConfig: TAccountMetas[2];
+    /** TokenGroup mint (for membership) */
+    groupMint: TAccountMetas[3];
+    /** New agent NFT mint (randomly generated keypair) */
+    agentMint: TAccountMetas[4];
+    /** Owner's ATA for agent NFT */
+    agentTokenAccount: TAccountMetas[5];
+    token2022Program: TAccountMetas[6];
+    associatedTokenProgram: TAccountMetas[7];
+    systemProgram: TAccountMetas[8];
+  };
+  data: RegisterAgentInstructionData;
+};
+declare function parseRegisterAgentInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedRegisterAgentInstruction<TProgram, TAccountMetas>;
+//#endregion
+//#region src/generated/instructions/updateRegistryAuthority.d.ts
+declare const UPDATE_REGISTRY_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getUpdateRegistryAuthorityDiscriminatorBytes(): ReadonlyUint8Array;
+type UpdateRegistryAuthorityInstruction<TProgram extends string = typeof SATI_REGISTRY_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountRegistryConfig extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority, TAccountRegistryConfig extends string ? WritableAccount<TAccountRegistryConfig> : TAccountRegistryConfig, ...TRemainingAccounts]>;
+type UpdateRegistryAuthorityInstructionData = {
+  discriminator: ReadonlyUint8Array;
+  newAuthority: Option<Address$1>;
+};
+type UpdateRegistryAuthorityInstructionDataArgs = {
+  newAuthority: OptionOrNullable<Address$1>;
+};
+declare function getUpdateRegistryAuthorityInstructionDataEncoder(): Encoder<UpdateRegistryAuthorityInstructionDataArgs>;
+declare function getUpdateRegistryAuthorityInstructionDataDecoder(): Decoder<UpdateRegistryAuthorityInstructionData>;
+declare function getUpdateRegistryAuthorityInstructionDataCodec(): Codec<UpdateRegistryAuthorityInstructionDataArgs, UpdateRegistryAuthorityInstructionData>;
+type UpdateRegistryAuthorityAsyncInput<TAccountAuthority extends string = string, TAccountRegistryConfig extends string = string> = {
+  /** Current authority (must sign) */
+  authority: TransactionSigner<TAccountAuthority>;
+  /** Registry configuration */
+  registryConfig?: Address$1<TAccountRegistryConfig>;
+  newAuthority: UpdateRegistryAuthorityInstructionDataArgs["newAuthority"];
+};
+declare function getUpdateRegistryAuthorityInstructionAsync<TAccountAuthority extends string, TAccountRegistryConfig extends string, TProgramAddress extends Address$1 = typeof SATI_REGISTRY_PROGRAM_ADDRESS>(input: UpdateRegistryAuthorityAsyncInput<TAccountAuthority, TAccountRegistryConfig>, config?: {
+  programAddress?: TProgramAddress;
+}): Promise<UpdateRegistryAuthorityInstruction<TProgramAddress, TAccountAuthority, TAccountRegistryConfig>>;
+type UpdateRegistryAuthorityInput<TAccountAuthority extends string = string, TAccountRegistryConfig extends string = string> = {
+  /** Current authority (must sign) */
+  authority: TransactionSigner<TAccountAuthority>;
+  /** Registry configuration */
+  registryConfig: Address$1<TAccountRegistryConfig>;
+  newAuthority: UpdateRegistryAuthorityInstructionDataArgs["newAuthority"];
+};
+declare function getUpdateRegistryAuthorityInstruction<TAccountAuthority extends string, TAccountRegistryConfig extends string, TProgramAddress extends Address$1 = typeof SATI_REGISTRY_PROGRAM_ADDRESS>(input: UpdateRegistryAuthorityInput<TAccountAuthority, TAccountRegistryConfig>, config?: {
+  programAddress?: TProgramAddress;
+}): UpdateRegistryAuthorityInstruction<TProgramAddress, TAccountAuthority, TAccountRegistryConfig>;
+type ParsedUpdateRegistryAuthorityInstruction<TProgram extends string = typeof SATI_REGISTRY_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+  programAddress: Address$1<TProgram>;
+  accounts: {
+    /** Current authority (must sign) */
+    authority: TAccountMetas[0];
+    /** Registry configuration */
+    registryConfig: TAccountMetas[1];
+  };
+  data: UpdateRegistryAuthorityInstructionData;
+};
+declare function parseUpdateRegistryAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUpdateRegistryAuthorityInstruction<TProgram, TAccountMetas>;
+//#endregion
+//#region src/schemas.d.ts
+/**
+ * SATI SAS Schema Definitions
+ *
+ * Schema definitions for Solana Attestation Service (SAS) attestations.
+ * These schemas define the data structures for SATI reputation and validation.
+ */
+/**
+ * SAS Layout Types
+ *
+ * Type-safe enum for schema field layout definitions.
+ * These map to the SAS program's internal type codes.
+ *
+ * @see https://github.com/solana-foundation/solana-attestation-service
+ */
+declare enum SASLayoutType {
+  /** Unsigned 8-bit integer (0-255) */
+  U8 = 0,
+  /** Unsigned 16-bit integer (0-65535) */
+  U16 = 1,
+  /** Unsigned 32-bit integer */
+  U32 = 2,
+  /** Unsigned 64-bit integer */
+  U64 = 3,
+  /** Unsigned 128-bit integer */
+  U128 = 4,
+  /** Signed 8-bit integer */
+  I8 = 5,
+  /** Signed 16-bit integer */
+  I16 = 6,
+  /** Signed 32-bit integer */
+  I32 = 7,
+  /** Signed 64-bit integer (for timestamps) */
+  I64 = 8,
+  /** Signed 128-bit integer */
+  I128 = 9,
+  /** Boolean */
+  Bool = 10,
+  /** Single character */
+  Char = 11,
+  /** UTF-8 string with 4-byte length prefix */
+  String = 12,
+  /** Byte array with 4-byte length prefix */
+  VecU8 = 13,
+}
+/**
+ * SAS Schema definition structure
+ */
+interface SASSchema {
+  name: string;
+  version: number;
+  description: string;
+  layout: SASLayoutType[];
+  fieldNames: string[];
+}
+/**
+ * FeedbackAuth Schema - Authorization for client to submit feedback
+ *
+ * Replaces ERC-8004's off-chain signature with on-chain attestation.
+ *
+ * Attestation configuration:
+ * - credential = agent NFT mint
+ * - subject = client pubkey (authorized reviewer)
+ * - issuer = agent owner
+ * - nonce = hash(agentMint, clientPubkey)
+ */
+declare const FEEDBACK_AUTH_SCHEMA: SASSchema;
+/**
+ * Feedback Schema - Client feedback for agent (ERC-8004 compatible)
+ *
+ * Attestation configuration:
+ * - credential = agent NFT mint
+ * - issuer = client (feedback giver)
+ * - nonce = hash(agent_mint, client_pubkey, timestamp)
+ */
+declare const FEEDBACK_SCHEMA: SASSchema;
+/**
+ * FeedbackResponse Schema - Response to feedback (ERC-8004 appendResponse)
+ *
+ * Attestation configuration:
+ * - credential = agent NFT mint
+ * - issuer = responder (agent owner, auditor, etc.)
+ * - nonce = hash(feedback_id, responder_pubkey, index)
+ */
+declare const FEEDBACK_RESPONSE_SCHEMA: SASSchema;
+/**
+ * ValidationRequest Schema - Agent requests work validation
+ *
+ * Attestation configuration:
+ * - credential = agent NFT mint
+ * - subject = validator pubkey
+ * - issuer = agent owner
+ * - nonce = hash(agent_mint, validator_pubkey, user_nonce)
+ */
+declare const VALIDATION_REQUEST_SCHEMA: SASSchema;
+/**
+ * ValidationResponse Schema - Validator responds to request
+ *
+ * Attestation configuration:
+ * - credential = agent NFT mint (from request)
+ * - issuer = validator
+ * - nonce = hash(request_id, response_index)
+ */
+declare const VALIDATION_RESPONSE_SCHEMA: SASSchema;
+/**
+ * Certification Schema - Immutable certification for agent
+ *
+ * For permanent, unmodifiable records (security audits, compliance
+ * certifications, credential attestations). SAS attestations are
+ * immutable by design - content cannot be modified after creation.
+ *
+ * Attestation configuration:
+ * - credential = agent NFT mint
+ * - issuer = certifier (e.g., audit firm)
+ * - nonce = hash(agent_mint, certifier_pubkey, cert_type, issued_at)
+ */
+declare const CERTIFICATION_SCHEMA: SASSchema;
+/**
+ * All SATI SAS schemas
+ */
+declare const SATI_SCHEMAS: {
+  readonly feedbackAuth: SASSchema;
+  readonly feedback: SASSchema;
+  readonly feedbackResponse: SASSchema;
+  readonly validationRequest: SASSchema;
+  readonly validationResponse: SASSchema;
+  readonly certification: SASSchema;
+};
+/**
+ * Schema names for lookup
+ */
+declare const SCHEMA_NAMES: {
+  readonly FEEDBACK_AUTH: "SATIFeedbackAuth";
+  readonly FEEDBACK: "SATIFeedback";
+  readonly FEEDBACK_RESPONSE: "SATIFeedbackResponse";
+  readonly VALIDATION_REQUEST: "SATIValidationRequest";
+  readonly VALIDATION_RESPONSE: "SATIValidationResponse";
+  readonly CERTIFICATION: "SATICertification";
+};
+//#endregion
+//#region src/types.d.ts
+/**
+ * Agent identity information retrieved from Token-2022 NFT
+ */
+interface AgentIdentity {
+  /** Agent NFT mint address */
+  mint: Address$1;
+  /** Current owner of the agent NFT */
+  owner: Address$1;
+  /** Agent name from metadata */
+  name: string;
+  /** Agent symbol from metadata */
+  symbol: string;
+  /** Registration file URI (IPFS/HTTP) */
+  uri: string;
+  /** Token group member number */
+  memberNumber: bigint;
+  /** Additional metadata key-value pairs */
+  additionalMetadata: Record<string, string>;
+  /** Whether the agent is non-transferable (soulbound) */
+  nonTransferable: boolean;
+}
+/**
+ * Feedback attestation data from SAS
+ */
+interface Feedback {
+  /** Feedback attestation address */
+  attestation: Address$1;
+  /** Agent mint receiving feedback */
+  agentMint: Address$1;
+  /** Feedback score (0-100) */
+  score: number;
+  /** Optional categorization tags */
+  tag1?: string;
+  tag2?: string;
+  /** URI to off-chain feedback details */
+  fileUri?: string;
+  /** SHA-256 hash of feedback file */
+  fileHash?: Uint8Array;
+  /** x402 payment proof reference */
+  paymentProof?: string;
+  /** Feedback giver's address */
+  issuer: Address$1;
+  /** Attestation expiry timestamp (0 = no expiry) */
+  expiry: number;
+  /** Whether attestation is revoked */
+  revoked: boolean;
+}
+/**
+ * Feedback authorization attestation data from SAS
+ */
+interface FeedbackAuthorization {
+  /** Authorization attestation address */
+  attestation: Address$1;
+  /** Agent mint that authorized feedback */
+  agentMint: Address$1;
+  /** Authorized client address */
+  client: Address$1;
+  /** Maximum feedback index allowed (ERC-8004 indexLimit) */
+  indexLimit: number;
+  /** Expiration timestamp (0 = no expiry) */
+  expiry: number;
+  /** Whether authorization is revoked */
+  revoked: boolean;
+}
+/**
+ * Validation request attestation data from SAS
+ */
+interface ValidationRequest {
+  /** Request attestation address */
+  attestation: Address$1;
+  /** Agent mint requesting validation */
+  agentMint: Address$1;
+  /** Validator address */
+  validator: Address$1;
+  /** Validation method ("tee", "zkml", "restake") */
+  methodId: string;
+  /** URI to validation request data */
+  requestUri: string;
+  /** SHA-256 hash of request content */
+  requestHash?: Uint8Array;
+  /** Request timestamp */
+  timestamp: number;
+}
+/**
+ * Validation status and response
+ */
+interface ValidationStatus {
+  /** Request attestation address */
+  requestAttestation: Address$1;
+  /** Response attestation address (if responded) */
+  responseAttestation?: Address$1;
+  /** Validation score (0-100, where 0=fail, 100=pass) */
+  response?: number;
+  /** URI to validation evidence */
+  responseUri?: string;
+  /** SHA-256 hash of response content */
+  responseHash?: Uint8Array;
+  /** Optional categorization tag */
+  tag?: string;
+  /** Validator address */
+  validator: Address$1;
+  /** Whether validation is complete */
+  completed: boolean;
+  /** Response attestation expiry timestamp */
+  responseExpiry?: number;
+}
+/**
+ * Registration result from registerAgent
+ */
+interface RegisterAgentResult {
+  /** Agent NFT mint address */
+  mint: Address$1;
+  /** Token group member number */
+  memberNumber: bigint;
+  /** Transaction signature */
+  signature: string;
+}
+/**
+ * Attestation result from SAS operations
+ */
+interface AttestationResult {
+  /** Attestation account address */
+  attestation: Address$1;
+  /** Transaction signature */
+  signature: string;
+}
+/**
+ * SATI client configuration options
+ */
+interface SATIClientOptions {
+  /** Network to connect to */
+  network: "mainnet" | "devnet" | "localnet";
+  /** Custom RPC URL (overrides network default) */
+  rpcUrl?: string;
+  /** Custom WebSocket URL for subscriptions (overrides network default) */
+  wsUrl?: string;
+}
+/**
+ * SAS configuration with credential and schema addresses
+ */
+interface SATISASConfig {
+  /** SATI credential PDA */
+  credential: Address$1;
+  /** Schema PDAs by name */
+  schemas: {
+    feedbackAuth: Address$1;
+    feedback: Address$1;
+    feedbackResponse: Address$1;
+    validationRequest: Address$1;
+    validationResponse: Address$1;
+    certification: Address$1;
+  };
+}
+/**
+ * Status of a single schema deployment
+ */
+interface SchemaDeploymentStatus {
+  /** Schema name (e.g., "SATIFeedback") */
+  name: string;
+  /** Schema PDA address */
+  address: Address$1;
+  /** Whether schema existed before this deployment */
+  existed: boolean;
+  /** Whether schema was deployed in this run */
+  deployed: boolean;
+}
+/**
+ * Result of SAS schema deployment operation
+ */
+interface SASDeploymentResult {
+  /** Whether deployment was successful */
+  success: boolean;
+  /** Credential deployment status */
+  credential: {
+    /** Credential PDA address */
+    address: Address$1;
+    /** Whether credential existed before this deployment */
+    existed: boolean;
+    /** Whether credential was deployed in this run */
+    deployed: boolean;
+  };
+  /** Schema deployment statuses */
+  schemas: SchemaDeploymentStatus[];
+  /** Transaction signatures for any deployments */
+  signatures: string[];
+  /** Full SAS config (usable immediately) */
+  config: SATISASConfig;
+}
+/**
+ * Persisted deployment configuration (for JSON files)
+ */
+interface DeployedSASConfig {
+  /** Network identifier */
+  network: "devnet" | "mainnet" | "localnet";
+  /** Authority that deployed the schemas */
+  authority: Address$1;
+  /** Deployment timestamp (ISO string) */
+  deployedAt: string;
+  /** The SAS configuration */
+  config: SATISASConfig;
+}
+//#endregion
+//#region src/sas.d.ts
+/**
+ * SATI credential name used for all attestations
+ */
+declare const SATI_CREDENTIAL_NAME = "SATI";
+/**
+ * Schema names for SATI attestations
+ */
+declare const SATI_SCHEMA_NAMES: {
+  readonly FEEDBACK_AUTH: "SATIFeedbackAuth";
+  readonly FEEDBACK: "SATIFeedback";
+  readonly FEEDBACK_RESPONSE: "SATIFeedbackResponse";
+  readonly VALIDATION_REQUEST: "SATIValidationRequest";
+  readonly VALIDATION_RESPONSE: "SATIValidationResponse";
+  readonly CERTIFICATION: "SATICertification";
+};
+/**
+ * All SATI schemas with their definitions (keyed by schema name constant)
+ */
+declare const SATI_SAS_SCHEMAS: Record<keyof typeof SATI_SCHEMA_NAMES, SASSchema>;
+/**
+ * Derive SATI credential PDA
+ *
+ * @param authority - Credential authority address
+ * @returns Credential PDA and bump
+ */
+declare function deriveSatiCredentialPda(authority: Address$1): Promise<readonly [Address$1, number]>;
+/**
+ * Derive SATI schema PDA
+ *
+ * @param credentialPda - SATI credential PDA
+ * @param schemaName - Schema name (e.g., "SATIFeedback")
+ * @param version - Schema version (default: 1)
+ * @returns Schema PDA and bump
+ */
+declare function deriveSatiSchemaPda(credentialPda: Address$1, schemaName: string, version?: number): Promise<readonly [Address$1, number]>;
+/**
+ * Derive attestation PDA for a specific schema
+ *
+ * @param credentialPda - SATI credential PDA
+ * @param schemaPda - Schema PDA
+ * @param nonce - Unique nonce for this attestation (e.g., hash of agent + client)
+ * @returns Attestation PDA and bump
+ */
+declare function deriveSatiAttestationPda(credentialPda: Address$1, schemaPda: Address$1, nonce: Address$1): Promise<readonly [Address$1, number]>;
+/**
+ * Get instructions to create SATI credential
+ *
+ * @param params - Creation parameters
+ * @returns Instruction to create credential
+ */
+declare function getCreateSatiCredentialInstruction(params: {
+  payer: TransactionSigner;
+  authority: TransactionSigner;
+  credentialPda: Address$1;
+  authorizedSigners: Address$1[];
+}): sas_lib0.CreateCredentialInstruction<Address$1<"22zoJMtdu4tQc2PzL74ZUT7FrwgB1Udec8DdW4yw4BdG">, string, string, string, string, []>;
+/**
+ * Get instruction to create a SATI schema
+ *
+ * @param params - Schema creation parameters
+ * @returns Instruction to create schema
+ */
+declare function getCreateSatiSchemaInstruction(params: {
+  payer: TransactionSigner;
+  authority: TransactionSigner;
+  credentialPda: Address$1;
+  schemaPda: Address$1;
+  schema: SASSchema;
+}): sas_lib0.CreateSchemaInstruction<Address$1<"22zoJMtdu4tQc2PzL74ZUT7FrwgB1Udec8DdW4yw4BdG">, string, string, string, string, string, []>;
+/**
+ * Serialize feedback authorization data for attestation
+ *
+ * @param data - FeedbackAuth data
+ * @param schemaData - Schema account data from fetchSchema
+ * @returns Serialized data buffer
+ */
+declare function serializeFeedbackAuthData(data: {
+  agent_mint: string;
+  index_limit: number;
+  expiry: number;
+}, schemaData: Awaited<ReturnType<typeof fetchSchema>>["data"]): Uint8Array;
+/**
+ * Serialize feedback data for attestation
+ *
+ * @param data - Feedback data
+ * @param schemaData - Schema account data from fetchSchema
+ * @returns Serialized data buffer
+ */
+declare function serializeFeedbackData(data: {
+  agent_mint: string;
+  score: number;
+  tag1?: string;
+  tag2?: string;
+  fileuri?: string;
+  filehash?: Uint8Array;
+  payment_proof?: string;
+}, schemaData: Awaited<ReturnType<typeof fetchSchema>>["data"]): Uint8Array;
+/**
+ * Serialize feedback response data for attestation
+ *
+ * @param data - FeedbackResponse data
+ * @param schemaData - Schema account data from fetchSchema
+ * @returns Serialized data buffer
+ */
+declare function serializeFeedbackResponseData(data: {
+  feedback_id: string;
+  response_uri: string;
+  response_hash?: Uint8Array;
+}, schemaData: Awaited<ReturnType<typeof fetchSchema>>["data"]): Uint8Array;
+/**
+ * Serialize validation request data for attestation
+ *
+ * @param data - ValidationRequest data
+ * @param schemaData - Schema account data from fetchSchema
+ * @returns Serialized data buffer
+ */
+declare function serializeValidationRequestData(data: {
+  agent_mint: string;
+  method_id: string;
+  request_uri: string;
+  request_hash?: Uint8Array;
+}, schemaData: Awaited<ReturnType<typeof fetchSchema>>["data"]): Uint8Array;
+/**
+ * Serialize validation response data for attestation
+ *
+ * @param data - ValidationResponse data
+ * @param schemaData - Schema account data from fetchSchema
+ * @returns Serialized data buffer
+ */
+declare function serializeValidationResponseData(data: {
+  request_id: string;
+  response: number;
+  response_uri?: string;
+  response_hash?: Uint8Array;
+  tag?: string;
+}, schemaData: Awaited<ReturnType<typeof fetchSchema>>["data"]): Uint8Array;
+/**
+ * Compute nonce for FeedbackAuth attestation
+ * nonce = keccak256("feedbackAuth:" + agentMint + ":" + clientPubkey)
+ *
+ * @param agentMint - Agent NFT mint address
+ * @param clientPubkey - Client public key
+ * @returns Nonce as Address (base58)
+ */
+declare function computeFeedbackAuthNonce(agentMint: Address$1, clientPubkey: Address$1): Address$1;
+/**
+ * Compute nonce for Feedback attestation
+ * nonce = keccak256("feedback:" + agentMint + ":" + clientPubkey + ":" + timestamp)
+ *
+ * @param agentMint - Agent NFT mint address
+ * @param clientPubkey - Client public key
+ * @param timestamp - Unix timestamp
+ * @returns Nonce as Address (base58)
+ */
+declare function computeFeedbackNonce(agentMint: Address$1, clientPubkey: Address$1, timestamp: number): Address$1;
+/**
+ * Compute nonce for FeedbackResponse attestation
+ * nonce = keccak256("response:" + feedbackId + ":" + responderPubkey + ":" + index)
+ *
+ * @param feedbackId - Feedback attestation address
+ * @param responderPubkey - Responder public key
+ * @param index - Response index
+ * @returns Nonce as Address (base58)
+ */
+declare function computeFeedbackResponseNonce(feedbackId: Address$1, responderPubkey: Address$1, index: number): Address$1;
+/**
+ * Compute nonce for ValidationRequest attestation
+ * nonce = keccak256("validationReq:" + agentMint + ":" + validatorPubkey + ":" + userNonce)
+ *
+ * @param agentMint - Agent NFT mint address
+ * @param validatorPubkey - Validator public key
+ * @param userNonce - User-provided nonce
+ * @returns Nonce as Address (base58)
+ */
+declare function computeValidationRequestNonce(agentMint: Address$1, validatorPubkey: Address$1, userNonce: number): Address$1;
+/**
+ * Compute nonce for ValidationResponse attestation
+ * nonce = keccak256("validationResp:" + requestId + ":" + responseIndex)
+ *
+ * @param requestId - Request attestation address
+ * @param responseIndex - Response index
+ * @returns Nonce as Address (base58)
+ */
+declare function computeValidationResponseNonce(requestId: Address$1, responseIndex: number): Address$1;
+/**
+ * Serialize certification data for attestation
+ *
+ * @param data - Certification data
+ * @param schemaData - Schema account data from fetchSchema
+ * @returns Serialized data buffer
+ */
+declare function serializeCertificationData(data: {
+  certifier: string;
+  cert_type: string;
+  cert_uri: string;
+  issued_at: number;
+}, schemaData: Awaited<ReturnType<typeof fetchSchema>>["data"]): Uint8Array;
+/**
+ * Compute nonce for Certification attestation
+ * nonce = keccak256("certification:" + agentMint + ":" + certifierPubkey + ":" + certType + ":" + issuedAt)
+ *
+ * @param agentMint - Agent NFT mint address
+ * @param certifierPubkey - Certifier public key
+ * @param certType - Certification type (e.g., "security-audit")
+ * @param issuedAt - Unix timestamp
+ * @returns Nonce as Address (base58)
+ */
+declare function computeCertificationNonce(agentMint: Address$1, certifierPubkey: Address$1, certType: string, issuedAt: number): Address$1;
+//#endregion
+//#region src/helpers.d.ts
+declare const TOKEN_2022_PROGRAM_ADDRESS: Address$1<"TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb">;
+declare const ASSOCIATED_TOKEN_PROGRAM_ADDRESS: Address$1<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">;
+/**
+ * Derive the Registry Config PDA
+ *
+ * Seeds: ["registry"]
+ */
+declare function findRegistryConfigPda(): Promise<readonly [Address$1, number]>;
+/**
+ * Derive the Group Mint PDA (SATI collection)
+ *
+ * Seeds: ["group_mint"]
+ */
+declare function findGroupMintPda(): Promise<readonly [Address$1, number]>;
+/**
+ * Derive Associated Token Account address for Token-2022
+ *
+ * @param mint - Token mint address
+ * @param owner - Token account owner
+ */
+declare function findAssociatedTokenAddress(mint: Address$1, owner: Address$1): Promise<readonly [Address$1, number]>;
+//#endregion
+//#region src/deployed/index.d.ts
+/**
+ * Load deployed SAS configuration for a network
+ *
+ * @param network - Network identifier ("devnet", "mainnet", "localnet")
+ * @returns SAS config if deployed, null otherwise
+ */
+declare function loadDeployedConfig(network: string): SATISASConfig | null;
+/**
+ * Check if a network has deployed SAS configuration
+ *
+ * @param network - Network identifier
+ * @returns true if config exists for network
+ */
+declare function hasDeployedConfig(network: string): boolean;
+/**
+ * Get list of networks with deployed configurations
+ *
+ * @returns Array of network names with deployed configs
+ */
+declare function getDeployedNetworks(): string[];
+//#endregion
+//#region src/client.d.ts
+/**
+ * SATI Client
+ *
+ * High-level interface for interacting with SATI protocol.
+ *
+ * @example
+ * ```typescript
+ * const sati = new SATI({ network: "devnet" });
+ *
+ * // Register an agent
+ * const { mint, memberNumber } = await sati.registerAgent({
+ *   payer,
+ *   name: "MyAgent",
+ *   uri: "ipfs://QmRegistrationFile",
+ * });
+ *
+ * // Load agent identity
+ * const agent = await sati.loadAgent(mint);
+ * ```
+ */
+declare class SATI {
+  private rpc;
+  private rpcSubscriptions;
+  private sendAndConfirm;
+  private network;
+  private sasConfig;
+  constructor(options: SATIClientOptions);
+  /**
+   * Set SAS configuration for reputation/validation operations
+   *
+   * This should be called after SATI schemas are deployed to the network.
+   * Use setupSASSchemas() to deploy schemas if they don't exist yet.
+   *
+   * @param config - SAS credential and schema addresses
+   */
+  setSASConfig(config: SATISASConfig): void;
+  /**
+   * Get current SAS configuration
+   */
+  getSASConfig(): SATISASConfig | null;
+  /**
+   * Ensure SAS config is set, throw if not
+   */
+  private requireSASConfig;
+  /**
+   * Register a new agent identity
+   *
+   * Creates a Token-2022 NFT with metadata and group membership atomically.
+   *
+   * **Compute Budget Note:**
+   * Each additional metadata entry adds ~5-10k compute units.
+   * When using >5 entries, the on-chain program logs a warning suggesting
+   * 400k CUs. If transactions fail with compute exceeded, prepend a
+   * SetComputeUnitLimit instruction to your transaction.
+   *
+   * @param params - Registration parameters
+   * @returns Mint address and member number
+   */
+  registerAgent(params: {
+    /** Payer for transaction and rent */
+    payer: KeyPairSigner;
+    /** Agent name (max 32 bytes) */
+    name: string;
+    /** Agent symbol (max 10 bytes, default: "SATI") */
+    symbol?: string;
+    /** Registration file URI (max 200 bytes) */
+    uri: string;
+    /** Additional metadata key-value pairs (max 10 entries) */
+    additionalMetadata?: Array<{
+      key: string;
+      value: string;
+    }>;
+    /** Make agent non-transferable (soulbound) */
+    nonTransferable?: boolean;
+    /** Owner of the agent NFT (default: payer) */
+    owner?: Address$1;
+  }): Promise<RegisterAgentResult>;
+  /**
+   * Get registry statistics
+   */
+  getRegistryStats(): Promise<{
+    groupMint: Address$1;
+    authority: Address$1;
+    totalAgents: bigint;
+    isImmutable: boolean;
+  }>;
+  /**
+   * Load agent identity from mint address
+   *
+   * Fetches Token-2022 metadata and group membership.
+   *
+   * @param mint - Agent NFT mint address
+   * @returns Agent identity or null if not found
+   */
+  loadAgent(mint: Address$1): Promise<AgentIdentity | null>;
+  /**
+   * Update agent metadata
+   *
+   * Directly calls Token-2022 updateTokenMetadataField instruction.
+   * Requires owner signature.
+   *
+   * Note: This method requires building raw instructions for the
+   * spl-token-metadata-interface. For now, use @solana/spl-token directly
+   * or the Anchor client for metadata updates.
+   *
+   * @param _mint - Agent NFT mint address
+   * @param _updates - Fields to update
+   */
+  updateAgentMetadata(_mint: Address$1, _updates: {
+    name?: string;
+    uri?: string;
+    additionalMetadata?: Array<{
+      key: string;
+      value: string;
+    }>;
+  }): Promise<void>;
+  /**
+   * Transfer agent to new owner
+   *
+   * Standard Token-2022 transfer. Requires current owner signature.
+   *
+   * @param params - Transfer parameters
+   */
+  transferAgent(params: {
+    /** Payer for transaction fees and new ATA creation */
+    payer: KeyPairSigner;
+    /** Current owner (must sign) */
+    owner: KeyPairSigner;
+    /** Agent NFT mint address */
+    mint: Address$1;
+    /** New owner address */
+    newOwner: Address$1;
+  }): Promise<{
+    signature: string;
+  }>;
+  /**
+   * Get current owner of an agent
+   *
+   * Finds the token account holding the NFT and returns its owner.
+   *
+   * @param mint - Agent NFT mint address
+   * @returns Owner address
+   */
+  getAgentOwner(mint: Address$1): Promise<Address$1>;
+  /**
+   * List registered agents
+   *
+   * Uses getProgramAccounts to find all SATI agent NFTs.
+   * For better performance at scale, use an indexer.
+   *
+   * @param params - Pagination parameters
+   * @returns Array of agent identities
+   */
+  listAgents(params?: {
+    offset?: number;
+    limit?: number;
+  }): Promise<AgentIdentity[]>;
+  /**
+   * Authorize a client to submit feedback
+   *
+   * Creates a FeedbackAuth attestation via SAS.
+   * Must be called by the agent owner.
+   *
+   * @param params - Authorization parameters
+   * @returns Attestation address and signature
+   */
+  authorizeFeedback(params: {
+    /** Payer for transaction */
+    payer: KeyPairSigner;
+    /** Agent owner (must sign) */
+    agentOwner: KeyPairSigner;
+    /** Agent NFT mint address */
+    agentMint: Address$1;
+    /** Client to authorize */
+    client: Address$1;
+    /** Maximum feedback index allowed (ERC-8004: indexLimit) */
+    indexLimit: number;
+    /** Expiration timestamp (0 = no expiry) */
+    expiry?: number;
+  }): Promise<AttestationResult>;
+  /**
+   * Revoke feedback authorization
+   *
+   * Closes the FeedbackAuth attestation and reclaims rent.
+   *
+   * @param params - Revocation parameters
+   */
+  revokeAuthorization(params: {
+    /** Payer (receives rent refund) */
+    payer: KeyPairSigner;
+    /** Authority who created the attestation */
+    authority: KeyPairSigner;
+    /** FeedbackAuth attestation address to revoke */
+    attestation: Address$1;
+  }): Promise<{
+    signature: string;
+  }>;
+  /**
+   * Submit feedback for an agent
+   *
+   * Creates a Feedback attestation via SAS.
+   * Requires prior authorization from agent owner via authorizeFeedback().
+   *
+   * @param params - Feedback parameters
+   * @returns Attestation address and signature
+   */
+  giveFeedback(params: {
+    /** Payer for transaction */
+    payer: KeyPairSigner;
+    /** Client submitting feedback (must be authorized) */
+    client: KeyPairSigner;
+    /** Agent NFT mint receiving feedback */
+    agentMint: Address$1;
+    /** Score 0-100 */
+    score: number;
+    /** Optional tag (ERC-8004: tag1) */
+    tag1?: string;
+    /** Optional tag (ERC-8004: tag2) */
+    tag2?: string;
+    /** Off-chain feedback file URI (ERC-8004: fileuri) */
+    fileuri?: string;
+    /** File hash (ERC-8004: filehash) */
+    filehash?: Uint8Array;
+    /** x402 payment proof reference */
+    paymentProof?: string;
+  }): Promise<AttestationResult>;
+  /**
+   * Revoke submitted feedback
+   *
+   * Closes the Feedback attestation and reclaims rent.
+   *
+   * @param params - Revocation parameters
+   */
+  revokeFeedback(params: {
+    /** Payer (receives rent refund) */
+    payer: KeyPairSigner;
+    /** Client who submitted the feedback */
+    client: KeyPairSigner;
+    /** Feedback attestation address to revoke */
+    attestation: Address$1;
+  }): Promise<{
+    signature: string;
+  }>;
+  /**
+   * Append response to feedback
+   *
+   * Creates a FeedbackResponse attestation via SAS.
+   * Can be called by agent owner, auditor, or anyone.
+   *
+   * @param params - Response parameters
+   * @returns Attestation address and signature
+   */
+  appendResponse(params: {
+    /** Payer for transaction */
+    payer: KeyPairSigner;
+    /** Responder (signer) */
+    responder: KeyPairSigner;
+    /** Feedback attestation being responded to */
+    feedbackAttestation: Address$1;
+    /** Off-chain response URI */
+    responseUri: string;
+    /** Response content hash */
+    responseHash?: Uint8Array;
+    /** Response index (allows multiple responses, default: 0) */
+    responseIndex?: number;
+  }): Promise<AttestationResult>;
+  /**
+   * Read feedback attestation
+   *
+   * @param attestation - Feedback attestation address
+   * @returns Feedback data or null if not found
+   */
+  readFeedback(attestation: Address$1): Promise<Feedback | null>;
+  /**
+   * Request validation from a validator
+   *
+   * Creates a ValidationRequest attestation via SAS.
+   * Must be called by agent owner.
+   *
+   * @param params - Request parameters
+   * @returns Attestation address and signature
+   */
+  requestValidation(params: {
+    /** Payer for transaction */
+    payer: KeyPairSigner;
+    /** Agent owner (must sign) */
+    agentOwner: KeyPairSigner;
+    /** Agent NFT mint requesting validation */
+    agentMint: Address$1;
+    /** Validator address */
+    validator: Address$1;
+    /** Validation method ("tee", "zkml", "restake") */
+    methodId: string;
+    /** Off-chain validation request URI */
+    requestUri: string;
+    /** Request content hash */
+    requestHash?: Uint8Array;
+  }): Promise<AttestationResult>;
+  /**
+   * Respond to a validation request
+   *
+   * Creates a ValidationResponse attestation via SAS.
+   * Called by validators.
+   *
+   * @param params - Response parameters
+   * @returns Attestation address and signature
+   */
+  respondToValidation(params: {
+    /** Payer for transaction */
+    payer: KeyPairSigner;
+    /** Validator (must sign) */
+    validator: KeyPairSigner;
+    /** ValidationRequest attestation being responded to */
+    requestAttestation: Address$1;
+    /** Response score 0-100 (0=fail, 100=pass) */
+    response: number;
+    /** Off-chain response/evidence URI */
+    responseUri?: string;
+    /** Response content hash */
+    responseHash?: Uint8Array;
+    /** Optional categorization tag */
+    tag?: string;
+    /** Response index (allows multiple responses, default: 0) */
+    responseIndex?: number;
+  }): Promise<AttestationResult>;
+  /**
+   * Get validation status
+   *
+   * Fetches the validation request and looks for any responses.
+   *
+   * @param requestAttestation - ValidationRequest attestation address
+   * @param responseIndex - Response index to check (default: 0)
+   * @returns Validation status or null if not found
+   */
+  getValidationStatus(requestAttestation: Address$1, responseIndex?: number): Promise<ValidationStatus | null>;
+  /**
+   * Setup SATI SAS schemas with idempotent deployment.
+   *
+   * This method is safe to call multiple times. It will:
+   * 1. Check which components already exist on-chain
+   * 2. Deploy only missing credential and schemas
+   * 3. Verify all components exist after deployment
+   *
+   * @param params - Setup parameters
+   * @returns Deployment result with status and config
+   */
+  setupSASSchemas(params: {
+    /** Payer for account creation */
+    payer: KeyPairSigner;
+    /** Credential authority (controls schema creation) */
+    authority: KeyPairSigner;
+    /** Authorized signers for attestations */
+    authorizedSigners?: Address$1[];
+    /** Deploy test schemas (v0) instead of production schemas */
+    testMode?: boolean;
+  }): Promise<SASDeploymentResult>;
+  /**
+   * Verify that all SAS components exist on-chain.
+   *
+   * @param config - SAS configuration to verify
+   * @returns Verification result with list of missing components
+   */
+  private verifySASDeployment;
+}
+//#endregion
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, type Address, AgentIdentity, AgentRegistered, AgentRegisteredArgs, AttestationResult, CERTIFICATION_SCHEMA, DeployedSASConfig, FEEDBACK_AUTH_SCHEMA, FEEDBACK_RESPONSE_SCHEMA, FEEDBACK_SCHEMA, Feedback, FeedbackAuthorization, INITIALIZE_DISCRIMINATOR, InitializeAsyncInput, InitializeInput, InitializeInstruction, InitializeInstructionData, InitializeInstructionDataArgs, MetadataEntry, MetadataEntryArgs, ParsedInitializeInstruction, ParsedRegisterAgentInstruction, ParsedSatiRegistryInstruction, ParsedUpdateRegistryAuthorityInstruction, REGISTER_AGENT_DISCRIMINATOR, REGISTRY_CONFIG_DISCRIMINATOR, RegisterAgentAsyncInput, RegisterAgentInput, RegisterAgentInstruction, RegisterAgentInstructionData, RegisterAgentInstructionDataArgs, RegisterAgentResult, RegistryAuthorityUpdated, RegistryAuthorityUpdatedArgs, RegistryConfig, RegistryConfigArgs, RegistryInitialized, RegistryInitializedArgs, SASDeploymentResult, SASLayoutType, SASSchema, SOLANA_ATTESTATION_SERVICE_PROGRAM_ADDRESS as SAS_PROGRAM_ID, SATI, SATIClientOptions, type SATISASConfig, SATI_CREDENTIAL_NAME, SATI_REGISTRY_ERROR__IMMUTABLE_AUTHORITY, SATI_REGISTRY_ERROR__INVALID_AUTHORITY, SATI_REGISTRY_ERROR__INVALID_GROUP_MINT, SATI_REGISTRY_ERROR__METADATA_KEY_TOO_LONG, SATI_REGISTRY_ERROR__METADATA_VALUE_TOO_LONG, SATI_REGISTRY_ERROR__MINT_AUTHORITY_NOT_RENOUNCED, SATI_REGISTRY_ERROR__NAME_TOO_LONG, SATI_REGISTRY_ERROR__OVERFLOW, SATI_REGISTRY_ERROR__SYMBOL_TOO_LONG, SATI_REGISTRY_ERROR__TOO_MANY_METADATA_ENTRIES, SATI_REGISTRY_ERROR__URI_TOO_LONG, SATI_REGISTRY_PROGRAM_ADDRESS, SATI_SAS_SCHEMAS, SATI_SCHEMAS, SATI_SCHEMA_NAMES, SCHEMA_NAMES, SatiRegistryAccount, SatiRegistryError, SatiRegistryInstruction, SchemaDeploymentStatus, TOKEN_2022_PROGRAM_ADDRESS, UPDATE_REGISTRY_AUTHORITY_DISCRIMINATOR, UpdateRegistryAuthorityAsyncInput, UpdateRegistryAuthorityInput, UpdateRegistryAuthorityInstruction, UpdateRegistryAuthorityInstructionData, UpdateRegistryAuthorityInstructionDataArgs, VALIDATION_REQUEST_SCHEMA, VALIDATION_RESPONSE_SCHEMA, ValidationRequest, ValidationStatus, address, computeCertificationNonce, computeFeedbackAuthNonce, computeFeedbackNonce, computeFeedbackResponseNonce, computeValidationRequestNonce, computeValidationResponseNonce, decodeRegistryConfig, deriveAttestationPda, deriveCredentialPda, deriveEventAuthorityAddress, deriveSatiAttestationPda, deriveSatiCredentialPda, deriveSatiSchemaPda, deriveSchemaPda, deserializeAttestationData, fetchAllMaybeRegistryConfig, fetchAllMaybeSchema, fetchAllRegistryConfig, fetchAttestation, fetchMaybeCredential, fetchMaybeRegistryConfig, fetchMaybeSchema, fetchRegistryConfig, fetchSchema, findAssociatedTokenAddress, findGroupMintPda, findRegistryConfigPda, getAgentRegisteredCodec, getAgentRegisteredDecoder, getAgentRegisteredEncoder, getCloseAttestationInstruction, getCreateAttestationInstruction, getCreateCredentialInstruction, getCreateSatiCredentialInstruction, getCreateSatiSchemaInstruction, getCreateSchemaInstruction, getDeployedNetworks, getInitializeDiscriminatorBytes, getInitializeInstruction, getInitializeInstructionAsync, getInitializeInstructionDataCodec, getInitializeInstructionDataDecoder, getInitializeInstructionDataEncoder, getMetadataEntryCodec, getMetadataEntryDecoder, getMetadataEntryEncoder, getRegisterAgentDiscriminatorBytes, getRegisterAgentInstruction, getRegisterAgentInstructionAsync, getRegisterAgentInstructionDataCodec, getRegisterAgentInstructionDataDecoder, getRegisterAgentInstructionDataEncoder, getRegistryAuthorityUpdatedCodec, getRegistryAuthorityUpdatedDecoder, getRegistryAuthorityUpdatedEncoder, getRegistryConfigCodec, getRegistryConfigDecoder, getRegistryConfigDiscriminatorBytes, getRegistryConfigEncoder, getRegistryConfigSize, getRegistryInitializedCodec, getRegistryInitializedDecoder, getRegistryInitializedEncoder, getSatiRegistryErrorMessage, getUpdateRegistryAuthorityDiscriminatorBytes, getUpdateRegistryAuthorityInstruction, getUpdateRegistryAuthorityInstructionAsync, getUpdateRegistryAuthorityInstructionDataCodec, getUpdateRegistryAuthorityInstructionDataDecoder, getUpdateRegistryAuthorityInstructionDataEncoder, hasDeployedConfig, identifySatiRegistryAccount, identifySatiRegistryInstruction, isSatiRegistryError, loadDeployedConfig, parseInitializeInstruction, parseRegisterAgentInstruction, parseUpdateRegistryAuthorityInstruction, serializeAttestationData, serializeCertificationData, serializeFeedbackAuthData, serializeFeedbackData, serializeFeedbackResponseData, serializeValidationRequestData, serializeValidationResponseData };