java.lang.Object
- org.hyperledger.aries.BaseClient
- - org.hyperledger.aries.AriesClient

```
public class AriesClient
extends BaseClient
```
ACA-PY Rest Client: Sends requests against rest API

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class AriesClient.AriesClientBuilder

Field Summary
- Fields inherited from class org.hyperledger.aries.BaseClient
  EMPTY_JSON

Constructor Summary

Constructors
Constructor	Description
`AriesClient(String url, String apiKey, String bearerToken, okhttp3.OkHttpClient client)`	Create a new aries client, supports builder methods like: `AriesClient.builder().build()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`actionMenuClose(@NonNull String connectionId)`	Close the active menu associated with a connection
`void`	`actionMenuFetch(@NonNull String connectionId)`	Fetch the active menu
`void`	`actionMenuPerform(@NonNull String connectionId, @NonNull PerformRequest request)`	Perform an action associated with the active menu
`void`	`actionMenuRequest(@NonNull String connectionId)`	Request the active menu
`void`	`actionMenuSendMenu(@NonNull String connectionId, @NonNull SendMenu request)`	Send an action menu to a connection
`static AriesClient.AriesClientBuilder`	`builder()`
`List<String>`	`connectionIds()`	Query agent-to-agent connections
`List<String>`	`connectionIds(ConnectionFilter filter)`	Query agent-to-agent connections
`Optional<List<ConnectionRecord>>`	`connections()`	Query agent-to-agent connections
`Optional<List<ConnectionRecord>>`	`connections(ConnectionFilter filter)`	Query agent-to-agent connections
`Optional<ConnectionRecord>`	`connectionsAcceptInvitation(@NonNull String connectionId, ConnectionAcceptInvitationFilter filter)`	Accept a stored connection invitation
`Optional<ConnectionRecord>`	`connectionsAcceptRequest(@NonNull String connectionId, ConnectionAcceptRequestFilter filter)`	Accept a stored connection request
`Optional<CreateInvitationResponse>`	`connectionsCreateInvitation(@NonNull CreateInvitationRequest request)`	Create a new connection invitation
`Optional<CreateInvitationResponse>`	`connectionsCreateInvitation(@NonNull CreateInvitationRequest request, CreateInvitationParams params)`	Create a new connection invitation
`Optional<ConnectionStaticResult>`	`connectionsCreateStatic(@NonNull ConnectionStaticRequest request)`	Create a new static connection
`void`	`connectionsEstablishInbound(@NonNull String connectionId, @NonNull String inboundConnectionId)`	Assign another connection as the inbound connection
`Optional<ConnectionRecord>`	`connectionsGetById(@NonNull String connectionId)`	Fetch a single connection record
`Optional<EndpointResult>`	`connectionsGetEndpoints(@NonNull String connectionId)`	Fetch a connection remote endpoint
`Optional<Map<String,String>>`	`connectionsGetMetadata(@NonNull String connectionId)`	Fetch connection metadata
`Optional<String>`	`connectionsGetMetadata(@NonNull String connectionId, @NonNull String key)`	Fetch connection metadata
`Optional<ConnectionRecord>`	`connectionsReceiveInvitation(@NonNull ReceiveInvitationRequest invite, ConnectionReceiveInvitationFilter filter)`	Receive a new connection invitation
`void`	`connectionsRemove(@NonNull String connectionId)`	Remove an existing connection record
`void`	`connectionsSendMessage(@NonNull String connectionId, @NonNull SendMessage msg)`	Send a basic message to a connection
`Optional<PingResponse>`	`connectionsSendPing(@NonNull String connectionId, @NonNull PingRequest comment)`	Send a trust ping to a connection
`Optional<Map<String,String>>`	`connectionsSetMetadata(@NonNull String connectionId, @NonNull ConnectionSetMetaDataRequest request)`	Set connection metadata
`void`	`connectionsStartIntroduction(@NonNull String connectionId, @NonNull ConnectionStartIntroductionFilter filter)`	Start an introduction between two connections
`Optional<Credential>`	`credential(@NonNull String credentialId)`	Fetch a credential from wallet by id
`Optional<CredentialDefinition.CredentialDefinitionResponse>`	`credentialDefinitionsCreate(@NonNull CredentialDefinition.CredentialDefinitionRequest defReq)`	Sends a credential definition to the ledger
`Optional<TxnOrCredentialDefinitionSendResult>`	`credentialDefinitionsCreate(@NonNull CredentialDefinition.CredentialDefinitionRequest defReq, @NonNull EndorserInfoFilter endorserInfoFilter)`	Sends a credential definition to the ledger via an endorser
`Optional<CredentialDefinition.CredentialDefinitionsCreated>`	`credentialDefinitionsCreated(CredentialDefinitionFilter filter)`	Search for matching credential definitions that originated from this agent
`Optional<CredentialDefinitionGetResult>`	`credentialDefinitionsGetById(@NonNull String id)`	Gets a credential definition from the ledger
`Optional<CredentialDefinitionGetResult>`	`credentialDefinitionsWriteRecord(@NonNull String id)`	Writes a credential definition non-secret record to the wallet
`List<String>`	`credentialIds()`	Fetch credentials ids from wallet
`List<String>`	`credentialIds(Predicate<Credential> filter)`	Fetch credentials ids from wallet
`Optional<Object>`	`credentialMimeTypes(@NonNull String credentialId)`	Get attribute MIME types from wallet
`void`	`credentialRemove(@NonNull String credentialId)`	Remove a credential from the wallet by id (credentialId)
`Optional<Credential.CredentialRevokedResult>`	`credentialRevoked(@NonNull String credentialId)`	Query credential revocation status by id
`Optional<Credential.CredentialRevokedResult>`	`credentialRevoked(@NonNull String credentialId, CredentialRevokedFilter filter)`	Query credential revocation status by id
`Optional<List<Credential>>`	`credentials()`	Fetch credentials from wallet
`Optional<List<Credential>>`	`credentials(Predicate<Credential> filter)`	Fetch credentials from wallet - filter results in memory
`Optional<List<Credential>>`	`credentials(ListCredentialsFilter filter)`	Fetch credentials from wallet
`Optional<VCRecordList>`	`credentialsW3C(@NonNull W3CCredentialsListRequest w3cReq)`	Fetch W3C credentials from wallet
`Optional<VCRecord>`	`credentialW3C(@NonNull String credentialId)`	Fetch W3C credential from wallet by id
`void`	`credentialW3CRemove(@NonNull String credentialId)`	Remove W3C credential from wallet by id
`Optional<ConnectionRecord>`	`didExchangeAcceptInvitation(@NonNull String connectionId, DidExchangeAcceptInvitationFilter filter)`	Accept a stored connection invitation
`Optional<ConnectionRecord>`	`didExchangeAcceptRequest(@NonNull String connectionId, DidExchangeAcceptRequestFilter filter)`	Accept a stored connection request
`Optional<ConnectionRecord>`	`didExchangeCreateRequest(@NonNull DidExchangeCreateRequestFilter filter)`	Create request against public DID's implicit invitation
`Optional<ConnectionRecord>`	`didExchangeReceiveRequest(@NonNull DIDXRequest request, DidExchangeReceiveRequestFilter filter)`	Receive request against public DID's implicit invitation
`Optional<V10DiscoveryRecord>`	`discoverFeaturesQuery(DiscoverFeaturesQueryFilter filter)`	Query supported features
`Optional<V10DiscoveryExchangeListResult>`	`discoverFeaturesRecords(DiscoverFeaturesRecordsFilter filter)`	Discover Features records
`Optional<V20DiscoveryRecord>`	`discoverFeaturesV2Queries(DiscoverFeaturesV2QueriesFilter filter)`	Query supported v2 features
`Optional<V20DiscoveryExchangeListResult>`	`discoverFeaturesV2Records(DiscoverFeaturesRecordsFilter filter)`	Discover features v2 records
`Optional<List<EndorseTransactionRecord>>`	`endorseGetTransactions()`	Query transactions
`Optional<EndorseTransactionRecord>`	`endorseTransactionCancel(@NonNull String trxId)`	For Author to cancel a particular transaction request
`Optional<EndorseTransactionRecord>`	`endorseTransactionCreateRequest(@NonNull Instant expiresTime, @NonNull EndorseCreateRequestFilter filter)`	For author to send a transaction request
`Optional<EndorseTransactionRecord>`	`endorseTransactionEndorse(@NonNull String trxId)`	For Endorser to endorse a particular transaction record
`Optional<EndorseTransactionRecord>`	`endorseTransactionEndorse(@NonNull String trxId, String endorserDid)`	For Endorser to endorse a particular transaction record
`Optional<EndorseTransactionRecord>`	`endorseTransactionGetById(@NonNull String trxId)`	Fetch single transaction record
`Optional<EndorseTransactionRecord>`	`endorseTransactionRefuse(@NonNull String trxId)`	For Endorser to refuse a particular transaction record
`Optional<EndorseTransactionRecord>`	`endorseTransactionResend(@NonNull String trxId)`	For Author to resend a particular transaction request
`Optional<EndorserInfo>`	`endorseTransactionSetEndorserInfo(@NonNull String connectionId, @NonNull SetEndorserInfoFilter filter)`	Set Endorser Info
`Optional<TransactionJobs>`	`endorseTransactionSetEndorserRole(@NonNull String connectionId, @NonNull SetEndorserRoleFilter filter)`	Set transaction jobs
`Optional<EndorseTransactionRecord>`	`endorseTransactionWrite(@NonNull String trxId)`	For Author / Endorser to write an endorsed transaction to the ledger
`Optional<V1CredentialExchange>`	`issueCredentialCreate(@NonNull V1CredentialCreate request)`	Send holder a credential, automating the entire flow The internal credential record will be created without the credential being sent to any connection.
`Optional<V1CredentialExchange>`	`issueCredentialCreateOffer(@NonNull V1CredentialFreeOfferRequest request)`	Create a credential offer, independent of any proposal or connection Unlike with `send-offer`, this credential exchange is not tied to a specific connection.
`Optional<List<V1CredentialExchange>>`	`issueCredentialRecords(IssueCredentialRecordsFilter filter)`	Fetch all credential exchange records
`Optional<V1CredentialExchange>`	`issueCredentialRecordsGetById(@NonNull String credentialExchangeId)`	Fetch a single credential exchange record
`Optional<V1CredentialExchange>`	`issueCredentialRecordsIssue(@NonNull String credentialExchangeId, V1CredentialIssueRequest request)`	Send holder a credential
`void`	`issueCredentialRecordsProblemReport(@NonNull String credentialExchangeId, @NonNull V10CredentialProblemReportRequest request)`	Send a problem report for a credential exchange
`void`	`issueCredentialRecordsRemove(@NonNull String credentialExchangeId)`	Remove an existing credential exchange record
`Optional<V1CredentialExchange>`	`issueCredentialRecordsSendOffer(@NonNull String credentialExchangeId, @NonNull V10CredentialBoundOfferRequest offerRequest)`	Send holder a credential offer in reference to a proposal with a preview
`Optional<V1CredentialExchange>`	`issueCredentialRecordsSendRequest(@NonNull String credentialExchangeId)`	Send issuer a credential request
`Optional<V1CredentialExchange>`	`issueCredentialRecordsStore(@NonNull String credentialExchangeId, V1CredentialStoreRequest request)`	Store a received credential
`Optional<V1CredentialExchange>`	`issueCredentialSend(@NonNull V1CredentialProposalRequest request)`	Send holder a credential, automating the entire flow
`Optional<V1CredentialExchange>`	`issueCredentialSendOffer(@NonNull V1CredentialOfferRequest request)`	Send holder a credential offer, independent of any proposal
`Optional<V1CredentialExchange>`	`issueCredentialSendProposal(@NonNull V1CredentialProposalRequest request)`	Send issuer a credential proposal
`Optional<V20CredExRecord>`	`issueCredentialV2Create(@NonNull V20IssueCredSchemaCore request)`	Create credential from attribute values
`Optional<V20CredExRecord>`	`issueCredentialV2CreateOffer(@NonNull V20CredOfferConnFreeRequest request)`	Create a credential offer, independent of any proposal or connection
`Optional<List<V20CredExRecordDetail>>`	`issueCredentialV2Records(V2IssueCredentialRecordsFilter filter)`	Fetch all credential exchange records
`Optional<V20CredExRecordDetail>`	`issueCredentialV2RecordsGetById(@NonNull String credentialExchangeId)`	Fetch a single credential exchange record
`Optional<V20CredExRecordDetail>`	`issueCredentialV2RecordsIssue(@NonNull String credentialExchangeId, V20CredIssueRequest request)`	Send holder a credential
`void`	`issueCredentialV2RecordsProblemReport(@NonNull String credentialExchangeId, @NonNull V20CredIssueProblemReportRequest request)`	Send a problem report for a credential exchange
`void`	`issueCredentialV2RecordsRemove(@NonNull String credentialExchangeId)`	Remove an existing credential exchange record
`Optional<V20CredExRecord>`	`issueCredentialV2RecordsSendOffer(@NonNull String credentialExchangeId, @NonNull V10CredentialBoundOfferRequest offerRequest)`	Send holder a credential offer in reference to a proposal with a preview.
`Optional<V20CredExRecord>`	`issueCredentialV2RecordsSendOffer(@NonNull String credentialExchangeId, @NonNull V20CredBoundOfferRequest offerRequest)`	Send holder a credential offer in reference to a proposal with a preview
`Optional<V20CredExRecord>`	`issueCredentialV2RecordsSendRequest(@NonNull String credentialExchangeId, @NonNull V20CredRequestRequest request)`	Send issuer a credential request
`Optional<V20CredExRecordDetail>`	`issueCredentialV2RecordsStore(@NonNull String credentialExchangeId, V20CredStoreRequest request)`	Store a received credential
`Optional<V20CredExRecord>`	`issueCredentialV2Send(@NonNull V1CredentialProposalRequest request)`	Send holder a credential, automating the entire flow (V1 to V2 wrapper).
`Optional<V20CredExRecord>`	`issueCredentialV2Send(@NonNull V2CredentialExchangeFree request)`	Send holder a credential, automating the entire flow
`Optional<V20CredExRecord>`	`issueCredentialV2SendOffer(@NonNull V20CredOfferRequest request)`	Send holder a credential offer, independent of any proposal
`Optional<V20CredExRecord>`	`issueCredentialV2SendProposal(@NonNull V1CredentialProposalRequest request)`	Send issuer a credential proposal
`Optional<V20CredExRecord>`	`issueCredentialV2SendProposal(@NonNull V2CredentialExchangeFree request)`	Send issuer a credential proposal
`Optional<V20CredExRecord>`	`issueCredentialV2SendRequest(@NonNull V20CredRequestFree request)`	Send issuer a credential request not bound to an existing thread.
`<T> Optional<T>`	`jsonldSign(@NonNull SignRequest signRequest, @NonNull Type t)`	Sign a JSON-LD structure and return it
`Optional<VerifyResponse>`	`jsonldVerify(@NonNull String verkey, @NonNull Object t)`	Verify a JSON-LD structure
`Optional<EndpointResponse>`	`ledgerDidEndpoint(@NonNull String did, DIDEndpointWithType.EndpointTypeEnum type)`	Get the endpoint for a DID from the ledger.
`Optional<DidVerkeyResponse>`	`ledgerDidVerkey(@NonNull String did)`	Get the verkey for a did from the ledger
`Optional<GetNymRoleResponse>`	`ledgerGetNymRole(@NonNull String did)`	Get the role from the NYM registration of a public DID.
`Optional<LedgerConfig>`	`ledgerMultipleConfig()`	Fetch the multiple ledger configuration currently in use
`Optional<WriteLedgerRequest>`	`ledgerMultipleGetWriteLedger()`	Fetch the current write ledger
`Optional<TxnOrRegisterLedgerNymResponse>`	`ledgerRegisterNym(@NonNull RegisterNymFilter filter)`	Send a NYM registration to the ledger
`void`	`ledgerRotatePublicDidKeypair()`	Rotate key pair for public did
`Optional<TAAInfo>`	`ledgerTaa()`	Fetch the current transaction author agreement, if any
`void`	`ledgerTaaAccept(@NonNull TAAAccept taaAccept)`	Accept the transaction author agreement
`void`	`mediationClearDefaultMediator()`	Clear default mediator
`Optional<MediationRecord>`	`mediationDefaultMediator()`	Get default mediator
`Optional<MediationRecord>`	`mediationDefaultMediator(@NonNull UUID mediationId)`	Set default mediator
`Optional<List<RouteRecord>>`	`mediationKeyLists(MediationKeyListsFilter filter)`	Retrieve key lists by connection or role
`Optional<MediationRecord>`	`mediationRequest(@NonNull UUID connectionId, @NonNull MediationCreateRequest request)`	Request mediation from connection
`Optional<List<MediationRecord>>`	`mediationRequests(MediationRequestsFilter filter)`	Query mediation requests, return list of all mediation records
`void`	`mediationRequestsDeleteById(@NonNull UUID mediationId)`	Delete mediation request by id
`Optional<MediationDeny>`	`mediationRequestsDeny(@NonNull UUID mediationId, @NonNull AdminMediationDeny request)`	Deny a stored mediation request
`Optional<MediationRecord>`	`mediationRequestsGetById(@NonNull UUID mediationId)`	Retrieve mediation request record by id
`Optional<MediationGrant>`	`mediationRequestsGrant(@NonNull UUID mediationId)`	Grant received mediation
`Optional<KeylistQuery>`	`mediationSendKeyListQuery(@NonNull UUID mediationId, @NonNull KeylistQueryFilterRequest request, MediationKeyListQueryFilter filter)`	Send key list query to mediator
`Optional<KeylistUpdate>`	`mediationSendKeyListUpdate(@NonNull UUID mediationId, @NonNull KeylistUpdateRequest request)`	Send key list update to mediator
`Optional<WalletRecord>`	`multitenancyWalletCreate(@NonNull CreateWalletRequest request)`	Create sub wallet
`ClientToTenant`	`multitenancyWalletCreateWithClient(@NonNull CreateWalletRequest request)`	Create sub wallet and initialise rest and websocket clients based on this client's configuration.
`Optional<WalletRecord>`	`multitenancyWalletGet(@NonNull String walletId)`	Get a singe sub wallet
`void`	`multitenancyWalletRemove(@NonNull String walletId, @NonNull RemoveWalletRequest request)`	remove a sub wallet
`Optional<List<WalletRecord>>`	`multitenancyWallets(String walletName)`	Query sub wallets
`Optional<CreateWalletTokenResponse>`	`multitenancyWalletToken(@NonNull String walletId, @NonNull CreateWalletTokenRequest request)`	Get auth token for a sub wallet
`Optional<WalletRecord>`	`multitenancyWalletUpdate(@NonNull String walletId, @NonNull UpdateWalletRequest request)`	Update a sub wallet
`Optional<InvitationRecord>`	`outOfBandCreateInvitation(@NonNull InvitationCreateRequest request, CreateInvitationFilter filter)`	Create a new connection invitation
`<T> Optional<ConnectionRecord>`	`outOfBandReceiveInvitation(@NonNull InvitationMessage<T> request, ReceiveInvitationFilter filter)`	Receive a new connection invitation
`Optional<PresentationExchangeRecord>`	`presentProofCreateRequest(@NonNull PresentProofRequest proofRequest)`	Creates a presentation request not bound to any proposal or existing connection
`Optional<List<PresentationExchangeRecord>>`	`presentProofRecords()`	Fetch all present-proof exchange records
`Optional<List<PresentationExchangeRecord>>`	`presentProofRecords(PresentProofRecordsFilter filter)`	Fetch all present-proof exchange records
`Optional<List<PresentationRequestCredentials>>`	`presentProofRecordsCredentials(@NonNull String presentationExchangeId)`	Fetch credentials for a presentation request from wallet
`Optional<List<PresentationRequestCredentials>>`	`presentProofRecordsCredentials(@NonNull String presentationExchangeId, PresentationRequestCredentialsFilter filter)`	Fetch credentials for a presentation request from wallet
`Optional<PresentationExchangeRecord>`	`presentProofRecordsGetById(@NonNull String presentationExchangeId)`	Fetch a single presentation exchange record by ID
`void`	`presentProofRecordsProblemReport(@NonNull String presentationExchangeId, @NonNull V10PresentationProblemReportRequest request)`	Send a problem report for presentation exchange
`void`	`presentProofRecordsRemove(@NonNull String presentationExchangeId)`	Remove an existing presentation exchange record by ID
`Optional<PresentationExchangeRecord>`	`presentProofRecordsSendPresentation(@NonNull String presentationExchangeId, @NonNull PresentationRequest presentationRequest)`	Sends a proof presentation
`Optional<PresentationExchangeRecord>`	`presentProofRecordsSendRequest(@NonNull String presentationExchangeId, @NonNull V10PresentationSendRequestToProposal request)`	Sends presentation request in reference to a proposal
`Optional<PresentationExchangeRecord>`	`presentProofRecordsVerifyPresentation(@NonNull String presentationExchangeId)`	Verify a received presentation
`Optional<PresentationExchangeRecord>`	`presentProofSendProposal(@NonNull PresentProofProposal proofProposal)`	Sends a presentation proposal
`Optional<PresentationExchangeRecord>`	`presentProofSendRequest(@NonNull String proofRequestJson)`	Sends a free presentation request not bound to any proposal.
`Optional<PresentationExchangeRecord>`	`presentProofSendRequest(@NonNull PresentProofRequest proofRequest)`	Sends a free presentation request not bound to any proposal
`Optional<V20PresExRecord>`	`presentProofV2CreateRequest(@NonNull V20PresCreateRequestRequest request)`	Creates a presentation request not bound to any proposal or existing connection
`Optional<List<V20PresExRecord>>`	`presentProofV2Records(V2PresentProofRecordsFilter filter)`	Fetch all present-proof exchange records
`Optional<List<PresentationRequestCredentials>>`	`presentProofV2RecordsCredentials(@NonNull String presentationExchangeId, PresentationRequestCredentialsFilter filter)`	Fetch matching indy credentials for a presentation request from wallet.
`Optional<List<VerifiableCredential.VerifiableCredentialMatch>>`	`presentProofV2RecordsCredentialsDif(@NonNull String presentationExchangeId, PresentationRequestCredentialsFilter filter)`	Fetch matching dif credentials for a presentation request from wallet
`Optional<V20PresExRecord>`	`presentProofV2RecordsGetById(@NonNull String presentationExchangeId)`	Fetch a single presentation exchange record by ID
`void`	`presentProofV2RecordsProblemReport(@NonNull String presentationExchangeId, @NonNull V20PresProblemReportRequest request)`	Send a problem report for presentation exchange
`void`	`presentProofV2RecordsRemove(@NonNull String presentationExchangeId)`	Remove an existing presentation exchange record by ID
`Optional<V20PresExRecord>`	`presentProofV2RecordsSendPresentation(@NonNull String presentationExchangeId, @NonNull V20PresSpecByFormatRequest presentationRequest)`	Sends a proof presentation
`Optional<V20PresExRecord>`	`presentProofV2RecordsSendRequest(@NonNull String presentationExchangeId, @NonNull V20PresentationSendRequestToProposal request)`	Sends presentation request in reference to a proposal
`Optional<V20PresExRecord>`	`presentProofV2RecordsVerifyPresentation(@NonNull String presentationExchangeId)`	Verify a received presentation
`Optional<V20PresExRecord>`	`presentProofV2SendProposal(@NonNull V20PresProposalRequest proofProposal)`	Sends a presentation proposal
`Optional<V20PresExRecord>`	`presentProofV2SendRequest(V20PresSendRequestRequest proofRequest)`	Sends a free presentation request not bound to any proposal
`Optional<DIDDocument>`	`resolverResolveDid(@NonNull String did)`	Retrieve doc for requested did
`Optional<IssuerRevRegRecord>`	`revocationActiveRegistry(@NonNull String credentialDefinitionId)`	Get an active revocation registry by credential definition id
`Optional<PublishRevocations>`	`revocationClearPendingRevocations(@NonNull ClearPendingRevocationsRequest request)`	Clear pending revocations
`Optional<IssuerRevRegRecord>`	`revocationCreateRegistry(@NonNull RevRegCreateRequest revRegRequest)`	Creates a new revocation registry Creating a new registry is a three-step flow: First: create the registry Second: publish the URI of the tails file `revocationRegistryUpdateUri(java.lang.String, org.hyperledger.aries.api.revocation.RevRegUpdateTailsFileUri)` Third: Set the registry to active `revocationActiveRegistry(java.lang.String)`
`Optional<IssuerRevRegRecord>`	`revocationCredentialRecord(RevocationCredentialRecordFilter filter)`	Get credential revocation status
`Optional<TxnOrPublishRevocationsResult>`	`revocationPublishRevocations(@NonNull PublishRevocations request)`	Publish pending revocations to ledger
`Optional<RevRegsCreated>`	`revocationRegistriesCreated(String credentialDefinitionId, RevocationRegistryState state)`	Search for matching revocation registries that current agent created
`Optional<String>`	`revocationRegistryDownloadTailsFile(@NonNull String revRegId)`	Download tails file
`Optional<RevRegWalletUpdatedResult>`	`revocationRegistryFixRevocationEntryState(@NonNull String revRegId, @NonNull FixRevocationEntryStateFilter filter)`	Fix revocation state in wallet and return number of updated entries
`Optional<IssuerRevRegRecord>`	`revocationRegistryGetById(@NonNull String revRegId)`	Gets revocation registry by revocation registry id
`Optional<RevRegIssuedResult>`	`revocationRegistryIssuedCredentials(@NonNull String revRegId)`	Get number of credentials issued against revocation registry
`Optional<CredRevRecordDetailsResult>`	`revocationRegistryIssuedCredentialsDetails(@NonNull String revRegId)`	Get details of credentials issued against revocation registry
`Optional<CredRevIndyRecordsResult>`	`revocationRegistryRevokedCredentialsDetails(@NonNull String revRegId)`	Get details of revoked credentials from ledger
`Optional<TxnOrRevRegResult>`	`revocationRegistrySendDefinition(@NonNull String revRegId, EndorserInfoFilter filter)`	Send revocation registry definition to ledger
`Optional<IssuerRevRegRecord>`	`revocationRegistrySendEntry(@NonNull String revRegId, EndorserInfoFilter filter)`	Send revocation registry entry to ledger
`Optional<IssuerRevRegRecord>`	`revocationRegistrySetState(@NonNull String revRegId, @NonNull RevocationRegistryState state)`	Set revocation registry state manually
`void`	`revocationRegistryTailsFile(@NonNull String revRegId)`	Upload local tails file to server
`Optional<IssuerRevRegRecord>`	`revocationRegistryUpdateUri(@NonNull String revRegId, @NonNull RevRegUpdateTailsFileUri tailsFileUri)`	Update revocation registry with new public URI to the tails file.
`Optional<RevRegCreateResponse.RevocationModuleResponse>`	`revocationRevoke(@NonNull RevokeRequest revokeRequest)`	Revoke an issued credential
`Optional<SchemaSendResponse>`	`schemas(@NonNull SchemaSendRequest schema)`	Sends a schema to the ledger
`Optional<TxnOrSchemaSendResult>`	`schemas(@NonNull SchemaSendRequest schema, @NonNull EndorserInfoFilter endorserInfoFilter)`	Sends a schema to the ledger via an endorser
`Optional<List<String>>`	`schemasCreated(SchemasCreatedFilter filter)`	Loads all schemas from the ledger, which where created by the DID of this cloud agent.
`Optional<SchemaSendResponse.Schema>`	`schemasGetById(@NonNull String schemaId)`	Gets a schema from the ledger
`Optional<SchemaSendResponse.Schema>`	`schemasWriteRecord(@NonNull String schemaId)`	Write schema non-secret record to the ledger
`Optional<AdminConfig>`	`statusConfig()`	Fetch the server configuration
`Optional<AdminStatusLiveliness>`	`statusLive()`	Server liveliness check
`Optional<AdminStatusReadiness>`	`statusReady()`	Server readiness check
`void`	`statusWaitUntilReady(@NonNull Duration timeout)`	Helper that blocks until either a timeout is reached or aca-py returns that it is ready
`Optional<List<DID>>`	`walletDid()`	List wallet DIDs
`Optional<List<DID>>`	`walletDid(ListWalletDidFilter filter)`	List wallet DIDs
`Optional<DID>`	`walletDidCreate(@NonNull WalletDIDCreate didCreate)`	Create local DID
`void`	`walletDidLocalRotateKeypair(@NonNull String did)`	Rotate keypair of a did that was not posted to the ledger
`Optional<DID>`	`walletDidPublic()`	Fetch the current public DID
`Optional<DID>`	`walletDidPublic(@NonNull String did)`	Assign the current public did
`Optional<DID>`	`walletDidPublic(@NonNull String did, @NonNull EndorserInfoFilter endorserInfoFilter)`	Assign the current public did as an endorser
`Optional<DIDEndpoint>`	`walletGetDidEndpoint(@NonNull String did)`	Query DID end point in wallet
`void`	`walletSetDidEndpoint(@NonNull DIDEndpointWithType endpointRequest)`	Update end point in wallet and, if public, on ledger

Methods inherited from class org.hyperledger.aries.BaseClient
checkForError, getWrapped

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- AriesClient
```
public AriesClient(@Nullable
                   String url,
                   @Nullable
                   String apiKey,
                   @Nullable
                   String bearerToken,
                   @Nullable
                   okhttp3.OkHttpClient client)
```
  Create a new aries client, supports builder methods like: AriesClient.builder().build()
  
  Parameters:
  
  url - Optional: The aca-py admin api URL without a path e.g. http(s)://host:[port], defaults to localhost
  
  apiKey - Optional: The admin api key, if security is enabled
  
  bearerToken - Optional: The Bearer token used in the Authorization header when running in multi tenant mode
  
  client - Optional: OkHttpClient if null or not set a default client is created

Method Detail

actionMenuClose
```
public void actionMenuClose(@NonNull
                            @NonNull String connectionId)
                     throws IOException
```
Close the active menu associated with a connection

Parameters:

connectionId - the connection id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

actionMenuFetch
```
public void actionMenuFetch(@NonNull
                            @NonNull String connectionId)
                     throws IOException
```
Fetch the active menu

Parameters:

connectionId - the connection id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

actionMenuPerform

public void actionMenuPerform(@NonNull
                              @NonNull String connectionId,
                              @NonNull
                              @NonNull PerformRequest request)
                       throws IOException

Perform an action associated with the active menu

Parameters:: connectionId - the connection id; request - PerformRequest
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

actionMenuRequest
```
public void actionMenuRequest(@NonNull
                              @NonNull String connectionId)
                       throws IOException
```
Request the active menu

Parameters:

connectionId - the connection id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

actionMenuSendMenu

public void actionMenuSendMenu(@NonNull
                               @NonNull String connectionId,
                               @NonNull
                               @NonNull SendMenu request)
                        throws IOException

Send an action menu to a connection

Parameters:: connectionId - the connection id; request - SendMenu
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsSendMessage

public void connectionsSendMessage(@NonNull
                                   @NonNull String connectionId,
                                   @NonNull
                                   @NonNull SendMessage msg)
                            throws IOException

Send a basic message to a connection

Parameters:: connectionId - the connection id; msg - SendMessage the message
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connections
```
public Optional<List<ConnectionRecord>> connections()
                                             throws IOException
```
Query agent-to-agent connections

Returns:

List of agent-to-agent connections

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connections

public Optional<List<ConnectionRecord>> connections(@Nullable
                                                    ConnectionFilter filter)
                                             throws IOException

Query agent-to-agent connections

Parameters:: filter - ConnectionFilter
Returns:: List of agent-to-agent connections
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionIds
```
public List<String> connectionIds()
                           throws IOException
```
Query agent-to-agent connections

Returns:

only the connection IDs

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionIds
```
public List<String> connectionIds(@Nullable
                                  ConnectionFilter filter)
                           throws IOException
```
Query agent-to-agent connections

Parameters:

filter - ConnectionFilter

Returns:

only the connection IDs based on the filter criteria

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsCreateInvitation

public Optional<CreateInvitationResponse> connectionsCreateInvitation(@NonNull
                                                                      @NonNull CreateInvitationRequest request)
                                                               throws IOException

Create a new connection invitation

Parameters:: request - CreateInvitationRequest
Returns:: CreateInvitationResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: 0.6.0

connectionsCreateInvitation

public Optional<CreateInvitationResponse> connectionsCreateInvitation(@NonNull
                                                                      @NonNull CreateInvitationRequest request,
                                                                      @Nullable
                                                                      CreateInvitationParams params)
                                                               throws IOException

Create a new connection invitation

Parameters:: request - CreateInvitationRequest; params - CreateInvitationParams
Returns:: CreateInvitationResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: 0.6.0

connectionsCreateStatic

public Optional<ConnectionStaticResult> connectionsCreateStatic(@NonNull
                                                                @NonNull ConnectionStaticRequest request)
                                                         throws IOException

Create a new static connection

Parameters:: request - ConnectionStaticRequest
Returns:: ConnectionStaticResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsReceiveInvitation

public Optional<ConnectionRecord> connectionsReceiveInvitation(@NonNull
                                                               @NonNull ReceiveInvitationRequest invite,
                                                               @Nullable
                                                               ConnectionReceiveInvitationFilter filter)
                                                        throws IOException

Receive a new connection invitation

Parameters:: invite - ReceiveInvitationRequest; filter - optional: ConnectionReceiveInvitationFilter
Returns:: ConnectionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsGetById
```
public Optional<ConnectionRecord> connectionsGetById(@NonNull
                                                     @NonNull String connectionId)
                                              throws IOException
```
Fetch a single connection record

Parameters:

connectionId - the connection id

Returns:

ConnectionRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsRemove
```
public void connectionsRemove(@NonNull
                              @NonNull String connectionId)
                       throws IOException
```
Remove an existing connection record

Parameters:

connectionId - the connection id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsAcceptInvitation

public Optional<ConnectionRecord> connectionsAcceptInvitation(@NonNull
                                                              @NonNull String connectionId,
                                                              @Nullable
                                                              ConnectionAcceptInvitationFilter filter)
                                                       throws IOException

Accept a stored connection invitation

Parameters:: connectionId - the connection id; filter - optional ConnectionAcceptInvitationFilter
Returns:: ConnectionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsAcceptRequest

public Optional<ConnectionRecord> connectionsAcceptRequest(@NonNull
                                                           @NonNull String connectionId,
                                                           @Nullable
                                                           ConnectionAcceptRequestFilter filter)
                                                    throws IOException

Accept a stored connection request

Parameters:: connectionId - the connection id; filter - optional ConnectionAcceptRequestFilter
Returns:: ConnectionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsGetEndpoints
```
public Optional<EndpointResult> connectionsGetEndpoints(@NonNull
                                                        @NonNull String connectionId)
                                                 throws IOException
```
Fetch a connection remote endpoint

Parameters:

connectionId - the connection id

Returns:

EndpointResult

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsEstablishInbound

public void connectionsEstablishInbound(@NonNull
                                        @NonNull String connectionId,
                                        @NonNull
                                        @NonNull String inboundConnectionId)
                                 throws IOException

Assign another connection as the inbound connection

Parameters:: connectionId - the connection identifier; inboundConnectionId - inbound connection identifier
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsGetMetadata

public Optional<Map<String,String>> connectionsGetMetadata(@NonNull
                                                                 @NonNull String connectionId)
                                                          throws IOException

Fetch connection metadata

Parameters:: connectionId - the connection id
Returns:: Map metadata map
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsGetMetadata

public Optional<String> connectionsGetMetadata(@NonNull
                                               @NonNull String connectionId,
                                               @NonNull
                                               @NonNull String key)
                                        throws IOException

Fetch connection metadata

Parameters:: connectionId - the connection id; key - Key to retrieve
Returns:: single value string
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

connectionsSetMetadata

public Optional<Map<String,String>> connectionsSetMetadata(@NonNull
                                                                 @NonNull String connectionId,
                                                                 @NonNull
                                                                 @NonNull ConnectionSetMetaDataRequest request)
                                                          throws IOException

Set connection metadata

Parameters:: connectionId - the connection id; request - ConnectionSetMetaDataRequest
Returns:: Map metadata map
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialDefinitionsCreate

public Optional<CredentialDefinition.CredentialDefinitionResponse> credentialDefinitionsCreate(@NonNull
                                                                                               @NonNull CredentialDefinition.CredentialDefinitionRequest defReq)
                                                                                        throws IOException

Sends a credential definition to the ledger

Parameters:: defReq - CredentialDefinition.CredentialDefinitionRequest
Returns:: CredentialDefinition.CredentialDefinitionResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialDefinitionsCreate

public Optional<TxnOrCredentialDefinitionSendResult> credentialDefinitionsCreate(@NonNull
                                                                                 @NonNull CredentialDefinition.CredentialDefinitionRequest defReq,
                                                                                 @NonNull
                                                                                 @NonNull EndorserInfoFilter endorserInfoFilter)
                                                                          throws IOException

Sends a credential definition to the ledger via an endorser

Parameters:: defReq - CredentialDefinition.CredentialDefinitionRequest; endorserInfoFilter - EndorserInfoFilter
Returns:: TxnOrCredentialDefinitionSendResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

credentialDefinitionsCreated

public Optional<CredentialDefinition.CredentialDefinitionsCreated> credentialDefinitionsCreated(@Nullable
                                                                                                CredentialDefinitionFilter filter)
                                                                                         throws IOException

Search for matching credential definitions that originated from this agent

Parameters:: filter - CredentialDefinitionFilter
Returns:: CredentialDefinition.CredentialDefinitionsCreated
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialDefinitionsGetById

public Optional<CredentialDefinitionGetResult> credentialDefinitionsGetById(@NonNull
                                                                            @NonNull String id)
                                                                     throws IOException

Gets a credential definition from the ledger

Parameters:: id - credential definition id
Returns:: CredentialDefinitionGetResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialDefinitionsWriteRecord

public Optional<CredentialDefinitionGetResult> credentialDefinitionsWriteRecord(@NonNull
                                                                                @NonNull String id)
                                                                         throws IOException

Writes a credential definition non-secret record to the wallet

Parameters:: id - credential definition id
Returns:: CredentialDefinitionGetResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialMimeTypes
```
public Optional<Object> credentialMimeTypes(@NonNull
                                            @NonNull String credentialId)
                                     throws IOException
```
Get attribute MIME types from wallet

Parameters:

credentialId - credential id

Returns:

???

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialRevoked

public Optional<Credential.CredentialRevokedResult> credentialRevoked(@NonNull
                                                                      @NonNull String credentialId)
                                                               throws IOException

Query credential revocation status by id

Parameters:: credentialId - credentialId
Returns:: Credential.CredentialRevokedResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialRevoked

public Optional<Credential.CredentialRevokedResult> credentialRevoked(@NonNull
                                                                      @NonNull String credentialId,
                                                                      CredentialRevokedFilter filter)
                                                               throws IOException

Query credential revocation status by id

Parameters:: credentialId - credentialId; filter - optional CredentialRevokedFilter
Returns:: Credential.CredentialRevokedResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialW3C
```
public Optional<VCRecord> credentialW3C(@NonNull
                                        @NonNull String credentialId)
                                 throws IOException
```
Fetch W3C credential from wallet by id

Parameters:

credentialId - credential id

Returns:

VCRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialW3CRemove
```
public void credentialW3CRemove(@NonNull
                                @NonNull String credentialId)
                         throws IOException
```
Remove W3C credential from wallet by id

Parameters:

credentialId - credential id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credential
```
public Optional<Credential> credential(@NonNull
                                       @NonNull String credentialId)
                                throws IOException
```
Fetch a credential from wallet by id

Parameters:

credentialId - credentialId

Returns:

Credential

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialRemove
```
public void credentialRemove(@NonNull
                             @NonNull String credentialId)
                      throws IOException
```
Remove a credential from the wallet by id (credentialId)

Parameters:

credentialId - credentialId

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentials
```
public Optional<List<Credential>> credentials()
                                       throws IOException
```
Fetch credentials from wallet

Returns:

list of credentials Credential

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentials
```
public Optional<List<Credential>> credentials(@Nullable
                                              ListCredentialsFilter filter)
                                       throws IOException
```
Fetch credentials from wallet

Parameters:

filter - ListCredentialsFilter

Returns:

All credentials or credentials that match the filter criteria

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentials
```
public Optional<List<Credential>> credentials(@Nullable
                                              Predicate<Credential> filter)
                                       throws IOException
```
Fetch credentials from wallet - filter results in memory

Parameters:

filter - see CredentialFilter for prepared filters

Returns:

Credentials that match the filter criteria

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialsW3C
```
public Optional<VCRecordList> credentialsW3C(@NonNull
                                             @NonNull W3CCredentialsListRequest w3cReq)
                                      throws IOException
```
Fetch W3C credentials from wallet

Parameters:

w3cReq - W3CCredentialsListRequest

Returns:

VCRecordList

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialIds
```
public List<String> credentialIds()
                           throws IOException
```
Fetch credentials ids from wallet

Returns:

only the credential IDs

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

credentialIds
```
public List<String> credentialIds(@Nullable
                                  Predicate<Credential> filter)
                           throws IOException
```
Fetch credentials ids from wallet

Parameters:

filter - see CredentialFilter for prepared filters

Returns:

only the credential IDs based on the filter criteria

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

didExchangeCreateRequest
```
public Optional<ConnectionRecord> didExchangeCreateRequest(@NonNull
                                                           @NonNull DidExchangeCreateRequestFilter filter)
                                                    throws IOException
```
Create request against public DID's implicit invitation

Parameters:

filter - DidExchangeCreateRequestFilter

Returns:

ConnectionRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

didExchangeReceiveRequest

public Optional<ConnectionRecord> didExchangeReceiveRequest(@NonNull
                                                            @NonNull DIDXRequest request,
                                                            @Nullable
                                                            DidExchangeReceiveRequestFilter filter)
                                                     throws IOException

Receive request against public DID's implicit invitation

Parameters:: request - DIDXRequest; filter - DidExchangeReceiveRequestFilter
Returns:: {link ConnectionRecord}
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

didExchangeAcceptInvitation

public Optional<ConnectionRecord> didExchangeAcceptInvitation(@NonNull
                                                              @NonNull String connectionId,
                                                              @Nullable
                                                              DidExchangeAcceptInvitationFilter filter)
                                                       throws IOException

Accept a stored connection invitation

Parameters:: connectionId - the connection id; filter - DidExchangeAcceptInvitationFilter
Returns:: ConnectionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

didExchangeAcceptRequest

public Optional<ConnectionRecord> didExchangeAcceptRequest(@NonNull
                                                           @NonNull String connectionId,
                                                           @Nullable
                                                           DidExchangeAcceptRequestFilter filter)
                                                    throws IOException

Accept a stored connection request

Parameters:: connectionId - the connection id; filter - DidExchangeAcceptRequestFilter
Returns:: ConnectionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

discoverFeaturesQuery

public Optional<V10DiscoveryRecord> discoverFeaturesQuery(@Nullable
                                                          DiscoverFeaturesQueryFilter filter)
                                                   throws IOException

Query supported features

Parameters:: filter - DiscoverFeaturesQueryFilter
Returns:: V10DiscoveryRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

discoverFeaturesRecords

public Optional<V10DiscoveryExchangeListResult> discoverFeaturesRecords(@Nullable
                                                                        DiscoverFeaturesRecordsFilter filter)
                                                                 throws IOException

Discover Features records

Parameters:: filter - DiscoverFeaturesRecordsFilter
Returns:: V10DiscoveryExchangeListResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

discoverFeaturesV2Queries

public Optional<V20DiscoveryRecord> discoverFeaturesV2Queries(@Nullable
                                                              DiscoverFeaturesV2QueriesFilter filter)
                                                       throws IOException

Query supported v2 features

Parameters:: filter - DiscoverFeaturesV2QueriesFilter
Returns:: V20DiscoveryRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

discoverFeaturesV2Records

public Optional<V20DiscoveryExchangeListResult> discoverFeaturesV2Records(@Nullable
                                                                          DiscoverFeaturesRecordsFilter filter)
                                                                   throws IOException

Discover features v2 records

Parameters:: filter - DiscoverFeaturesRecordsFilter
Returns:: V20DiscoveryExchangeListResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

endorseTransactionResend
```
public Optional<EndorseTransactionRecord> endorseTransactionResend(@NonNull
                                                                   @NonNull String trxId)
                                                            throws IOException
```
For Author to resend a particular transaction request

Parameters:

trxId - transaction id

Returns:

EndorseTransactionRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

endorseGetTransactions
```
public Optional<List<EndorseTransactionRecord>> endorseGetTransactions()
                                                                throws IOException
```
Query transactions

Returns:

list of EndorseTransactionRecord}

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

endorseTransactionCreateRequest

public Optional<EndorseTransactionRecord> endorseTransactionCreateRequest(@NonNull
                                                                          @NonNull Instant expiresTime,
                                                                          @NonNull
                                                                          @NonNull EndorseCreateRequestFilter filter)
                                                                   throws IOException

For author to send a transaction request

Parameters:: expiresTime - when the request should expire; filter - EndorseCreateRequestFilter
Returns:: EndorseTransactionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

endorseTransactionSetEndorserInfo

public Optional<EndorserInfo> endorseTransactionSetEndorserInfo(@NonNull
                                                                @NonNull String connectionId,
                                                                @NonNull
                                                                @NonNull SetEndorserInfoFilter filter)
                                                         throws IOException

Set Endorser Info

Parameters:: connectionId - the connection id; filter - SetEndorserInfoFilter
Returns:: EndorserInfo
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

endorseTransactionSetEndorserRole

public Optional<TransactionJobs> endorseTransactionSetEndorserRole(@NonNull
                                                                   @NonNull String connectionId,
                                                                   @NonNull
                                                                   @NonNull SetEndorserRoleFilter filter)
                                                            throws IOException

Set transaction jobs

Parameters:: connectionId - the connection id; filter - SetEndorserRoleFilter
Returns:: TransactionJobs
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

endorseTransactionGetById

public Optional<EndorseTransactionRecord> endorseTransactionGetById(@NonNull
                                                                    @NonNull String trxId)
                                                             throws IOException

Fetch single transaction record

Parameters:: trxId - the transaction id
Returns:: EndorseTransactionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

endorseTransactionCancel
```
public Optional<EndorseTransactionRecord> endorseTransactionCancel(@NonNull
                                                                   @NonNull String trxId)
                                                            throws IOException
```
For Author to cancel a particular transaction request

Parameters:

trxId - transaction id

Returns:

EndorseTransactionRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

endorseTransactionEndorse
```
public Optional<EndorseTransactionRecord> endorseTransactionEndorse(@NonNull
                                                                    @NonNull String trxId)
                                                             throws IOException
```
For Endorser to endorse a particular transaction record

Parameters:

trxId - transaction id

Returns:

EndorseTransactionRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

endorseTransactionEndorse

public Optional<EndorseTransactionRecord> endorseTransactionEndorse(@NonNull
                                                                    @NonNull String trxId,
                                                                    String endorserDid)
                                                             throws IOException

For Endorser to endorse a particular transaction record

Parameters:: trxId - transaction id; endorserDid - optional endorser DID
Returns:: EndorseTransactionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

endorseTransactionRefuse
```
public Optional<EndorseTransactionRecord> endorseTransactionRefuse(@NonNull
                                                                   @NonNull String trxId)
                                                            throws IOException
```
For Endorser to refuse a particular transaction record

Parameters:

trxId - transaction id

Returns:

EndorseTransactionRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

endorseTransactionWrite
```
public Optional<EndorseTransactionRecord> endorseTransactionWrite(@NonNull
                                                                  @NonNull String trxId)
                                                           throws IOException
```
For Author / Endorser to write an endorsed transaction to the ledger

Parameters:

trxId - transaction id

Returns:

EndorseTransactionRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

connectionsStartIntroduction

public void connectionsStartIntroduction(@NonNull
                                         @NonNull String connectionId,
                                         @NonNull
                                         @NonNull ConnectionStartIntroductionFilter filter)
                                  throws IOException

Start an introduction between two connections

Parameters:: connectionId - connection id; filter - ConnectionStartIntroductionFilter
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialCreate
```
public Optional<V1CredentialExchange> issueCredentialCreate(@NonNull
                                                            @NonNull V1CredentialCreate request)
                                                     throws IOException
```
Send holder a credential, automating the entire flow The internal credential record will be created without the credential being sent to any connection. This can be used in conjunction with the `oob` protocols to bind messages to an out-of-band message.

Parameters:

request - V1CredentialCreate

Returns:

V1CredentialExchange

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialCreateOffer
```
public Optional<V1CredentialExchange> issueCredentialCreateOffer(@NonNull
                                                                 @NonNull V1CredentialFreeOfferRequest request)
                                                          throws IOException
```
Create a credential offer, independent of any proposal or connection Unlike with `send-offer`, this credential exchange is not tied to a specific connection. It must be dispatched out-of-band by the controller.

Parameters:

request - V1CredentialFreeOfferRequest

Returns:

V1CredentialExchange

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecords
```
public Optional<List<V1CredentialExchange>> issueCredentialRecords(IssueCredentialRecordsFilter filter)
                                                            throws IOException
```
Fetch all credential exchange records

Parameters:

filter - IssueCredentialRecordsFilter

Returns:

list of V1CredentialExchange

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecordsGetById

public Optional<V1CredentialExchange> issueCredentialRecordsGetById(@NonNull
                                                                    @NonNull String credentialExchangeId)
                                                             throws IOException

Fetch a single credential exchange record

Parameters:: credentialExchangeId - credential exchange identifier
Returns:: V1CredentialExchange
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecordsRemove
```
public void issueCredentialRecordsRemove(@NonNull
                                         @NonNull String credentialExchangeId)
                                  throws IOException
```
Remove an existing credential exchange record

Parameters:

credentialExchangeId - the credential exchange id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecordsIssue

public Optional<V1CredentialExchange> issueCredentialRecordsIssue(@NonNull
                                                                  @NonNull String credentialExchangeId,
                                                                  @Nullable
                                                                  V1CredentialIssueRequest request)
                                                           throws IOException

Send holder a credential

Parameters:: credentialExchangeId - credential exchange identifier; request - optional V1CredentialIssueRequest
Returns:: V1CredentialExchange
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecordsProblemReport

public void issueCredentialRecordsProblemReport(@NonNull
                                                @NonNull String credentialExchangeId,
                                                @NonNull
                                                @NonNull V10CredentialProblemReportRequest request)
                                         throws IOException

Send a problem report for a credential exchange

Parameters:: credentialExchangeId - credential exchange identifier; request - V10CredentialProblemReportRequest
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecordsSendOffer

public Optional<V1CredentialExchange> issueCredentialRecordsSendOffer(@NonNull
                                                                      @NonNull String credentialExchangeId,
                                                                      @NonNull
                                                                      @NonNull V10CredentialBoundOfferRequest offerRequest)
                                                               throws IOException

Send holder a credential offer in reference to a proposal with a preview

Parameters:: credentialExchangeId - credential exchange identifier; offerRequest - V10CredentialBoundOfferRequest
Returns:: V1CredentialExchange
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecordsSendRequest

public Optional<V1CredentialExchange> issueCredentialRecordsSendRequest(@NonNull
                                                                        @NonNull String credentialExchangeId)
                                                                 throws IOException

Send issuer a credential request

Parameters:: credentialExchangeId - credential exchange identifier
Returns:: V1CredentialExchange
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialRecordsStore

public Optional<V1CredentialExchange> issueCredentialRecordsStore(@NonNull
                                                                  @NonNull String credentialExchangeId,
                                                                  @Nullable
                                                                  V1CredentialStoreRequest request)
                                                           throws IOException

Store a received credential

Parameters:: credentialExchangeId - the credential exchange id; request - V1CredentialStoreRequest
Returns:: V1CredentialExchange
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialSend
```
public Optional<V1CredentialExchange> issueCredentialSend(@NonNull
                                                          @NonNull V1CredentialProposalRequest request)
                                                   throws IOException
```
Send holder a credential, automating the entire flow

Parameters:

request - V1CredentialProposalRequest the credential to be issued

Returns:

V1CredentialExchange

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialSendOffer
```
public Optional<V1CredentialExchange> issueCredentialSendOffer(@NonNull
                                                               @NonNull V1CredentialOfferRequest request)
                                                        throws IOException
```
Send holder a credential offer, independent of any proposal

Parameters:

request - V1CredentialOfferRequest

Returns:

V1CredentialExchange

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialSendProposal

public Optional<V1CredentialExchange> issueCredentialSendProposal(@NonNull
                                                                  @NonNull V1CredentialProposalRequest request)
                                                           throws IOException

Send issuer a credential proposal

Parameters:: request - V1CredentialProposalRequest the requested credential
Returns:: V1CredentialExchange
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2Create

public Optional<V20CredExRecord> issueCredentialV2Create(@NonNull
                                                         @NonNull V20IssueCredSchemaCore request)
                                                  throws IOException

Create credential from attribute values

Parameters:: request - V20IssueCredSchemaCore
Returns:: V20CredExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2CreateOffer
```
public Optional<V20CredExRecord> issueCredentialV2CreateOffer(@NonNull
                                                              @NonNull V20CredOfferConnFreeRequest request)
                                                       throws IOException
```
Create a credential offer, independent of any proposal or connection

Parameters:

request - V20CredOfferConnFreeRequest

Returns:

V20CredExRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2Records
```
public Optional<List<V20CredExRecordDetail>> issueCredentialV2Records(V2IssueCredentialRecordsFilter filter)
                                                               throws IOException
```
Fetch all credential exchange records

Parameters:

filter - V2IssueCredentialRecordsFilter

Returns:

list of V20CredExRecordDetail

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsGetById

public Optional<V20CredExRecordDetail> issueCredentialV2RecordsGetById(@NonNull
                                                                       @NonNull String credentialExchangeId)
                                                                throws IOException

Fetch a single credential exchange record

Parameters:: credentialExchangeId - credential exchange identifier
Returns:: V20CredExRecordDetail
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsRemove
```
public void issueCredentialV2RecordsRemove(@NonNull
                                           @NonNull String credentialExchangeId)
                                    throws IOException
```
Remove an existing credential exchange record

Parameters:

credentialExchangeId - the credential exchange id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsIssue

public Optional<V20CredExRecordDetail> issueCredentialV2RecordsIssue(@NonNull
                                                                     @NonNull String credentialExchangeId,
                                                                     @Nullable
                                                                     V20CredIssueRequest request)
                                                              throws IOException

Send holder a credential

Parameters:: credentialExchangeId - credential exchange identifier; request - optional V20CredIssueRequest
Returns:: V20CredExRecordDetail
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsProblemReport

public void issueCredentialV2RecordsProblemReport(@NonNull
                                                  @NonNull String credentialExchangeId,
                                                  @NonNull
                                                  @NonNull V20CredIssueProblemReportRequest request)
                                           throws IOException

Send a problem report for a credential exchange

Parameters:: credentialExchangeId - credential exchange identifier; request - V20CredIssueProblemReportRequest
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsSendOffer

public Optional<V20CredExRecord> issueCredentialV2RecordsSendOffer(@NonNull
                                                                   @NonNull String credentialExchangeId,
                                                                   @NonNull
                                                                   @NonNull V10CredentialBoundOfferRequest offerRequest)
                                                            throws IOException

Send holder a credential offer in reference to a proposal with a preview. V1 to V2 Wrapper

Parameters:: credentialExchangeId - credential exchange identifier; offerRequest - V10CredentialBoundOfferRequest
Returns:: V20CredExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsSendOffer

public Optional<V20CredExRecord> issueCredentialV2RecordsSendOffer(@NonNull
                                                                   @NonNull String credentialExchangeId,
                                                                   @NonNull
                                                                   @NonNull V20CredBoundOfferRequest offerRequest)
                                                            throws IOException

Send holder a credential offer in reference to a proposal with a preview

Parameters:: credentialExchangeId - credential exchange identifier; offerRequest - V20CredBoundOfferRequest
Returns:: V20CredExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsSendRequest

public Optional<V20CredExRecord> issueCredentialV2RecordsSendRequest(@NonNull
                                                                     @NonNull String credentialExchangeId,
                                                                     @NonNull
                                                                     @NonNull V20CredRequestRequest request)
                                                              throws IOException

Send issuer a credential request

Parameters:: credentialExchangeId - credential exchange identifier; request - V20CredRequestRequest
Returns:: V20CredExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2RecordsStore

public Optional<V20CredExRecordDetail> issueCredentialV2RecordsStore(@NonNull
                                                                     @NonNull String credentialExchangeId,
                                                                     @Nullable
                                                                     V20CredStoreRequest request)
                                                              throws IOException

Store a received credential

Parameters:: credentialExchangeId - the credential exchange id; request - V20CredStoreRequest
Returns:: V20CredExRecordDetail
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2Send
```
public Optional<V20CredExRecord> issueCredentialV2Send(@NonNull
                                                       @NonNull V1CredentialProposalRequest request)
                                                throws IOException
```
Send holder a credential, automating the entire flow (V1 to V2 wrapper).

Parameters:

request - V1CredentialProposalRequest the credential to be issued

Returns:

V20CredExRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2Send
```
public Optional<V20CredExRecord> issueCredentialV2Send(@NonNull
                                                       @NonNull V2CredentialExchangeFree request)
                                                throws IOException
```
Send holder a credential, automating the entire flow

Parameters:

request - V2CredentialExchangeFree the credential to be issued

Returns:

V20CredExRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2SendOffer
```
public Optional<V20CredExRecord> issueCredentialV2SendOffer(@NonNull
                                                            @NonNull V20CredOfferRequest request)
                                                     throws IOException
```
Send holder a credential offer, independent of any proposal

Parameters:

request - V20CredOfferRequest

Returns:

V20CredExRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2SendProposal

public Optional<V20CredExRecord> issueCredentialV2SendProposal(@NonNull
                                                               @NonNull V1CredentialProposalRequest request)
                                                        throws IOException

Send issuer a credential proposal

Parameters:: request - V1CredentialProposalRequest the requested credential
Returns:: V20CredExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2SendProposal

public Optional<V20CredExRecord> issueCredentialV2SendProposal(@NonNull
                                                               @NonNull V2CredentialExchangeFree request)
                                                        throws IOException

Send issuer a credential proposal

Parameters:: request - V2CredentialExchangeFree the requested credential
Returns:: V20CredExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

issueCredentialV2SendRequest
```
public Optional<V20CredExRecord> issueCredentialV2SendRequest(@NonNull
                                                              @NonNull V20CredRequestFree request)
                                                       throws IOException
```
Send issuer a credential request not bound to an existing thread. Indy credential's cannot start at a request

Parameters:

request - V20CredRequestFree the requested credential

Returns:

V20CredExRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

jsonldSign
```
public <T> Optional<T> jsonldSign(@NonNull
                                  @NonNull SignRequest signRequest,
                                  @NonNull
                                  @NonNull Type t)
                           throws IOException
```
Sign a JSON-LD structure and return it

Type Parameters:

T - class type either VerifiableCredential or VerifiablePresentation

Parameters:

signRequest - SignRequest

t - class type either VerifiableCredential or VerifiablePresentation

Returns:

either VerifiableCredential or VerifiablePresentation with LinkedDataProof

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.5.2

jsonldVerify

public Optional<VerifyResponse> jsonldVerify(@NonNull
                                             @NonNull String verkey,
                                             @NonNull
                                             @NonNull Object t)
                                      throws IOException

Verify a JSON-LD structure

Parameters:: verkey - the verkey; t - instance to verify either VerifiableCredential or VerifiablePresentation
Returns:: VerifyResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.5.2

ledgerDidEndpoint

public Optional<EndpointResponse> ledgerDidEndpoint(@NonNull
                                                    @NonNull String did,
                                                    @Nullable
                                                    DIDEndpointWithType.EndpointTypeEnum type)
                                             throws IOException

Get the endpoint for a DID from the ledger.

Parameters:: did - the DID of interest; type - optional, endpoint type of interest (defaults to 'endpoint')
Returns:: EndpointResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

ledgerDidVerkey
```
public Optional<DidVerkeyResponse> ledgerDidVerkey(@NonNull
                                                   @NonNull String did)
                                            throws IOException
```
Get the verkey for a did from the ledger

Parameters:

did - the DID of interest

Returns:

EndpointResponse

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

ledgerGetNymRole
```
public Optional<GetNymRoleResponse> ledgerGetNymRole(@NonNull
                                                     @NonNull String did)
                                              throws IOException
```
Get the role from the NYM registration of a public DID.

Parameters:

did - did of interest

Returns:

GetNymRoleResponse

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

0.7.3

ledgerMultipleConfig
```
public Optional<LedgerConfig> ledgerMultipleConfig()
                                            throws IOException
```
Fetch the multiple ledger configuration currently in use

Returns:

LedgerConfig

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

0.7.3

ledgerMultipleGetWriteLedger
```
public Optional<WriteLedgerRequest> ledgerMultipleGetWriteLedger()
                                                          throws IOException
```
Fetch the current write ledger

Returns:

WriteLedgerRequest

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

0.7.3

ledgerRegisterNym

public Optional<TxnOrRegisterLedgerNymResponse> ledgerRegisterNym(@NonNull
                                                                  @NonNull RegisterNymFilter filter)
                                                           throws IOException

Send a NYM registration to the ledger

Parameters:: filter - RegisterNymFilter
Returns:: TxnOrRegisterLedgerNymResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: 0.7.3

ledgerRotatePublicDidKeypair
```
public void ledgerRotatePublicDidKeypair()
                                  throws IOException
```
Rotate key pair for public did

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

0.7.3

ledgerTaa
```
public Optional<TAAInfo> ledgerTaa()
                            throws IOException
```
Fetch the current transaction author agreement, if any

Returns:

the current transaction author agreement, if any

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

ledgerTaaAccept
```
public void ledgerTaaAccept(@NonNull
                            @NonNull TAAAccept taaAccept)
                     throws IOException
```
Accept the transaction author agreement

Parameters:

taaAccept - TAAAccept

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout. Or AriesException if TAA is not available

mediationDefaultMediator
```
public Optional<MediationRecord> mediationDefaultMediator()
                                                   throws IOException
```
Get default mediator

Returns:

MediationRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationClearDefaultMediator
```
public void mediationClearDefaultMediator()
                                   throws IOException
```
Clear default mediator

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationKeyLists
```
public Optional<List<RouteRecord>> mediationKeyLists(MediationKeyListsFilter filter)
                                              throws IOException
```
Retrieve key lists by connection or role

Parameters:

filter - MediationKeyListsFilter

Returns:

list of RouteRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationSendKeyListQuery

public Optional<KeylistQuery> mediationSendKeyListQuery(@NonNull
                                                        @NonNull UUID mediationId,
                                                        @NonNull
                                                        @NonNull KeylistQueryFilterRequest request,
                                                        MediationKeyListQueryFilter filter)
                                                 throws IOException

Send key list query to mediator

Parameters:: mediationId - mediation record identifier; request - KeylistQueryFilterRequest; filter - optional MediationKeyListQueryFilter
Returns:: KeylistQuery
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationSendKeyListUpdate

public Optional<KeylistUpdate> mediationSendKeyListUpdate(@NonNull
                                                          @NonNull UUID mediationId,
                                                          @NonNull
                                                          @NonNull KeylistUpdateRequest request)
                                                   throws IOException

Send key list update to mediator

Parameters:: mediationId - mediation record identifier; request - KeylistUpdateRequest
Returns:: KeylistUpdate
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationRequest

public Optional<MediationRecord> mediationRequest(@NonNull
                                                  @NonNull UUID connectionId,
                                                  @NonNull
                                                  @NonNull MediationCreateRequest request)
                                           throws IOException

Request mediation from connection

Parameters:: connectionId - connection identifier; request - MediationCreateRequest
Returns:: MediationRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationRequests
```
public Optional<List<MediationRecord>> mediationRequests(MediationRequestsFilter filter)
                                                  throws IOException
```
Query mediation requests, return list of all mediation records

Parameters:

filter - optional MediationRequestsFilter

Returns:

list of MediationRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationRequestsGetById
```
public Optional<MediationRecord> mediationRequestsGetById(@NonNull
                                                          @NonNull UUID mediationId)
                                                   throws IOException
```
Retrieve mediation request record by id

Parameters:

mediationId - mediation record identifier

Returns:

MediationRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationRequestsDeleteById
```
public void mediationRequestsDeleteById(@NonNull
                                        @NonNull UUID mediationId)
                                 throws IOException
```
Delete mediation request by id

Parameters:

mediationId - mediation record identifier

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationRequestsDeny

public Optional<MediationDeny> mediationRequestsDeny(@NonNull
                                                     @NonNull UUID mediationId,
                                                     @NonNull
                                                     @NonNull AdminMediationDeny request)
                                              throws IOException

Deny a stored mediation request

Parameters:: mediationId - mediation record identifier; request - AdminMediationDeny
Returns:: MediationDeny
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationRequestsGrant
```
public Optional<MediationGrant> mediationRequestsGrant(@NonNull
                                                       @NonNull UUID mediationId)
                                                throws IOException
```
Grant received mediation

Parameters:

mediationId - mediation record identifier

Returns:

MediationGrant

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

mediationDefaultMediator

public Optional<MediationRecord> mediationDefaultMediator(@NonNull
                                                          @NonNull UUID mediationId)
                                                   throws IOException

Set default mediator

Parameters:: mediationId - mediation record identifier
Returns:: MediationRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

multitenancyWalletCreate

public Optional<WalletRecord> multitenancyWalletCreate(@NonNull
                                                       @NonNull CreateWalletRequest request)
                                                throws IOException

Create sub wallet

Parameters:: request - CreateWalletRequest
Returns:: WalletRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

multitenancyWalletCreateWithClient
```
public ClientToTenant multitenancyWalletCreateWithClient(@NonNull
                                                         @NonNull CreateWalletRequest request)
                                                  throws IOException
```
Create sub wallet and initialise rest and websocket clients based on this client's configuration.

Parameters:

request - CreateWalletRequest

Returns:

ClientToTenant

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

multitenancyWalletGet
```
public Optional<WalletRecord> multitenancyWalletGet(@NonNull
                                                    @NonNull String walletId)
                                             throws IOException
```
Get a singe sub wallet

Parameters:

walletId - sub wallet identifier

Returns:

WalletRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

multitenancyWalletUpdate

public Optional<WalletRecord> multitenancyWalletUpdate(@NonNull
                                                       @NonNull String walletId,
                                                       @NonNull
                                                       @NonNull UpdateWalletRequest request)
                                                throws IOException

Update a sub wallet

Parameters:: walletId - sub wallet identifier; request - UpdateWalletRequest
Returns:: WalletRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

multitenancyWalletRemove

public void multitenancyWalletRemove(@NonNull
                                     @NonNull String walletId,
                                     @NonNull
                                     @NonNull RemoveWalletRequest request)
                              throws IOException

remove a sub wallet

Parameters:: walletId - sub wallet identifier; request - RemoveWalletRequest
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

multitenancyWalletToken

public Optional<CreateWalletTokenResponse> multitenancyWalletToken(@NonNull
                                                                   @NonNull String walletId,
                                                                   @NonNull
                                                                   @NonNull CreateWalletTokenRequest request)
                                                            throws IOException

Get auth token for a sub wallet

Parameters:: walletId - sub wallet identifier; request - CreateWalletTokenRequest
Returns:: CreateWalletTokenResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

multitenancyWallets
```
public Optional<List<WalletRecord>> multitenancyWallets(String walletName)
                                                 throws IOException
```
Query sub wallets

Parameters:

walletName - optional the wallets name

Returns:

list of WalletRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

outOfBandCreateInvitation

public Optional<InvitationRecord> outOfBandCreateInvitation(@NonNull
                                                            @NonNull InvitationCreateRequest request,
                                                            CreateInvitationFilter filter)
                                                     throws IOException

Create a new connection invitation

Parameters:: request - InvitationCreateRequest; filter - optional CreateInvitationFilter
Returns:: InvitationRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

outOfBandReceiveInvitation

public <T> Optional<ConnectionRecord> outOfBandReceiveInvitation(@NonNull
                                                                 @NonNull InvitationMessage<T> request,
                                                                 ReceiveInvitationFilter filter)
                                                          throws IOException

Receive a new connection invitation

Type Parameters:: T - type of the service object in the invitation message either String or InvitationMessage.InvitationMessageService
Parameters:: request - InvitationMessage; filter - ReceiveInvitationFilter
Returns:: ConnectionRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

presentProofCreateRequest
```
public Optional<PresentationExchangeRecord> presentProofCreateRequest(@NonNull
                                                                      @NonNull PresentProofRequest proofRequest)
                                                               throws IOException
```
Creates a presentation request not bound to any proposal or existing connection

Parameters:

proofRequest - PresentProofRequest

Returns:

PresentationExchangeRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecords
```
public Optional<List<PresentationExchangeRecord>> presentProofRecords()
                                                               throws IOException
```
Fetch all present-proof exchange records

Returns:

list of PresentationExchangeRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecords

public Optional<List<PresentationExchangeRecord>> presentProofRecords(@Nullable
                                                                      PresentProofRecordsFilter filter)
                                                               throws IOException

Fetch all present-proof exchange records

Parameters:: filter - PresentProofRecordsFilter
Returns:: list of PresentationExchangeRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsGetById

public Optional<PresentationExchangeRecord> presentProofRecordsGetById(@NonNull
                                                                       @NonNull String presentationExchangeId)
                                                                throws IOException

Fetch a single presentation exchange record by ID

Parameters:: presentationExchangeId - the presentation exchange id
Returns:: PresentationExchangeRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsRemove
```
public void presentProofRecordsRemove(@NonNull
                                      @NonNull String presentationExchangeId)
                               throws IOException
```
Remove an existing presentation exchange record by ID

Parameters:

presentationExchangeId - the presentation exchange id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsCredentials

public Optional<List<PresentationRequestCredentials>> presentProofRecordsCredentials(@NonNull
                                                                                     @NonNull String presentationExchangeId)
                                                                              throws IOException

Fetch credentials for a presentation request from wallet

Parameters:: presentationExchangeId - the presentation exchange id
Returns:: list of PresentationRequestCredentials
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsCredentials

public Optional<List<PresentationRequestCredentials>> presentProofRecordsCredentials(@NonNull
                                                                                     @NonNull String presentationExchangeId,
                                                                                     @Nullable
                                                                                     PresentationRequestCredentialsFilter filter)
                                                                              throws IOException

Fetch credentials for a presentation request from wallet

Parameters:: presentationExchangeId - the presentation exchange id; filter - PresentationRequestCredentialsFilter
Returns:: list of PresentationRequestCredentials
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsProblemReport

public void presentProofRecordsProblemReport(@NonNull
                                             @NonNull String presentationExchangeId,
                                             @NonNull
                                             @NonNull V10PresentationProblemReportRequest request)
                                      throws IOException

Send a problem report for presentation exchange

Parameters:: presentationExchangeId - presentation exchange identifier; request - V10PresentationProblemReportRequest
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsSendPresentation

public Optional<PresentationExchangeRecord> presentProofRecordsSendPresentation(@NonNull
                                                                                @NonNull String presentationExchangeId,
                                                                                @NonNull
                                                                                @NonNull PresentationRequest presentationRequest)
                                                                         throws IOException

Sends a proof presentation

Parameters:: presentationExchangeId - the presentation exchange id; presentationRequest - PresentationRequest
Returns:: PresentationExchangeRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsSendRequest

public Optional<PresentationExchangeRecord> presentProofRecordsSendRequest(@NonNull
                                                                           @NonNull String presentationExchangeId,
                                                                           @NonNull
                                                                           @NonNull V10PresentationSendRequestToProposal request)
                                                                    throws IOException

Sends presentation request in reference to a proposal

Parameters:: presentationExchangeId - presentation exchange identifier; request - V10PresentationSendRequestToProposal
Returns:: PresentationExchangeRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofRecordsVerifyPresentation

public Optional<PresentationExchangeRecord> presentProofRecordsVerifyPresentation(@NonNull
                                                                                  @NonNull String presentationExchangeId)
                                                                           throws IOException

Verify a received presentation

Parameters:: presentationExchangeId - presentation exchange identifier
Returns:: PresentationExchangeRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofSendProposal

public Optional<PresentationExchangeRecord> presentProofSendProposal(@NonNull
                                                                     @NonNull PresentProofProposal proofProposal)
                                                              throws IOException

Sends a presentation proposal

Parameters:: proofProposal - PresentProofProposal
Returns:: PresentationExchangeRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofSendRequest

public Optional<PresentationExchangeRecord> presentProofSendRequest(@NonNull
                                                                    @NonNull PresentProofRequest proofRequest)
                                                             throws IOException

Sends a free presentation request not bound to any proposal

Parameters:: proofRequest - PresentProofRequest
Returns:: PresentationExchangeRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofSendRequest
```
public Optional<PresentationExchangeRecord> presentProofSendRequest(@NonNull
                                                                    @NonNull String proofRequestJson)
                                                             throws IOException
```
Sends a free presentation request not bound to any proposal. Use this method if you want to have full control over the proof request.

Parameters:

proofRequestJson - json string

Returns:

PresentationExchangeRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2CreateRequest
```
public Optional<V20PresExRecord> presentProofV2CreateRequest(@NonNull
                                                             @NonNull V20PresCreateRequestRequest request)
                                                      throws IOException
```
Creates a presentation request not bound to any proposal or existing connection

Parameters:

request - V20PresCreateRequestRequest

Returns:

V20PresExRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2Records

public Optional<List<V20PresExRecord>> presentProofV2Records(@Nullable
                                                             V2PresentProofRecordsFilter filter)
                                                      throws IOException

Fetch all present-proof exchange records

Parameters:: filter - V2PresentProofRecordsFilter
Returns:: list of V20PresExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsGetById
```
public Optional<V20PresExRecord> presentProofV2RecordsGetById(@NonNull
                                                              @NonNull String presentationExchangeId)
                                                       throws IOException
```
Fetch a single presentation exchange record by ID

Parameters:

presentationExchangeId - the presentation exchange id

Returns:

V20PresExRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsRemove
```
public void presentProofV2RecordsRemove(@NonNull
                                        @NonNull String presentationExchangeId)
                                 throws IOException
```
Remove an existing presentation exchange record by ID

Parameters:

presentationExchangeId - the presentation exchange id

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsCredentials

public Optional<List<PresentationRequestCredentials>> presentProofV2RecordsCredentials(@NonNull
                                                                                       @NonNull String presentationExchangeId,
                                                                                       @Nullable
                                                                                       PresentationRequestCredentialsFilter filter)
                                                                                throws IOException

Fetch matching indy credentials for a presentation request from wallet.

Parameters:: presentationExchangeId - the presentation exchange id; filter - PresentationRequestCredentialsFilter
Returns:: list of PresentationRequestCredentials
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsCredentialsDif

public Optional<List<VerifiableCredential.VerifiableCredentialMatch>> presentProofV2RecordsCredentialsDif(@NonNull
                                                                                                          @NonNull String presentationExchangeId,
                                                                                                          @Nullable
                                                                                                          PresentationRequestCredentialsFilter filter)
                                                                                                   throws IOException

Fetch matching dif credentials for a presentation request from wallet

Parameters:: presentationExchangeId - the presentation exchange id; filter - PresentationRequestCredentialsFilter
Returns:: list of VerifiableCredential.VerifiableCredentialMatch
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsProblemReport

public void presentProofV2RecordsProblemReport(@NonNull
                                               @NonNull String presentationExchangeId,
                                               @NonNull
                                               @NonNull V20PresProblemReportRequest request)
                                        throws IOException

Send a problem report for presentation exchange

Parameters:: presentationExchangeId - presentation exchange identifier; request - V20PresProblemReportRequest
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsSendPresentation

public Optional<V20PresExRecord> presentProofV2RecordsSendPresentation(@NonNull
                                                                       @NonNull String presentationExchangeId,
                                                                       @NonNull
                                                                       @NonNull V20PresSpecByFormatRequest presentationRequest)
                                                                throws IOException

Sends a proof presentation

Parameters:: presentationExchangeId - the presentation exchange id; presentationRequest - V20PresSpecByFormatRequest
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsSendRequest

public Optional<V20PresExRecord> presentProofV2RecordsSendRequest(@NonNull
                                                                  @NonNull String presentationExchangeId,
                                                                  @NonNull
                                                                  @NonNull V20PresentationSendRequestToProposal request)
                                                           throws IOException

Sends presentation request in reference to a proposal

Parameters:: presentationExchangeId - presentation exchange identifier; request - V20PresentationSendRequestToProposal
Returns:: V20PresExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2RecordsVerifyPresentation

public Optional<V20PresExRecord> presentProofV2RecordsVerifyPresentation(@NonNull
                                                                         @NonNull String presentationExchangeId)
                                                                  throws IOException

Verify a received presentation

Parameters:: presentationExchangeId - presentation exchange identifier
Returns:: V20PresExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2SendProposal

public Optional<V20PresExRecord> presentProofV2SendProposal(@NonNull
                                                            @NonNull V20PresProposalRequest proofProposal)
                                                     throws IOException

Sends a presentation proposal

Parameters:: proofProposal - V20PresProposalRequest
Returns:: V20PresExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

presentProofV2SendRequest

public Optional<V20PresExRecord> presentProofV2SendRequest(@NonNull
                                                           V20PresSendRequestRequest proofRequest)
                                                    throws IOException

Sends a free presentation request not bound to any proposal

Parameters:: proofRequest - V20PresSendRequestRequest
Returns:: V20PresExRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

resolverResolveDid
```
public Optional<DIDDocument> resolverResolveDid(@NonNull
                                                @NonNull String did)
                                         throws IOException
```
Retrieve doc for requested did

Parameters:

did - the did

Returns:

DIDDocument

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

revocationActiveRegistry
```
public Optional<IssuerRevRegRecord> revocationActiveRegistry(@NonNull
                                                             @NonNull String credentialDefinitionId)
                                                      throws IOException
```
Get an active revocation registry by credential definition id

Parameters:

credentialDefinitionId - the credential definition id

Returns:

IssuerRevRegRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationClearPendingRevocations
```
public Optional<PublishRevocations> revocationClearPendingRevocations(@NonNull
                                                                      @NonNull ClearPendingRevocationsRequest request)
                                                               throws IOException
```
Clear pending revocations

Parameters:

request - ClearPendingRevocationsRequest Credential revocation ids by revocation registry id: omit for all, specify null or empty list for all pending per revocation registry

Returns:

PublishRevocations

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationCreateRegistry
```
public Optional<IssuerRevRegRecord> revocationCreateRegistry(@NonNull
                                                             @NonNull RevRegCreateRequest revRegRequest)
                                                      throws IOException
```
Creates a new revocation registry Creating a new registry is a three-step flow: First: create the registry Second: publish the URI of the tails file revocationRegistryUpdateUri(java.lang.String, org.hyperledger.aries.api.revocation.RevRegUpdateTailsFileUri) Third: Set the registry to active revocationActiveRegistry(java.lang.String)

Parameters:

revRegRequest - RevRegCreateRequest

Returns:

IssuerRevRegRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationCredentialRecord
```
public Optional<IssuerRevRegRecord> revocationCredentialRecord(RevocationCredentialRecordFilter filter)
                                                        throws IOException
```
Get credential revocation status

Parameters:

filter - RevocationCredentialRecordFilter

Returns:

IssuerRevRegRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationPublishRevocations

public Optional<TxnOrPublishRevocationsResult> revocationPublishRevocations(@NonNull
                                                                            @NonNull PublishRevocations request)
                                                                     throws IOException

Publish pending revocations to ledger

Parameters:: request - PublishRevocations
Returns:: PublishRevocations
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistriesCreated

public Optional<RevRegsCreated> revocationRegistriesCreated(@Nullable
                                                            String credentialDefinitionId,
                                                            @Nullable
                                                            RevocationRegistryState state)
                                                     throws IOException

Search for matching revocation registries that current agent created

Parameters:: credentialDefinitionId - the credential definition id; state - RevocationRegistryState
Returns:: RevRegsCreated
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryGetById
```
public Optional<IssuerRevRegRecord> revocationRegistryGetById(@NonNull
                                                              @NonNull String revRegId)
                                                       throws IOException
```
Gets revocation registry by revocation registry id

Parameters:

revRegId - the revocation registry id

Returns:

IssuerRevRegRecord

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryUpdateUri

public Optional<IssuerRevRegRecord> revocationRegistryUpdateUri(@NonNull
                                                                @NonNull String revRegId,
                                                                @NonNull
                                                                @NonNull RevRegUpdateTailsFileUri tailsFileUri)
                                                         throws IOException

Update revocation registry with new public URI to the tails file.

Parameters:: revRegId - the revocation registry id; tailsFileUri - RevRegUpdateTailsFileUri the URI of the tails file
Returns:: IssuerRevRegRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistrySendDefinition

public Optional<TxnOrRevRegResult> revocationRegistrySendDefinition(@NonNull
                                                                    @NonNull String revRegId,
                                                                    EndorserInfoFilter filter)
                                                             throws IOException

Send revocation registry definition to ledger

Parameters:: revRegId - revocation registry identifier; filter - EndorserInfoFilter
Returns:: TxnOrRevRegResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistrySendEntry

public Optional<IssuerRevRegRecord> revocationRegistrySendEntry(@NonNull
                                                                @NonNull String revRegId,
                                                                EndorserInfoFilter filter)
                                                         throws IOException

Send revocation registry entry to ledger

Parameters:: revRegId - revocation registry identifier; filter - EndorserInfoFilter
Returns:: IssuerRevRegRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryFixRevocationEntryState

public Optional<RevRegWalletUpdatedResult> revocationRegistryFixRevocationEntryState(@NonNull
                                                                                     @NonNull String revRegId,
                                                                                     @NonNull
                                                                                     @NonNull FixRevocationEntryStateFilter filter)
                                                                              throws IOException

Fix revocation state in wallet and return number of updated entries

Parameters:: revRegId - revocation registry identifier; filter - FixRevocationEntryStateFilter
Returns:: RevRegWalletUpdatedResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryIssuedCredentials
```
public Optional<RevRegIssuedResult> revocationRegistryIssuedCredentials(@NonNull
                                                                        @NonNull String revRegId)
                                                                 throws IOException
```
Get number of credentials issued against revocation registry

Parameters:

revRegId - revocation registry identifier

Returns:

RevRegIssuedResult

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryIssuedCredentialsDetails

public Optional<CredRevRecordDetailsResult> revocationRegistryIssuedCredentialsDetails(@NonNull
                                                                                       @NonNull String revRegId)
                                                                                throws IOException

Get details of credentials issued against revocation registry

Parameters:: revRegId - revocation registry identifier
Returns:: CredRevRecordDetailsResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryRevokedCredentialsDetails

public Optional<CredRevIndyRecordsResult> revocationRegistryRevokedCredentialsDetails(@NonNull
                                                                                      @NonNull String revRegId)
                                                                               throws IOException

Get details of revoked credentials from ledger

Parameters:: revRegId - revocation registry identifier
Returns:: CredRevIndyRecordsResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistrySetState

public Optional<IssuerRevRegRecord> revocationRegistrySetState(@NonNull
                                                               @NonNull String revRegId,
                                                               @NonNull
                                                               @NonNull RevocationRegistryState state)
                                                        throws IOException

Set revocation registry state manually

Parameters:: revRegId - revocation registry identifier; state - RevocationRegistryState
Returns:: IssuerRevRegRecord
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryTailsFile
```
public void revocationRegistryTailsFile(@NonNull
                                        @NonNull String revRegId)
                                 throws IOException
```
Upload local tails file to server

Parameters:

revRegId - revocation registry identifier

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRegistryDownloadTailsFile
```
public Optional<String> revocationRegistryDownloadTailsFile(@NonNull
                                                            @NonNull String revRegId)
                                                     throws IOException
```
Download tails file

Parameters:

revRegId - revocation registry identifier

Returns:

string with binary encoded payload

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

revocationRevoke

public Optional<RevRegCreateResponse.RevocationModuleResponse> revocationRevoke(@NonNull
                                                                                @NonNull RevokeRequest revokeRequest)
                                                                         throws IOException

Revoke an issued credential

Parameters:: revokeRequest - RevokeRequest
Returns:: empty object when success
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

schemas
```
public Optional<SchemaSendResponse> schemas(@NonNull
                                            @NonNull SchemaSendRequest schema)
                                     throws IOException
```
Sends a schema to the ledger

Parameters:

schema - SchemaSendRequest

Returns:

SchemaSendResponse

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

schemas

public Optional<TxnOrSchemaSendResult> schemas(@NonNull
                                               @NonNull SchemaSendRequest schema,
                                               @NonNull
                                               @NonNull EndorserInfoFilter endorserInfoFilter)
                                        throws IOException

Sends a schema to the ledger via an endorser

Parameters:: schema - SchemaSendRequest; endorserInfoFilter - EndorserInfoFilter
Returns:: TxnOrSchemaSendResult
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.
Since:: aca-py 0.7.0

schemasGetById
```
public Optional<SchemaSendResponse.Schema> schemasGetById(@NonNull
                                                          @NonNull String schemaId)
                                                   throws IOException
```
Gets a schema from the ledger

Parameters:

schemaId - the schemas id or sequence number

Returns:

SchemaSendResponse.Schema

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

schemasCreated
```
public Optional<List<String>> schemasCreated(@Nullable
                                             SchemasCreatedFilter filter)
                                      throws IOException
```
Loads all schemas from the ledger, which where created by the DID of this cloud agent.

Parameters:

filter - allows looking only for some schemas

Returns:

List of Schema names

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

schemasWriteRecord
```
public Optional<SchemaSendResponse.Schema> schemasWriteRecord(@NonNull
                                                              @NonNull String schemaId)
                                                       throws IOException
```
Write schema non-secret record to the ledger

Parameters:

schemaId - schema id

Returns:

SchemaSendResponse.Schema

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

0.7.3

statusConfig
```
public Optional<AdminConfig> statusConfig()
                                   throws IOException
```
Fetch the server configuration

Returns:

AdminConfig

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.7.0

statusLive
```
public Optional<AdminStatusLiveliness> statusLive()
                                           throws IOException
```
Server liveliness check

Returns:

AdminStatusLiveliness

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.5.3

statusReady
```
public Optional<AdminStatusReadiness> statusReady()
                                           throws IOException
```
Server readiness check

Returns:

AdminStatusReadiness

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

Since:

aca-py 0.5.3

statusWaitUntilReady
```
public void statusWaitUntilReady(@NonNull
                                 @NonNull Duration timeout)
```
Helper that blocks until either a timeout is reached or aca-py returns that it is ready

Parameters:

timeout - Duration how long to wait for aca-py to be ready until failing

Since:

aca-py 0.5.3

connectionsSendPing

public Optional<PingResponse> connectionsSendPing(@NonNull
                                                  @NonNull String connectionId,
                                                  @NonNull
                                                  @NonNull PingRequest comment)
                                           throws IOException

Send a trust ping to a connection

Parameters:: connectionId - the connection id; comment - comment for the ping message
Returns:: PingResponse
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletDid
```
public Optional<List<DID>> walletDid()
                              throws IOException
```
List wallet DIDs

Returns:

list of DID

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletDid
```
public Optional<List<DID>> walletDid(ListWalletDidFilter filter)
                              throws IOException
```
List wallet DIDs

Parameters:

filter - ListWalletDidFilter

Returns:

list of DID

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletDidCreate
```
public Optional<DID> walletDidCreate(@NonNull
                                     @NonNull WalletDIDCreate didCreate)
                              throws IOException
```
Create local DID

Parameters:

didCreate - DIDCreate

Returns:

DID

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletDidLocalRotateKeypair
```
public void walletDidLocalRotateKeypair(@NonNull
                                        @NonNull String did)
                                 throws IOException
```
Rotate keypair of a did that was not posted to the ledger

Parameters:

did - fully qualified did:indy

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletDidPublic
```
public Optional<DID> walletDidPublic()
                              throws IOException
```
Fetch the current public DID

Returns:

DID

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletDidPublic
```
public Optional<DID> walletDidPublic(@NonNull
                                     @NonNull String did)
                              throws IOException
```
Assign the current public did

Parameters:

did - fully qualified did:indy

Returns:

DID

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletDidPublic

public Optional<DID> walletDidPublic(@NonNull
                                     @NonNull String did,
                                     @NonNull
                                     @NonNull EndorserInfoFilter endorserInfoFilter)
                              throws IOException

Assign the current public did as an endorser

Parameters:: did - fully qualified did:indy; endorserInfoFilter - EndorserInfoFilter
Returns:: DID
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletGetDidEndpoint

public Optional<DIDEndpoint> walletGetDidEndpoint(@NonNull
                                                  @NonNull String did)
                                           throws IOException

Query DID end point in wallet

Parameters:: did - the did
Returns:: DIDEndpoint
Throws:: IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

walletSetDidEndpoint
```
public void walletSetDidEndpoint(@NonNull
                                 @NonNull DIDEndpointWithType endpointRequest)
                          throws IOException
```
Update end point in wallet and, if public, on ledger

Parameters:

endpointRequest - DIDEndpointWithType

Throws:

IOException - if the request could not be executed due to cancellation, a connectivity problem or timeout.

builder

public static AriesClient.AriesClientBuilder builder()

Class AriesClient

Nested Class Summary

Field Summary

Fields inherited from class org.hyperledger.aries.BaseClient

Constructor Summary

Method Summary

Methods inherited from class org.hyperledger.aries.BaseClient

Methods inherited from class java.lang.Object

Constructor Detail

AriesClient

Method Detail

actionMenuClose

actionMenuFetch

actionMenuPerform

actionMenuRequest

actionMenuSendMenu

connectionsSendMessage

connections

connections

connectionIds

connectionIds

connectionsCreateInvitation

connectionsCreateInvitation

connectionsCreateStatic

connectionsReceiveInvitation

connectionsGetById

connectionsRemove

connectionsAcceptInvitation

connectionsAcceptRequest

connectionsGetEndpoints

connectionsEstablishInbound

connectionsGetMetadata

connectionsGetMetadata

connectionsSetMetadata

credentialDefinitionsCreate

credentialDefinitionsCreate

credentialDefinitionsCreated

credentialDefinitionsGetById

credentialDefinitionsWriteRecord

credentialMimeTypes

credentialRevoked

credentialRevoked

credentialW3C

credentialW3CRemove

credential

credentialRemove

credentials

credentials

credentials

credentialsW3C

credentialIds

credentialIds

didExchangeCreateRequest

didExchangeReceiveRequest

didExchangeAcceptInvitation

didExchangeAcceptRequest

discoverFeaturesQuery

discoverFeaturesRecords

discoverFeaturesV2Queries

discoverFeaturesV2Records

endorseTransactionResend

endorseGetTransactions

endorseTransactionCreateRequest

endorseTransactionSetEndorserInfo

endorseTransactionSetEndorserRole

endorseTransactionGetById

endorseTransactionCancel

endorseTransactionEndorse

endorseTransactionEndorse

endorseTransactionRefuse

endorseTransactionWrite

connectionsStartIntroduction

issueCredentialCreate

issueCredentialCreateOffer

issueCredentialRecords

issueCredentialRecordsGetById

issueCredentialRecordsRemove

issueCredentialRecordsIssue

issueCredentialRecordsProblemReport

issueCredentialRecordsSendOffer