Module Contents alltypes
      Module Contents class ANSIProgressObserver
        Module Contents ANSIProgressObserver(smm: StateMachineManager)
        val smm: StateMachineManager
      object ANSIProgressRenderer
        Module Contents var progressTracker: ProgressTracker?
      interface APIServer
        Module Contents abstract fun buildTransaction(type: ContractDefRef, steps: List<TransactionBuildStep>): SerializedBytes<WireTransaction>
        abstract fun commitTransaction(tx: SerializedBytes<WireTransaction>, signatures: List<WithKey>): SecureHash
        abstract fun fetchProtocolsRequiringAttention(query: StatesQuery): Map<StateRef, ProtocolRequiringAttention>
        abstract fun fetchStates(states: List<StateRef>): Map<StateRef, TransactionState<ContractState>?>
        abstract fun fetchTransactions(txs: List<SecureHash>): Map<SecureHash, SignedTransaction?>
        abstract fun generateTransactionSignature(tx: SerializedBytes<WireTransaction>): WithKey
        abstract fun invokeProtocolSync(type: ProtocolRef, args: Map<String, Any?>): Any?
        abstract fun provideProtocolResponse(protocol: ProtocolInstanceRef, choice: SecureHash, args: Map<String, Any?>): Unit
        abstract fun queryStates(query: StatesQuery): List<StateRef>
        abstract fun serverTime(): LocalDateTime
        abstract fun status(): <ERROR CLASS>
      class APIServerImpl : APIServer
        Module Contents APIServerImpl(node: AbstractNode)
        fun buildTransaction(type: ContractDefRef, steps: List<TransactionBuildStep>): SerializedBytes<WireTransaction>
        fun commitTransaction(tx: SerializedBytes<WireTransaction>, signatures: List<WithKey>): SecureHash
        fun fetchProtocolsRequiringAttention(query: StatesQuery): Map<StateRef, ProtocolRequiringAttention>
        fun fetchStates(states: List<StateRef>): Map<StateRef, TransactionState<ContractState>?>
        fun fetchTransactions(txs: List<SecureHash>): Map<SecureHash, SignedTransaction?>
        fun generateTransactionSignature(tx: SerializedBytes<WireTransaction>): WithKey
        fun invokeProtocolSync(type: ProtocolRef, args: Map<String, Any?>): Any?
        val node: AbstractNode
        fun provideProtocolResponse(protocol: ProtocolInstanceRef, choice: SecureHash, args: Map<String, Any?>): Unit
        fun queryStates(query: StatesQuery): List<StateRef>
        fun serverTime(): LocalDateTime
        fun status(): <ERROR CLASS>
      abstract class AbstractConserveAmount<S : FungibleAsset<T>, T : Any> : GroupClause<S, Issued<T>>
        Module Contents AbstractConserveAmount()
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, changeKey: PublicKey, assetStates: List<StateAndRef<S>>, deriveState: (TransactionState<S>, Amount<Issued<T>>, PublicKey) -> TransactionState<S>, generateExitCommand: (Amount<Issued<T>>) -> CommandData): PublicKey
        fun generateSpend(tx: TransactionBuilder, amount: Amount<T>, to: PublicKey, assetsStates: List<StateAndRef<S>>, onlyFromParties: Set<Party>? = null, deriveState: (TransactionState<S>, Amount<Issued<T>>, PublicKey) -> TransactionState<S>, generateMoveCommand: () -> CommandData): List<PublicKey>
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<T>): Set<CommandData>
      abstract class AbstractIssue<in S : ContractState, T : Any> : GroupClause<S, Issued<T>>
        Module Contents AbstractIssue(sum: List<S>.() -> Amount<Issued<T>>, sumOrZero: List<S>.(Issued<T>) -> Amount<Issued<T>>)
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        val sum: List<S>.() -> Amount<Issued<T>>
        val sumOrZero: List<S>.(Issued<T>) -> Amount<Issued<T>>
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<T>): Set<CommandData>
      abstract class AbstractNode : SingletonSerializeAsToken
        Module Contents AbstractNode(dir: Path, configuration: NodeConfiguration, networkMapService: NodeInfo?, advertisedServices: Set<ServiceType>, platformClock: Clock)
        val PRIVATE_KEY_FILE_NAME: String
        val PUBLIC_IDENTITY_FILE_NAME: String
        protected val _servicesThatAcceptUploads: ArrayList<AcceptsFileUpload>
        val advertisedServices: Set<ServiceType>
        lateinit var api: APIServer
        lateinit var checkpointStorage: CheckpointStorage
        val configuration: NodeConfiguration
        protected open fun constructStorageService(attachments: NodeAttachmentService, transactionStorage: TransactionStorage, keypair: KeyPair, identity: Party): StorageServiceImpl
        protected fun createNodeDir(): Unit
        val customServices: ArrayList<Any>
        val dir: Path
        open fun findMyLocation(): PhysicalLocation?
        inline fun <reified T : Any> findService(): <ERROR CLASS>
        protected open fun generateKeyPair(): KeyPair
        lateinit var identity: IdentityService
        var inNodeNetworkMapService: NetworkMapService?
        var inNodeNotaryService: NotaryService?
        val info: NodeInfo
        protected open fun initialiseStorageService(dir: Path): <ERROR CLASS><TxWritableStorageService, CheckpointStorage>
        var isPreviousCheckpointsPresent: Boolean
        lateinit var keyManagement: E2ETestKeyManagementService
        protected abstract val log: <ERROR CLASS>
        protected fun makeAttachmentStorage(dir: Path): NodeAttachmentService
        protected open fun makeIdentityService(): IdentityService
        protected abstract fun makeMessagingService(): MessagingServiceInternal
        protected open fun makeNetworkMapService(): Unit
        protected open fun makeNotaryService(type: ServiceType): Unit
        lateinit var net: MessagingServiceInternal
        lateinit var netMapCache: NetworkMapCache
        val networkMapRegistrationFuture: <ERROR CLASS><Unit>
        var networkMapSeq: Long
        val networkMapService: NodeInfo?
        protected open fun noNetworkMapConfigured(): <ERROR CLASS><Unit>
        val platformClock: Clock
        protected val pluginRegistries: List<CordaPluginRegistry>
        lateinit var protocolLogicFactory: ProtocolLogicRefFactory
        lateinit var scheduler: SchedulerService
        protected abstract val serverThread: AffinityExecutor
        val services: ServiceHubInternal
        val servicesThatAcceptUploads: List<AcceptsFileUpload>
        open fun setup(): AbstractNode
        lateinit var smm: StateMachineManager
        open fun start(): AbstractNode
        protected abstract fun startMessagingService(): Unit
        var started: Boolean
        open fun stop(): Unit
        lateinit var storage: TxWritableStorageService
        lateinit var wallet: WalletService
      abstract class AbstractNodeService : SingletonSerializeAsToken
        Module Contents AbstractNodeService(net: MessagingService, networkMapCache: NetworkMapCache)
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R, crossinline exceptionConsumer: (Message, Exception) -> Unit): Unit
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R): Unit
        val net: MessagingService
        val networkMapCache: NetworkMapCache
      abstract class AbstractStateReplacementProtocol<T>
        Module Contents AbstractStateReplacementProtocol()
        abstract class Acceptor<in T> : ProtocolLogic<Unit>
          Module Contents Acceptor(otherSide: Party, sessionIdForSend: Long, sessionIdForReceive: Long, progressTracker: ProgressTracker = tracker())
          object APPROVING : Step
          object REJECTING : Step
          object VERIFYING : Step
          open fun call(): Unit
          val otherSide: Party
          open val progressTracker: ProgressTracker
          val sessionIdForReceive: Long
          val sessionIdForSend: Long
          fun tracker(): ProgressTracker
        data class Handshake : PartyRequestMessage
          Module Contents Handshake(sessionIdForSend: Long, replyToParty: Party, sessionID: Long)
          val replyToParty: Party
          val sessionID: Long
          val sessionIdForSend: Long
        abstract class Instigator<out S : ContractState, T> : ProtocolLogic<StateAndRef<S>>
          Module Contents Instigator(originalState: StateAndRef<S>, modification: T, progressTracker: ProgressTracker = tracker())
          object NOTARY : Step
          object SIGNING : Step
          open fun call(): StateAndRef<S>
          val modification: T
          val originalState: StateAndRef<S>
          open val progressTracker: ProgressTracker
          fun tracker(): ProgressTracker
        interface Proposal<out T>
          Module Contents abstract val modification: T
          abstract val stateRef: StateRef
          abstract val stx: SignedTransaction
        data class Result
          Module Contents val error: StateReplacementRefused?
          fun noError(sig: WithKey): Result
          val sig: WithKey?
          fun withError(error: StateReplacementRefused): Result
      interface AcceptsFileUpload
        Module Contents abstract val acceptableFileExtensions: List<String>
        abstract val dataTypePrefix: String
        abstract fun upload(data: InputStream): String
      enum class AccrualAdjustment
        Module Contents Adjusted
        Unadjusted
      object Ack : DeserializeAsKotlinObjectDef
      enum class AddOrRemove
        Module Contents ADD
        REMOVE
      interface AffinityExecutor : Executor
        Module Contents class Gate : AffinityExecutor
          Module Contents Gate(alwaysQueue: Boolean = false)
          fun execute(command: Runnable): Unit
          val isOnThread: Boolean
          val taskQueueSize: Int
          fun waitAndRun(): Unit
        val SAME_THREAD: AffinityExecutor
        class ServiceAffinityExecutor : AffinityExecutor, ThreadPoolExecutor
          Module Contents ServiceAffinityExecutor(threadName: String, numThreads: Int)
          protected fun afterExecute(r: Runnable, t: Throwable?): Unit
          val isOnThread: Boolean
          val logger: <ERROR CLASS>
        open fun checkOnThread(): Unit
        open fun executeASAP(runnable: () -> Unit): Unit
        open fun <T> fetchFrom(fetcher: () -> T): T
        open fun flush(): Unit
        abstract val isOnThread: Boolean
      interface AllPossibleRecipients : MessageRecipients
      class AlwaysSucceedContract : Contract
        Module Contents AlwaysSucceedContract(legalContractReference: SecureHash = SecureHash.sha256("Always succeed contract"))
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      data class Amount<T> : Comparable<Amount<T>>
        Module Contents Amount(amount: BigDecimal, currency: T)
        Amount(quantity: Long, token: T)
        fun compareTo(other: Amount<T>): Int
        operator fun div(other: Long): Amount<T>
        operator fun div(other: Int): Amount<T>
        operator fun minus(other: Amount<T>): Amount<T>
        operator fun plus(other: Amount<T>): Amount<T>
        val quantity: Long
        operator fun times(other: Long): Amount<T>
        operator fun times(other: Int): Amount<T>
        fun toString(): String
        val token: T
      data class AppContext
        Module Contents AppContext(attachments: List<SecureHash>)
        val attachments: List<SecureHash>
        val classLoader: ClassLoader
      class ArtemisMessagingClient : ArtemisMessagingComponent, MessagingServiceInternal
        Module Contents ArtemisMessagingClient(directory: Path, config: NodeConfiguration, serverHostPort: <ERROR CLASS>, myHostPort: <ERROR CLASS>, defaultExecutor: Executor = RunOnCallerThread)
        data class Handler : MessageHandlerRegistration
          Module Contents Handler(executor: Executor?, topicSession: TopicSession, callback: (Message, MessageHandlerRegistration) -> Unit)
          val callback: (Message, MessageHandlerRegistration) -> Unit
          val executor: Executor?
          val topicSession: TopicSession
        val SESSION_ID_PROPERTY: String
        val TOPIC_PROPERTY: String
        fun addMessageHandler(topic: String, sessionID: Long, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        fun addMessageHandler(topicSession: TopicSession, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        fun createMessage(topicSession: TopicSession, data: ByteArray): Message
        fun createMessage(topic: String, sessionID: Long, data: ByteArray): Message
        val defaultExecutor: Executor
        val log: <ERROR CLASS>
        fun makeRecipient(hostAndPort: <ERROR CLASS>): SingleMessageRecipient
        fun makeRecipient(hostname: String): <ERROR CLASS>
        val myAddress: SingleMessageRecipient
        val myHostPort: <ERROR CLASS>
        fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        fun send(message: Message, target: MessageRecipients): Unit
        val serverHostPort: <ERROR CLASS>
        fun start(): Unit
        fun stop(): Unit
        fun toHostAndPort(hostname: String): <ERROR CLASS>
      abstract class ArtemisMessagingComponent : SingletonSerializeAsToken
        Module Contents ArtemisMessagingComponent(directory: Path, config: NodeConfiguration)
        protected data class Address : SingleMessageRecipient
          Module Contents Address(hostAndPort: <ERROR CLASS>)
          val hostAndPort: <ERROR CLASS>
        protected enum class ConnectionDirection
          Module Contents INBOUND
          OUTBOUND
        val config: NodeConfiguration
        fun configureWithDevSSLCertificate(): Unit
        val directory: Path
        protected fun tcpTransport(direction: ConnectionDirection, host: String, port: Int): <ERROR CLASS>
      class ArtemisMessagingServer : ArtemisMessagingComponent
        Module Contents ArtemisMessagingServer(directory: Path, config: NodeConfiguration, myHostPort: <ERROR CLASS>)
        val log: <ERROR CLASS>
        val myAddress: SingleMessageRecipient
        val myHostPort: <ERROR CLASS>
        fun start(): Unit
        fun stop(): Unit
      interface Attachment : NamedByHash
        Module Contents open fun extractFile(path: String, outputTo: OutputStream): Unit
        abstract fun open(): InputStream
        open fun openAsJAR(): JarInputStream
      class AttachmentDownloadServlet
        Module Contents AttachmentDownloadServlet()
        fun doGet(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
      class AttachmentResolutionException : Exception
        Module Contents AttachmentResolutionException(attachmentId: SecureHash)
      interface AttachmentStorage
        Module Contents abstract fun importAttachment(jar: InputStream): SecureHash
        abstract fun openAttachment(id: SecureHash): Attachment?
      class AttachmentsClassLoader : SecureClassLoader
        Module Contents AttachmentsClassLoader(attachments: List<Attachment>, parent: ClassLoader = ClassLoader.getSystemClassLoader())
        class OverlappingAttachments : Exception
          Module Contents OverlappingAttachments(path: String)
          val path: String
          fun toString(): String
        protected fun findClass(name: String): Class<*>
        protected fun findResource(name: String): URL?
        fun getResourceAsStream(name: String): InputStream?
      data class AuthenticatedObject<out T : Any>
        Module Contents AuthenticatedObject(signers: List<PublicKey>, signingParties: List<Party>, value: T)
        val signers: List<PublicKey>
        val signingParties: List<Party>
        val value: T
      object AutoOfferProtocol
        Module Contents data class AutoOfferMessage
          Module Contents AutoOfferMessage(otherSide: Party, notary: Party, otherSessionID: Long, dealBeingOffered: DealState)
          val dealBeingOffered: DealState
          val notary: Party
          val otherSessionID: Long
          val otherSide: Party
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Requester : ProtocolLogic<SignedTransaction>
          Module Contents Requester(dealToBeOffered: DealState)
          object ANNOUNCING : Step
          object DEALING : Step
            Module Contents fun childProgressTracker(): ProgressTracker
          object RECEIVED : Step
          fun call(): SignedTransaction
          val dealToBeOffered: DealState
          val progressTracker: ProgressTracker
          protected val topic: String
          fun tracker(): ProgressTracker
        class Service
          Module Contents Service(services: ServiceHubInternal)
          class Callback
            Module Contents Callback(success: (SignedTransaction) -> Unit)
            fun onFailure(t: Throwable?): Unit
            fun onSuccess(st: SignedTransaction?): Unit
            val success: (SignedTransaction) -> Unit
          object DEALING : Step
            Module Contents fun childProgressTracker(): ProgressTracker
          object RECEIVED : Step
          fun tracker(): ProgressTracker
        val TOPIC: String
      data class BilateralNetState<P> : NetState<P>
        Module Contents BilateralNetState(partyKeys: Set<PublicKey>, template: Terms<P>)
        val partyKeys: Set<PublicKey>
        val template: Terms<P>
      interface BilateralNettableState<N : BilateralNettableState<N>>
        Module Contents abstract val bilateralNetState: Any
        abstract fun net(other: N): N
      class BriefLogFormatter : Formatter
        Module Contents BriefLogFormatter()
        fun format(logRecord: LogRecord): String
        fun init(): Unit
        fun initVerbose(vararg loggerNames: String): Unit
        fun loggingOff(vararg names: String): Unit
        fun loggingOff(vararg classes: KClass<*>): Unit
        fun loggingOn(vararg names: String): Unit
        fun loggingOn(vararg classes: KClass<*>): Unit
      open class BusinessCalendar
        Module Contents val TEST_CALENDAR_DATA: <ERROR CLASS>
        class UnknownCalendar : Exception
          Module Contents UnknownCalendar(name: String)
        open fun applyRollConvention(testDate: LocalDate, dateRollConvention: DateRollConvention): LocalDate
        val calendars: <ERROR CLASS>
        fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = getInstance(), dateRollConvention: DateRollConvention = DateRollConvention.Following, noOfAdditionalPeriods: Int = Integer.MAX_VALUE, endDate: LocalDate? = null, periodOffset: Int? = null): List<LocalDate>
        open fun equals(other: Any?): Boolean
        fun getInstance(vararg calname: String): BusinessCalendar
        fun getOffsetDate(startDate: LocalDate, period: Frequency, steps: Int = 1): LocalDate
        open fun hashCode(): Int
        val holidayDates: List<LocalDate>
        open fun isWorkingDay(date: LocalDate): Boolean
        fun moveBusinessDays(date: LocalDate, direction: DateRollDirection, i: Int): LocalDate
        fun parseDateFromString(it: String): LocalDate
      class Cash : OnLedgerAsset<Currency, State>
        Module Contents Cash()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Currency>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Issued<Currency>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, Issued<Currency>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue : AbstractIssue<State, Currency>
            Module Contents Issue()
            val requiredCommands: <ERROR CLASS>
        interface Commands : Commands
          Module Contents data class Exit : Commands, Exit<Currency>
            Module Contents Exit(amount: Amount<Issued<Currency>>)
            val amount: Amount<Issued<Currency>>
          data class Issue : Issue, Commands
            Module Contents Issue(nonce: Long = newSecureRandom().nextLong())
            val nonce: Long
          data class Move : Move, Commands
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
        data class State : FungibleAsset<Currency>
          Module Contents State(deposit: PartyAndReference, amount: Amount<Currency>, owner: PublicKey)
          State(amount: Amount<Issued<Currency>>, owner: PublicKey)
          val amount: Amount<Issued<Currency>>
          val contract: Cash
          val deposit: PartyAndReference
          val exitKeys: <ERROR CLASS>
          val issuanceDef: Issued<Currency>
          fun move(newAmount: Amount<Issued<Currency>>, newOwner: PublicKey): FungibleAsset<Currency>
          val owner: PublicKey
          val participants: <ERROR CLASS>
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        val clauses: <ERROR CLASS>
        val conserveClause: AbstractConserveAmount<State, Currency>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Currency>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<Commands>>
        fun generateExitCommand(amount: Amount<Issued<Currency>>): Exit
        fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Currency>, pennies: Long, owner: PublicKey, notary: Party): Unit
        fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Currency>>, owner: PublicKey, notary: Party): Unit
        fun generateIssueCommand(): Issue
        fun generateMoveCommand(): Move
        val legalContractReference: SecureHash
      class CashBalanceAsMetricsObserver
        Module Contents CashBalanceAsMetricsObserver(serviceHubInternal: ServiceHubInternal)
        val serviceHubInternal: ServiceHubInternal
      data class Checkpoint
        Module Contents Checkpoint(serialisedFiber: SerializedBytes<ProtocolStateMachineImpl<*>>, request: FiberRequest?)
        val request: FiberRequest?
        val serialisedFiber: SerializedBytes<ProtocolStateMachineImpl<*>>
      interface CheckpointStorage
        Module Contents abstract fun addCheckpoint(checkpoint: Checkpoint): Unit
        abstract val checkpoints: Iterable<Checkpoint>
        abstract fun removeCheckpoint(checkpoint: Checkpoint): Unit
      object CityDatabase
        Module Contents operator fun get(name: String): PhysicalLocation?
      interface Clause
        Module Contents abstract val ifMatched: MatchBehaviour
        abstract val ifNotMatched: MatchBehaviour
        abstract val requiredCommands: Set<Class<out CommandData>>
      abstract class ClauseVerifier : Contract
        Module Contents ClauseVerifier()
        abstract val clauses: List<SingleClause>
        abstract fun extractCommands(tx: TransactionForContract): Collection<AuthenticatedObject<CommandData>>
        open fun verify(tx: TransactionForContract): Unit
      sealed class CliParams
        Module Contents class DateChange : CliParams
          Module Contents DateChange(apiAddress: <ERROR CLASS>, dateString: String)
          val apiAddress: <ERROR CLASS>
          val dateString: String
        object Help : CliParams
        class RunNode : CliParams
          Module Contents RunNode(node: IRSDemoNode, dir: Path, networkAddress: <ERROR CLASS>, apiAddress: <ERROR CLASS>, mapAddress: String, identityFile: Path, tradeWithIdentities: List<Path>, uploadRates: Boolean, defaultLegalName: String, autoSetup: Boolean)
          val apiAddress: <ERROR CLASS>
          val autoSetup: Boolean
          val defaultLegalName: String
          val dir: Path
          val identityFile: Path
          val mapAddress: String
          val networkAddress: <ERROR CLASS>
          val node: IRSDemoNode
          val tradeWithIdentities: List<Path>
          val uploadRates: Boolean
        class SetupNode : CliParams
          Module Contents SetupNode(node: IRSDemoNode, dir: Path, defaultLegalName: String)
          val defaultLegalName: String
          val dir: Path
          val node: IRSDemoNode
        class Trade : CliParams
          Module Contents Trade(apiAddress: <ERROR CLASS>, tradeId: String)
          val apiAddress: <ERROR CLASS>
          val tradeId: String
        val defaultBaseDirectory: String
        fun legalName(node: IRSDemoNode): String
        fun parse(options: <ERROR CLASS>): CliParams
      object CliParamsSpec
        Module Contents val apiAddressArg: <ERROR CLASS>
        val baseDirectoryArg: <ERROR CLASS>
        val fakeTradeWithIdentityFile: <ERROR CLASS>
        val help: <ERROR CLASS>
        val networkAddressArg: <ERROR CLASS>
        val networkMapIdentityFile: <ERROR CLASS>
        val networkMapNetAddr: <ERROR CLASS>
        val nonOptions: <ERROR CLASS>
        val parser: <ERROR CLASS>
        val roleArg: <ERROR CLASS>
      data class Command
        Module Contents Command(data: CommandData, key: PublicKey)
        Command(value: CommandData, signers: List<PublicKey>)
        val signers: List<PublicKey>
        fun toString(): String
        val value: CommandData
      interface CommandData
      class CommercialPaper : ClauseVerifier
        Module Contents CommercialPaper()
        interface Clauses
          Module Contents abstract class AbstractGroupClause : GroupClause<State, Issued<Terms>>
            Module Contents AbstractGroupClause()
            open val ifMatched: MatchBehaviour
            open val ifNotMatched: MatchBehaviour
          class Group : GroupClauseVerifier<State, Issued<Terms>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, Issued<Terms>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue : AbstractIssue<State, Terms>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms>): Set<CommandData>
          class Move : AbstractGroupClause
            Module Contents Move()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms>): Set<CommandData>
          class Redeem : AbstractGroupClause
            Module Contents Redeem()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms>): Set<CommandData>
        interface Commands : CommandData
          Module Contents data class Issue : IssueCommand, Commands
            Module Contents Issue(notary: Party, nonce: Long = random63BitValue())
            val nonce: Long
            val notary: Party
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
          data class Redeem : Commands
            Module Contents Redeem(notary: Party)
            val notary: Party
        data class State : OwnableState
          Module Contents State(issuance: PartyAndReference, owner: PublicKey, faceValue: Amount<Issued<Currency>>, maturityDate: Instant)
          val contract: CommercialPaper
          val faceValue: Amount<Issued<Currency>>
          val issuance: PartyAndReference
          val maturityDate: Instant
          val owner: PublicKey
          val participants: List<PublicKey>
          fun toString(): String
          val token: Issued<Terms>
          fun withFaceValue(newFaceValue: Amount<Issued<Currency>>): <ERROR CLASS>
          fun withIssuance(newIssuance: PartyAndReference): <ERROR CLASS>
          fun withMaturityDate(newMaturityDate: Instant): <ERROR CLASS>
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
          fun withOwner(newOwner: PublicKey): <ERROR CLASS>
        data class Terms
          Module Contents Terms(asset: Issued<Currency>, maturityDate: Instant)
          val asset: Issued<Currency>
          val maturityDate: Instant
        val clauses: <ERROR CLASS>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<CommandData>>
        fun generateIssue(issuance: PartyAndReference, faceValue: Amount<Issued<Currency>>, maturityDate: Instant, notary: Party): TransactionBuilder
        fun generateMove(tx: TransactionBuilder, paper: StateAndRef<State>, newOwner: PublicKey): Unit
        fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<State>, wallet: List<StateAndRef<State>>): Unit
        val legalContractReference: SecureHash
      class CommercialPaperLegacy : Contract
        Module Contents CommercialPaperLegacy()
        interface Commands : CommandData
          Module Contents data class Issue : Commands
            Module Contents Issue(notary: Party)
            val notary: Party
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
          data class Redeem : Commands
            Module Contents Redeem(notary: Party)
            val notary: Party
        data class State : OwnableState
          Module Contents State(issuance: PartyAndReference, owner: PublicKey, faceValue: Amount<Issued<Currency>>, maturityDate: Instant)
          val contract: CommercialPaperLegacy
          val faceValue: Amount<Issued<Currency>>
          val issuance: PartyAndReference
          val maturityDate: Instant
          val owner: PublicKey
          val participants: List<PublicKey>
          fun toString(): String
          fun withFaceValue(newFaceValue: Amount<Issued<Currency>>): <ERROR CLASS>
          fun withIssuance(newIssuance: PartyAndReference): <ERROR CLASS>
          fun withMaturityDate(newMaturityDate: Instant): <ERROR CLASS>
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
          fun withOwner(newOwner: PublicKey): <ERROR CLASS>
          fun withoutOwner(): State
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      data class Commodity
        Module Contents Commodity(symbol: String, displayName: String, commodityCode: String = symbol, defaultFractionDigits: Int = 0)
        val commodityCode: String
        val defaultFractionDigits: Int
        val displayName: String
        fun getInstance(symbol: String): Commodity?
        val symbol: String
      class CommodityContract : OnLedgerAsset<Commodity, State>
        Module Contents CommodityContract()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Commodity>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Issued<Commodity>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, Issued<Commodity>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue : AbstractIssue<State, Commodity>
            Module Contents Issue()
            val requiredCommands: <ERROR CLASS>
        interface Commands : Commands
          Module Contents data class Exit : Commands, Exit<Commodity>
            Module Contents Exit(amount: Amount<Issued<Commodity>>)
            val amount: Amount<Issued<Commodity>>
          data class Issue : Issue, Commands
            Module Contents Issue(nonce: Long = newSecureRandom().nextLong())
            val nonce: Long
          data class Move : Move, Commands
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
        data class State : FungibleAsset<Commodity>
          Module Contents State(deposit: PartyAndReference, amount: Amount<Commodity>, owner: PublicKey)
          State(amount: Amount<Issued<Commodity>>, owner: PublicKey)
          val amount: Amount<Issued<Commodity>>
          val contract: CommodityContract
          val deposit: PartyAndReference
          val exitKeys: MutableSet<PublicKey>
          val issuanceDef: Issued<Commodity>
          fun move(newAmount: Amount<Issued<Commodity>>, newOwner: PublicKey): FungibleAsset<Commodity>
          val owner: PublicKey
          val participants: <ERROR CLASS>
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        val clauses: <ERROR CLASS>
        val conserveClause: AbstractConserveAmount<State, Commodity>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Commodity>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<Commands>>
        fun generateExitCommand(amount: Amount<Issued<Commodity>>): Exit
        fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Commodity>, pennies: Long, owner: PublicKey, notary: Party): Unit
        fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Commodity>>, owner: PublicKey, notary: Party): Unit
        fun generateIssueCommand(): Issue
        fun generateMoveCommand(): Move
        val legalContractReference: SecureHash
      class Config
        Module Contents Config(services: ServiceHub)
        val defaultObjectMapper: <ERROR CLASS>
        fun getContext(type: Class<*>): <ERROR CLASS>
        val services: ServiceHub
      class ConfigurationException : Exception
        Module Contents ConfigurationException(message: String)
      interface Contract
        Module Contents abstract val legalContractReference: SecureHash
        abstract fun verify(tx: TransactionForContract): Unit
      data class ContractClassRef : ContractDefRef
        Module Contents ContractClassRef(className: String)
        val className: String
      interface ContractDefRef
      data class ContractLedgerRef : ContractDefRef
        Module Contents ContractLedgerRef(hash: SecureHash)
        val hash: SecureHash
      interface ContractState
        Module Contents abstract val contract: Contract
        abstract val participants: List<PublicKey>
      abstract class CordaPluginRegistry
        Module Contents CordaPluginRegistry()
        open val requiredProtocols: Map<String, Set<String>>
        open val servicePlugins: List<Class<*>>
        open val staticServeDirs: Map<String, String>
        open val webApis: List<Class<*>>
      class CubicSplineInterpolator : Interpolator
        Module Contents CubicSplineInterpolator(xs: DoubleArray, ys: DoubleArray)
        fun create(xs: DoubleArray, ys: DoubleArray): CubicSplineInterpolator
        fun interpolate(x: Double): Double
      class DataUploadServlet
        Module Contents DataUploadServlet()
        fun doPost(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
      object DataVending
        Module Contents class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service : AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
          val NOTIFY_TX_PROTOCOL_TOPIC: String
          data class NotifyTxRequestMessage : PartyRequestMessage
            Module Contents NotifyTxRequestMessage(tx: SignedTransaction, replyToParty: Party, sessionID: Long)
            val replyToParty: Party
            val sessionID: Long
            val tx: SignedTransaction
          data class NotifyTxResponseMessage
            Module Contents NotifyTxResponseMessage(accepted: Boolean)
            val accepted: Boolean
          class TransactionRejectedError : Exception
            Module Contents TransactionRejectedError(msg: String)
          val logger: <ERROR CLASS>
          fun notify(net: MessagingService, myIdentity: Party, recipient: NodeInfo, transaction: SignedTransaction): <ERROR CLASS><Unit>
          val services: ServiceHubInternal
          val storage: StorageService
      enum class DateRollConvention
        Module Contents Actual
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        Following
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        ModifiedFollowing
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        ModifiedPrevious
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        Previous
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        abstract fun direction(): DateRollDirection
        abstract val isModified: Boolean
      enum class DateRollDirection
        Module Contents BACKWARD
        FORWARD
        val value: Long
      enum class DayCountBasisDay
        Module Contents D30
        D30E
        D30F
        D30G
        D30N
        D30P
        D30Z
        DActual
        DActualJ
        DBus_SaoPaulo
        fun toString(): String
      enum class DayCountBasisYear
        Module Contents Y252
        Y360
        Y365
        Y365B
        Y365F
        Y365L
        Y365Q
        Y366
        YActual
        YActualA
        YICMA
        YISMA
        fun toString(): String
      interface DealState : LinearState
        Module Contents abstract fun generateAgreement(notary: Party): TransactionBuilder
        abstract val parties: Array<Party>
        abstract val ref: String
        abstract fun withPublicKey(before: Party, after: PublicKey): DealState
      class DemoClock : MutableClock, SerializeAsToken
        Module Contents DemoClock(delegateClock: Clock = Clock.systemUTC())
        fun getZone(): ZoneId
        fun instant(): Instant
        fun toToken(context: SerializeAsTokenContext): SerializationToken
        fun updateDate(date: LocalDate): Boolean
        fun withZone(zone: ZoneId): Clock
      interface DeserializeAsKotlinObjectDef
      open class DigitalSignature : OpaqueBytes
        Module Contents DigitalSignature(bits: ByteArray)
        class LegallyIdentifiable : WithKey
          Module Contents LegallyIdentifiable(signer: Party, bits: ByteArray, covering: Int)
          val signer: Party
        open class WithKey : DigitalSignature
          Module Contents WithKey(by: PublicKey, bits: ByteArray, covering: Int = 0)
          val by: PublicKey
          fun verifyWithECDSA(content: ByteArray): Unit
          fun verifyWithECDSA(content: OpaqueBytes): Unit
      interface DirectRequestMessage : ServiceRequestMessage
        Module Contents open fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
        abstract val replyToRecipient: SingleMessageRecipient
      class DummyContract : Contract
        Module Contents DummyContract()
        interface Commands : CommandData
          Module Contents class Create : TypeOnlyCommandData, Commands
            Module Contents Create()
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
        data class MultiOwnerState : ContractState, State
          Module Contents MultiOwnerState(magicNumber: Int = 0, owners: List<PublicKey>)
          val contract: DummyContract
          val magicNumber: Int
          val owners: List<PublicKey>
          val participants: List<PublicKey>
        data class SingleOwnerState : OwnableState, State
          Module Contents SingleOwnerState(magicNumber: Int = 0, owner: PublicKey)
          val contract: DummyContract
          val magicNumber: Int
          val owner: PublicKey
          val participants: List<PublicKey>
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        interface State : ContractState
          Module Contents abstract val magicNumber: Int
        fun generateInitial(owner: PartyAndReference, magicNumber: Int, notary: Party): TransactionBuilder
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      class DummyLinearState : LinearState
        Module Contents DummyLinearState(thread: SecureHash = SecureHash.randomSHA256(), contract: Contract = AlwaysSucceedContract(), participants: List<PublicKey> = listOf(), nonce: SecureHash = SecureHash.randomSHA256())
        val contract: Contract
        fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        val nonce: SecureHash
        val participants: List<PublicKey>
        val thread: SecureHash
      class DummyPublicKey : PublicKey, Comparable<PublicKey>
        Module Contents DummyPublicKey(s: String)
        fun compareTo(other: PublicKey): Int
        fun equals(other: Any?): Boolean
        fun getAlgorithm(): String
        fun getEncoded(): <ERROR CLASS>
        fun getFormat(): String
        fun hashCode(): Int
        val s: String
        fun toString(): String
      data class DummyState : ContractState
        Module Contents DummyState(magicNumber: Int = 0)
        val contract: DummyContract
        val magicNumber: Int
        val participants: List<PublicKey>
      class DuplicateOutputLabel : Exception
        Module Contents DuplicateOutputLabel(label: String)
      class E2ETestKeyManagementService : SingletonSerializeAsToken, KeyManagementService
        Module Contents E2ETestKeyManagementService(initialKeys: Set<KeyPair>)
        fun freshKey(): KeyPair
        val keys: Map<PublicKey, PrivateKey>
      object Ed25519PrivateKeySerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<<ERROR CLASS>>): <ERROR CLASS>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit
      object Ed25519PublicKeySerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<<ERROR CLASS>>): <ERROR CLASS>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit
      object Emoji
        Module Contents const val CODE_BAG_OF_CASH: String
        const val CODE_DIAMOND: String
        const val CODE_GREEN_TICK: String
        const val CODE_LEFT_ARROW: String
        const val CODE_NEWSPAPER: String
        const val CODE_PAPERCLIP: String
        const val CODE_RIGHT_ARROW: String
        val bagOfCash: String
        val diamond: String
        val hasEmojiTerminal: <ERROR CLASS>
        val leftArrow: String
        val newspaper: String
        val paperclip: String
        fun renderIfSupported(obj: Any): String
        val rightArrow: String
      sealed class EnforceVerifyOrFail
      open class Event
        Module Contents Event(date: LocalDate)
        val date: LocalDate
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
      object ExitServerProtocol
        Module Contents class Broadcast : ProtocolLogic<Boolean>
          Module Contents Broadcast(exitCode: Int)
          fun call(): Boolean
          val exitCode: Int
          protected val topic: String
        data class ExitMessage
          Module Contents ExitMessage(exitCode: Int)
          val exitCode: Int
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service
          Module Contents Service(services: ServiceHubInternal)
        val TOPIC: String
      data class Expression
        Module Contents Expression(expr: String)
        val expr: String
      object ExpressionDeserializer
        Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): Expression
      object ExpressionSerializer
        Module Contents fun serialize(expr: Expression, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
      class FetchAttachmentsProtocol : FetchDataProtocol<Attachment, ByteArray>
        Module Contents FetchAttachmentsProtocol(requests: Set<SecureHash>, otherSide: Party)
        const val TOPIC: String
        protected fun convert(wire: ByteArray): Attachment
        protected fun load(txid: SecureHash): Attachment?
        protected fun maybeWriteToDisk(downloaded: List<Attachment>): Unit
        protected val topic: String
      abstract class FetchDataProtocol<T : NamedByHash, in W : Any> : ProtocolLogic<Result<T>>
        Module Contents FetchDataProtocol(requests: Set<SecureHash>, otherSide: Party)
        open class BadAnswer : Exception
          Module Contents BadAnswer()
        class DownloadedVsRequestedDataMismatch : BadAnswer
          Module Contents DownloadedVsRequestedDataMismatch(requested: SecureHash, got: SecureHash)
          val got: SecureHash
          val requested: SecureHash
        class HashNotFound : BadAnswer
          Module Contents HashNotFound(requested: SecureHash)
          val requested: SecureHash
        data class Request : PartyRequestMessage
          Module Contents Request(hashes: List<SecureHash>, replyToParty: Party, sessionID: Long)
          val hashes: List<SecureHash>
          val replyToParty: Party
          val sessionID: Long
        data class Result<out T : NamedByHash>
          Module Contents Result(fromDisk: List<T>, downloaded: List<T>)
          val downloaded: List<T>
          val fromDisk: List<T>
        open fun call(): Result<T>
        protected open fun convert(wire: W): T
        protected abstract fun load(txid: SecureHash): T?
        protected open fun maybeWriteToDisk(downloaded: List<T>): Unit
        protected val otherSide: Party
        protected val requests: Set<SecureHash>
      class FetchTransactionsProtocol : FetchDataProtocol<SignedTransaction, SignedTransaction>
        Module Contents FetchTransactionsProtocol(requests: Set<SecureHash>, otherSide: Party)
        const val TOPIC: String
        protected fun load(txid: SecureHash): SignedTransaction?
        protected val topic: String
      class FiberBox<out T>
        Module Contents FiberBox(content: T, lock: Lock = ReentrantLock())
        fun <R> read(body: T.() -> R): R
        fun <R> readWithDeadline(clock: Clock, deadline: Instant, body: T.() -> R): R
        fun <R> write(body: T.() -> R): R
      sealed class FiberRequest
        Module Contents class ExpectingResponse<R : Any> : FiberRequest
          Module Contents ExpectingResponse(topic: String, destination: Party?, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any?, type: Class<R>)
          fun equals(other: Any?): Boolean
          val responseType: Class<R>
          fun toString(): String
        class NotExpectingResponse : FiberRequest
          Module Contents NotExpectingResponse(topic: String, destination: Party, sessionIDForSend: Long, obj: Any?)
        val destination: Party?
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val payload: Any?
        val receiveTopicSession: TopicSession
        val sessionIDForReceive: Long
        val sessionIDForSend: Long
        val stackTraceInCaseOfProblems: StackSnapshot?
        val topic: String
      data class Fix : CommandData
        Module Contents Fix(of: FixOf, value: BigDecimal)
        val of: FixOf
        val value: BigDecimal
      data class FixOf
        Module Contents FixOf(name: String, forDay: LocalDate, ofTenor: Tenor)
        val forDay: LocalDate
        val name: String
        val ofTenor: Tenor
      interface FixableDealState : DealState
        Module Contents abstract fun generateFix(ptx: TransactionBuilder, oldState: StateAndRef<*>, fix: Fix): Unit
        abstract fun nextFixingOf(): FixOf?
      class FixedRate : Rate
        Module Contents FixedRate(ratioUnit: RatioUnit)
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        fun isPositive(): Boolean
      class FixedRatePaymentEvent : RatePaymentEvent
        Module Contents FixedRatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount<Currency>, rate: Rate)
        val CSVHeader: String
        val flow: Amount<Currency>
        fun toString(): String
      object FixingSessionInitiation
        Module Contents class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service
          Module Contents Service(services: ServiceHubInternal)
      open class FloatingRate : Rate
        Module Contents FloatingRate()
      class FloatingRatePaymentEvent : RatePaymentEvent
        Module Contents FloatingRatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, fixingDate: LocalDate, notional: Amount<Currency>, rate: Rate)
        val CSVHeader: String
        fun asCSV(): String
        fun copy(date: LocalDate = this.date, accrualStartDate: LocalDate = this.accrualStartDate, accrualEndDate: LocalDate = this.accrualEndDate, dayCountBasisDay: DayCountBasisDay = this.dayCountBasisDay, dayCountBasisYear: DayCountBasisYear = this.dayCountBasisYear, fixingDate: LocalDate = this.fixingDate, notional: Amount<Currency> = this.notional, rate: Rate = this.rate): FloatingRatePaymentEvent
        fun equals(other: Any?): Boolean
        val fixingDate: LocalDate
        val flow: Amount<Currency>
        fun hashCode(): Int
        fun toString(): String
        fun withNewRate(newRate: Rate): FloatingRatePaymentEvent
      enum class Frequency
        Module Contents Annual
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        BiWeekly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Daily
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Monthly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Quarterly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        SemiAnnual
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Weekly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        val annualCompoundCount: Int
        abstract fun offset(d: LocalDate, n: Long = 1): LocalDate
      class FullNodeConfiguration : NodeConfiguration
        Module Contents FullNodeConfiguration(conf: <ERROR CLASS>)
        val artemisAddress: <ERROR CLASS>
        val basedir: Path
        val clock: Clock
        fun createNode(): Node
        val exportJMXto: String
        val extraAdvertisedServiceIds: String
        val hostNotaryServiceLocally: Boolean
        val keyStorePassword: String
        val mapService: NameServiceConfig
        val messagingServerAddress: <ERROR CLASS>?
        val myLegalName: String
        val nearestCity: String
        val trustStorePassword: String
        val webAddress: <ERROR CLASS>
      interface FungibleAsset<T> : OwnableState
        Module Contents interface Commands : CommandData
          Module Contents interface Exit<T> : Commands
            Module Contents abstract val amount: Amount<Issued<T>>
          interface Issue : IssueCommand, Commands
          interface Move : MoveCommand, Commands
        abstract val amount: Amount<Issued<T>>
        abstract val deposit: PartyAndReference
        abstract val exitKeys: Collection<PublicKey>
        abstract val issuanceDef: Issued<T>
        abstract fun move(newAmount: Amount<Issued<T>>, newOwner: PublicKey): FungibleAsset<T>
        abstract val owner: PublicKey
      interface GroupClause<in S : ContractState, in T : Any> : Clause, GroupVerify<S, T>
      abstract class GroupClauseVerifier<S : ContractState, T : Any> : SingleClause
        Module Contents GroupClauseVerifier()
        abstract val clauses: List<GroupClause<S, T>>
        abstract fun extractGroups(tx: TransactionForContract): List<InOutGroup<S, T>>
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
      interface GroupVerify<in S, in T : Any>
        Module Contents abstract fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: T): Set<CommandData>
      enum class IRSDemoNode
        Module Contents NodeA
        NodeB
        val other: IRSDemoNode
      class IRSDemoPluginRegistry : CordaPluginRegistry
        Module Contents IRSDemoPluginRegistry()
        val requiredProtocols: Map<String, Set<String>>
        val staticServeDirs: Map<String, String>
        val webApis: List<Class<*>>
      enum class IRSDemoRole
        Module Contents Date
        NodeA
        NodeB
        SetupNodeA
        SetupNodeB
        Trade
      class IRSSimulation : Simulation
        Module Contents IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: LatencyCalculator?)
        fun iterate(): MessageTransfer?
        val om: <ERROR CLASS>
        protected fun startMainSimulation(): <ERROR CLASS><Unit>
      interface IdentityService
        Module Contents abstract fun partyFromKey(key: PublicKey): Party?
        abstract fun partyFromName(name: String): Party?
        abstract fun registerIdentity(party: Party): Unit
      class IllegalProtocolLogicException : IllegalArgumentException
        Module Contents IllegalProtocolLogicException(type: Class<*>, msg: String)
      class ImmutableClassSerializer<T : Any>
        Module Contents ImmutableClassSerializer(klass: KClass<T>)
        val constructor: <ERROR CLASS>
        val klass: KClass<T>
        val props: <ERROR CLASS>
        val propsByName: <ERROR CLASS>
        fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<T>): T
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit
      class InMemoryIdentityService : SingletonSerializeAsToken, IdentityService
        Module Contents InMemoryIdentityService()
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
      class InMemoryMessagingNetwork : SingletonSerializeAsToken
        Module Contents InMemoryMessagingNetwork(sendManuallyPumped: Boolean)
        inner class Builder : MessagingServiceBuilder<InMemoryMessaging>
          Module Contents Builder(manuallyPumped: Boolean, id: Handle)
          val id: Handle
          val manuallyPumped: Boolean
          fun start(): <ERROR CLASS><InMemoryMessaging>
        class Handle : SingleMessageRecipient
          Module Contents Handle(id: Int, description: String)
          val description: String
          fun equals(other: Any?): Boolean
          fun hashCode(): Int
          val id: Int
          fun toString(): String
        inner class InMemoryMessaging : SingletonSerializeAsToken, MessagingServiceInternal
          Module Contents InMemoryMessaging(manuallyPumped: Boolean, handle: Handle)
          inner class Handler : MessageHandlerRegistration
            Module Contents Handler(executor: Executor?, topicSession: TopicSession, callback: (Message, MessageHandlerRegistration) -> Unit)
            val callback: (Message, MessageHandlerRegistration) -> Unit
            val executor: Executor?
            val topicSession: TopicSession
          fun addMessageHandler(topic: String, sessionID: Long, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
          fun addMessageHandler(topicSession: TopicSession, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
          fun createMessage(topic: String, sessionID: Long, data: ByteArray): Message
          fun createMessage(topicSession: TopicSession, data: ByteArray): Message
          val myAddress: SingleMessageRecipient
          fun pumpReceive(block: Boolean): MessageTransfer?
          fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
          fun send(message: Message, target: MessageRecipients): Unit
          fun stop(): Unit
        interface LatencyCalculator
          Module Contents abstract fun between(sender: SingleMessageRecipient, receiver: SingleMessageRecipient): Duration
        val MESSAGES_LOG_NAME: String
        data class MessageTransfer
          Module Contents MessageTransfer(sender: InMemoryMessaging, message: Message, recipients: MessageRecipients)
          val message: Message
          val recipients: MessageRecipients
          val sender: InMemoryMessaging
          fun toString(): String
        fun createNode(manuallyPumped: Boolean): <ERROR CLASS><Handle, MessagingServiceBuilder<InMemoryMessaging>>
        fun createNodeWithID(manuallyPumped: Boolean, id: Int, description: String? = null): MessagingServiceBuilder<InMemoryMessaging>
        val endpoints: List<InMemoryMessaging>
        val everyoneOnline: AllPossibleRecipients
        var latencyCalculator: LatencyCalculator?
        fun pumpSend(block: Boolean): MessageTransfer?
        fun pumpSendInternal(transfer: MessageTransfer): Unit
        val receivedMessages: <ERROR CLASS><MessageTransfer>
        val sendManuallyPumped: Boolean
        val sentMessages: <ERROR CLASS><MessageTransfer>
        fun stop(): Unit
      open class InMemoryNetworkMapCache : SingletonSerializeAsToken, NetworkMapCache
        Module Contents InMemoryNetworkMapCache()
        open fun addMapService(net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int?): <ERROR CLASS><Unit>
        open fun addNode(node: NodeInfo): Unit
        open val changed: <ERROR CLASS><MapChange>
        open fun deregisterForUpdates(net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        open fun get(): <ERROR CLASS>
        open fun get(serviceType: ServiceType): <ERROR CLASS>
        open fun getNodeByLegalName(name: String): <ERROR CLASS>
        open fun getNodeByPublicKey(publicKey: PublicKey): <ERROR CLASS>
        open fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        open val networkMapNodes: List<NodeInfo>
        open val notaryNodes: List<NodeInfo>
        open val partyNodes: List<NodeInfo>
        fun processUpdatePush(req: Update): Unit
        open val ratesOracleNodes: List<NodeInfo>
        protected var registeredNodes: MutableMap<Party, NodeInfo>
        open val regulators: List<NodeInfo>
        open fun removeNode(node: NodeInfo): Unit
      class InMemoryNetworkMapService : NetworkMapService, AbstractNodeService
        Module Contents InMemoryNetworkMapService(net: MessagingService, home: NodeRegistration, cache: NetworkMapCache)
        val cache: NetworkMapCache
        fun getUnacknowledgedCount(subscriber: SingleMessageRecipient): Int?
        val maxSizeRegistrationRequestBytes: Int
        val maxUnacknowledgedUpdates: Int
        val nodes: List<NodeInfo>
        fun notifySubscribers(wireReg: WireNodeRegistration): Unit
        fun processAcknowledge(req: UpdateAcknowledge): Unit
        fun processFetchAllRequest(req: FetchMapRequest): FetchMapResponse
        fun processQueryRequest(req: QueryIdentityRequest): QueryIdentityResponse
        fun processRegistrationChangeRequest(req: RegistrationRequest): RegistrationResponse
        fun processSubscriptionRequest(req: SubscribeRequest): SubscribeResponse
      class InMemoryUniquenessProvider : UniquenessProvider
        Module Contents InMemoryUniquenessProvider()
        fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party): Unit
      open class InMemoryWalletService : SingletonSerializeAsToken, WalletService
        Module Contents InMemoryWalletService(services: ServiceHub)
        class ClashingThreads : Exception
          Module Contents ClashingThreads(threads: Set<SecureHash>, transactions: Iterable<WireTransaction>)
        val Wallet.clashingThreads: Set<SecureHash>
        open val currentWallet: Wallet
        open val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        open fun notifyAll(txns: Iterable<WireTransaction>): Wallet
        open val updates: <ERROR CLASS><Update>
      class InsufficientBalanceException : Exception
        Module Contents InsufficientBalanceException(amountMissing: Amount<*>)
        val amountMissing: Amount<*>
        fun toString(): String
      data class InterceptorClause : SingleClause
        Module Contents InterceptorClause(preclause: SingleVerify, clause: SingleClause)
        val clause: SingleClause
        val ifMatched: MatchBehaviour
        val ifNotMatched: MatchBehaviour
        val preclause: SingleVerify
        val requiredCommands: Set<Class<out CommandData>>
        fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
      class InterestRateSwap : ClauseVerifier
        Module Contents InterestRateSwap()
        data class Calculation
          Module Contents Calculation(expression: Expression, floatingLegPaymentSchedule: Map<LocalDate, FloatingRatePaymentEvent>, fixedLegPaymentSchedule: Map<LocalDate, FixedRatePaymentEvent>)
          fun applyFixing(date: LocalDate, newRate: FixedRate): Calculation
          val expression: Expression
          val fixedLegPaymentSchedule: Map<LocalDate, FixedRatePaymentEvent>
          val floatingLegPaymentSchedule: Map<LocalDate, FloatingRatePaymentEvent>
          fun getFixing(date: LocalDate): FloatingRatePaymentEvent
          fun nextFixingDate(): LocalDate?
        interface Clause
          Module Contents abstract class AbstractIRSClause : GroupClause<State, String>
            Module Contents AbstractIRSClause()
            fun checkLegAmounts(legs: Array<CommonLeg>): Unit
            fun checkLegDates(legs: Array<CommonLeg>): Unit
            fun checkRates(legs: Array<CommonLeg>): Boolean
            fun checkSchedules(legs: Array<CommonLeg>): Boolean
            fun getFloatingLegPaymentsDifferences(payments1: Map<LocalDate, Event>, payments2: Map<LocalDate, Event>): List<<ERROR CLASS><LocalDate, <ERROR CLASS><FloatingRatePaymentEvent, FloatingRatePaymentEvent>>>
            open val ifMatched: MatchBehaviour
            open val ifNotMatched: MatchBehaviour
          class Agree : AbstractIRSClause
            Module Contents Agree()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Fix : AbstractIRSClause
            Module Contents Fix()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Group : GroupClauseVerifier<State, String>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, String>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Mature : AbstractIRSClause
            Module Contents Mature()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Pay : AbstractIRSClause
            Module Contents Pay()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Timestamped : SingleClause
            Module Contents Timestamped()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
        interface Commands : CommandData
          Module Contents class Agree : TypeOnlyCommandData, Commands
            Module Contents Agree()
          class Mature : TypeOnlyCommandData, Commands
            Module Contents Mature()
          class Pay : TypeOnlyCommandData, Commands
            Module Contents Pay()
          data class Refix : Commands
            Module Contents Refix(fix: Fix)
            val fix: Fix
        data class Common
          Module Contents Common(baseCurrency: Currency, eligibleCurrency: Currency, eligibleCreditSupport: String, independentAmounts: Amount<Currency>, threshold: Amount<Currency>, minimumTransferAmount: Amount<Currency>, rounding: Amount<Currency>, valuationDate: String, notificationTime: String, resolutionTime: String, interestRate: ReferenceRate, addressForTransfers: String, exposure: UnknownType, localBusinessDay: BusinessCalendar, dailyInterestAmount: Expression, tradeID: String, hashLegalDocs: String)
          val addressForTransfers: String
          val baseCurrency: Currency
          val dailyInterestAmount: Expression
          val eligibleCreditSupport: String
          val eligibleCurrency: Currency
          val exposure: UnknownType
          val hashLegalDocs: String
          val independentAmounts: Amount<Currency>
          val interestRate: ReferenceRate
          val localBusinessDay: BusinessCalendar
          val minimumTransferAmount: Amount<Currency>
          val notificationTime: String
          val resolutionTime: String
          val rounding: Amount<Currency>
          val threshold: Amount<Currency>
          val tradeID: String
          val valuationDate: String
        abstract class CommonLeg
          Module Contents CommonLeg(notional: Amount<Currency>, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment)
          val dayCountBasisDay: DayCountBasisDay
          val dayCountBasisYear: DayCountBasisYear
          val dayInMonth: Int
          val effectiveDate: LocalDate
          val effectiveDateAdjustment: DateRollConvention?
          open fun equals(other: Any?): Boolean
          open fun hashCode(): Int
          val interestPeriodAdjustment: AccrualAdjustment
          val notional: Amount<Currency>
          val paymentCalendar: BusinessCalendar
          val paymentDelay: Int
          val paymentFrequency: Frequency
          val paymentRule: PaymentRule
          val terminationDate: LocalDate
          val terminationDateAdjustment: DateRollConvention?
          open fun toString(): String
        class FixedLeg : CommonLeg
          Module Contents FixedLeg(fixedRatePayer: Party, notional: Amount<Currency>, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment, fixedRate: FixedRate, rollConvention: DateRollConvention)
          fun copy(fixedRatePayer: Party = this.fixedRatePayer, notional: Amount<Currency> = this.notional, paymentFrequency: Frequency = this.paymentFrequency, effectiveDate: LocalDate = this.effectiveDate, effectiveDateAdjustment: DateRollConvention? = this.effectiveDateAdjustment, terminationDate: LocalDate = this.terminationDate, terminationDateAdjustment: DateRollConvention? = this.terminationDateAdjustment, dayCountBasisDay: DayCountBasisDay = this.dayCountBasisDay, dayCountBasisYear: DayCountBasisYear = this.dayCountBasisYear, dayInMonth: Int = this.dayInMonth, paymentRule: PaymentRule = this.paymentRule, paymentDelay: Int = this.paymentDelay, paymentCalendar: BusinessCalendar = this.paymentCalendar, interestPeriodAdjustment: AccrualAdjustment = this.interestPeriodAdjustment, fixedRate: FixedRate = this.fixedRate): FixedLeg
          open fun equals(other: Any?): Boolean
          var fixedRate: FixedRate
          var fixedRatePayer: Party
          open fun hashCode(): Int
          var rollConvention: DateRollConvention
          open fun toString(): String
        class FloatingLeg : CommonLeg
          Module Contents FloatingLeg(floatingRatePayer: Party, notional: Amount<Currency>, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment, rollConvention: DateRollConvention, fixingRollConvention: DateRollConvention, resetDayInMonth: Int, fixingPeriodOffset: Int, resetRule: PaymentRule, fixingsPerPayment: Frequency, fixingCalendar: BusinessCalendar, index: String, indexSource: String, indexTenor: Tenor)
          fun copy(floatingRatePayer: Party = this.floatingRatePayer, notional: Amount<Currency> = this.notional, paymentFrequency: Frequency = this.paymentFrequency, effectiveDate: LocalDate = this.effectiveDate, effectiveDateAdjustment: DateRollConvention? = this.effectiveDateAdjustment, terminationDate: LocalDate = this.terminationDate, terminationDateAdjustment: DateRollConvention? = this.terminationDateAdjustment, dayCountBasisDay: DayCountBasisDay = this.dayCountBasisDay, dayCountBasisYear: DayCountBasisYear = this.dayCountBasisYear, dayInMonth: Int = this.dayInMonth, paymentRule: PaymentRule = this.paymentRule, paymentDelay: Int = this.paymentDelay, paymentCalendar: BusinessCalendar = this.paymentCalendar, interestPeriodAdjustment: AccrualAdjustment = this.interestPeriodAdjustment, rollConvention: DateRollConvention = this.rollConvention, fixingRollConvention: DateRollConvention = this.fixingRollConvention, resetDayInMonth: Int = this.resetDayInMonth, fixingPeriod: Int = this.fixingPeriodOffset, resetRule: PaymentRule = this.resetRule, fixingsPerPayment: Frequency = this.fixingsPerPayment, fixingCalendar: BusinessCalendar = this.fixingCalendar, index: String = this.index, indexSource: String = this.indexSource, indexTenor: Tenor = this.indexTenor): FloatingLeg
          open fun equals(other: Any?): Boolean
          var fixingCalendar: BusinessCalendar
          var fixingPeriodOffset: Int
          var fixingRollConvention: DateRollConvention
          var fixingsPerPayment: Frequency
          var floatingRatePayer: Party
          open fun hashCode(): Int
          var index: String
          var indexSource: String
          var indexTenor: Tenor
          var resetDayInMonth: Int
          var resetRule: PaymentRule
          var rollConvention: DateRollConvention
          open fun toString(): String
        data class State : FixableDealState, SchedulableState
          Module Contents State(fixedLeg: FixedLeg, floatingLeg: FloatingLeg, calculation: Calculation, common: Common)
          val calculation: Calculation
          val common: Common
          val contract: InterestRateSwap
          fun evaluateCalculation(businessDate: LocalDate, expression: Expression = calculation.expression): Any
          val fixedLeg: FixedLeg
          val floatingLeg: FloatingLeg
          fun generateAgreement(notary: Party): TransactionBuilder
          fun generateFix(ptx: TransactionBuilder, oldState: StateAndRef<*>, fix: Fix): Unit
          fun isRelevant(ourKeys: Set<PublicKey>): Boolean
          fun nextFixingOf(): FixOf?
          fun nextScheduledActivity(thisStateRef: StateRef, protocolLogicRefFactory: ProtocolLogicRefFactory): ScheduledActivity?
          val participants: List<PublicKey>
          val parties: Array<Party>
          fun prettyPrint(): <ERROR CLASS>
          val ref: String
          val thread: <ERROR CLASS>
          fun withPublicKey(before: Party, after: PublicKey): DealState
        val clauses: List<SingleClause>
        fun extractCommands(tx: TransactionForContract): Collection<AuthenticatedObject<CommandData>>
        fun generateAgreement(floatingLeg: FloatingLeg, fixedLeg: FixedLeg, calculation: Calculation, common: Common, notary: Party): TransactionBuilder
        fun generateFix(tx: TransactionBuilder, irs: StateAndRef<State>, fixing: Fix): Unit
        val legalContractReference: <ERROR CLASS>
      class InterestRateSwapAPI
        Module Contents InterestRateSwapAPI(services: ServiceHub)
        fun exitServer(): <ERROR CLASS>
        fun fetchDeal(ref: String): <ERROR CLASS>
        fun fetchDeals(): Array<State>
        fun fetchDemoDate(): LocalDate
        val services: ServiceHub
        fun storeDeal(newDeal: State): <ERROR CLASS>
        fun storeDemoDate(newDemoDate: LocalDate): <ERROR CLASS>
      interface Interpolator
        Module Contents abstract fun interpolate(x: Double): Double
      interface InterpolatorFactory
        Module Contents abstract fun create(xs: DoubleArray, ys: DoubleArray): Interpolator
      interface IssuanceDefinition
      interface IssueCommand : CommandData
        Module Contents abstract val nonce: Long
      data class Issued<out P>
        Module Contents Issued(issuer: PartyAndReference, product: P)
        val issuer: PartyAndReference
        val product: P
        fun toString(): String
      object JsonSupport
        Module Contents object CalendarDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): BusinessCalendar
        object LocalDateDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): LocalDate
        object LocalDateKeyDeserializer
          Module Contents fun deserializeKey(text: String, p1: <ERROR CLASS>): Any?
        object PartyDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): Party
        object PartySerializer
          Module Contents fun serialize(obj: Party, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        object PublicKeyDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): <ERROR CLASS>
        object PublicKeySerializer
          Module Contents fun serialize(obj: <ERROR CLASS>, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        class SecureHashDeserializer<T : SecureHash>
          Module Contents SecureHashDeserializer()
          fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): T
        object SecureHashSerializer
          Module Contents fun serialize(obj: SecureHash, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        class ServiceHubObjectMapper
          Module Contents ServiceHubObjectMapper(identities: IdentityService)
          val identities: IdentityService
        object ToStringSerializer
          Module Contents fun serialize(obj: Any, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        fun createDefaultMapper(identities: IdentityService): <ERROR CLASS>
      interface KeyManagementService
        Module Contents abstract fun freshKey(): KeyPair
        abstract val keys: Map<PublicKey, PrivateKey>
        open fun toKeyPair(publicKey: PublicKey): KeyPair
        open fun toPrivate(publicKey: PublicKey): PrivateKey
      object KotlinObjectSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<DeserializeAsKotlinObjectDef>): DeserializeAsKotlinObjectDef
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: DeserializeAsKotlinObjectDef): Unit
      class LedgerDSL<out T : TransactionDSLInterpreter, out L : LedgerDSLInterpreter<T>> : LedgerDSLInterpreter<TransactionDSLInterpreter>
        Module Contents LedgerDSL(interpreter: L)
        val interpreter: L
        inline fun <reified S : ContractState> String.output(): S
        inline fun <reified S : ContractState> String.outputStateAndRef(): StateAndRef<S>
        fun <S : ContractState> retrieveOutput(clazz: Class<S>, label: String): S
        fun transaction(label: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(), dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): WireTransaction
        fun unverifiedTransaction(label: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(), dsl: TransactionDSL<TransactionDSLInterpreter>.() -> Unit): WireTransaction
      interface LedgerDSLInterpreter<out T : TransactionDSLInterpreter> : Verifies, OutputStateLookup
        Module Contents abstract fun _transaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<T>.() -> EnforceVerifyOrFail): WireTransaction
        abstract fun _unverifiedTransaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<T>.() -> Unit): WireTransaction
        abstract fun attachment(attachment: InputStream): SecureHash
        abstract fun tweak(dsl: LedgerDSL<T, LedgerDSLInterpreter<T>>.() -> Unit): Unit
      data class LedgerTransaction : NamedByHash
        Module Contents LedgerTransaction(inputs: List<StateAndRef<*>>, outputs: List<TransactionState<*>>, commands: List<AuthenticatedObject<CommandData>>, attachments: List<Attachment>, id: SecureHash, signers: List<PublicKey>, type: TransactionType)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        val id: SecureHash
        val inputs: List<StateAndRef<*>>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        val outputs: List<TransactionState<*>>
        val signers: List<PublicKey>
        fun toTransactionForContract(): TransactionForContract
        val type: TransactionType
        fun verify(): Unit
      class LinearInterpolator : Interpolator
        Module Contents LinearInterpolator(xs: DoubleArray, ys: DoubleArray)
        fun create(xs: DoubleArray, ys: DoubleArray): LinearInterpolator
        fun interpolate(x: Double): Double
      interface LinearState : ContractState
        Module Contents abstract fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        abstract val thread: SecureHash
      enum class MatchBehaviour
        Module Contents CONTINUE
        END
        ERROR
      interface Message
        Module Contents abstract val data: ByteArray
        abstract val debugMessageID: String
        abstract val debugTimestamp: Instant
        abstract fun serialise(): ByteArray
        abstract val topicSession: TopicSession
      interface MessageHandlerRegistration
      interface MessageRecipientGroup : MessageRecipients
      interface MessageRecipients
      interface MessagingService
        Module Contents abstract fun addMessageHandler(topic: String = "", sessionID: Long = DEFAULT_SESSION_ID, executor: Executor? = null, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        abstract fun addMessageHandler(topicSession: TopicSession, executor: Executor? = null, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        abstract fun createMessage(topic: String, sessionID: Long = DEFAULT_SESSION_ID, data: ByteArray): Message
        abstract fun createMessage(topicSession: TopicSession, data: ByteArray): Message
        abstract val myAddress: SingleMessageRecipient
        abstract fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        abstract fun send(message: Message, target: MessageRecipients): Unit
      interface MessagingServiceBuilder<out T : MessagingServiceInternal>
        Module Contents abstract fun start(): <ERROR CLASS><out T>
      interface MessagingServiceInternal : MessagingService
        Module Contents abstract fun stop(): Unit
      class MissingAttachmentsException : Exception
        Module Contents MissingAttachmentsException(ids: List<SecureHash>)
        val ids: List<SecureHash>
      class MockAttachmentStorage : AttachmentStorage
        Module Contents MockAttachmentStorage()
        val files: HashMap<SecureHash, ByteArray>
        fun importAttachment(jar: InputStream): SecureHash
        fun openAttachment(id: SecureHash): Attachment?
      class MockIdentityService : IdentityService, SingletonSerializeAsToken
        Module Contents MockIdentityService(identities: List<Party>)
        val identities: List<Party>
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
      class MockKeyManagementService : SingletonSerializeAsToken, KeyManagementService
        Module Contents MockKeyManagementService(vararg initialKeys: KeyPair)
        fun freshKey(): KeyPair
        val keys: MutableMap<PublicKey, PrivateKey>
        val nextKeys: LinkedList<KeyPair>
      class MockNetwork
        Module Contents MockNetwork(networkSendManuallyPumped: Boolean = false, threadPerNode: Boolean = false, defaultFactory: Factory = MockNetwork.DefaultFactory)
        object DefaultFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        interface Factory
          Module Contents abstract fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        class MockNode : AbstractNode
          Module Contents MockNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?)
          open fun findMyLocation(): PhysicalLocation?
          protected open fun generateKeyPair(): KeyPair
          val id: Int
          val keyPair: KeyPair?
          protected open val log: <ERROR CLASS>
          protected open fun makeIdentityService(): MockIdentityService
          protected open fun makeMessagingService(): MessagingServiceInternal
          val mockNet: MockNetwork
          protected open fun noNetworkMapConfigured(): <ERROR CLASS>
          val place: PhysicalLocation
          protected open val serverThread: AffinityExecutor
          open fun start(): MockNode
          protected open fun startMessagingService(): Unit
        fun addressToNode(address: SingleMessageRecipient): MockNode
        fun createNode(networkMapAddress: NodeInfo? = null, forcedID: Int = -1, nodeFactory: Factory = defaultFactory, start: Boolean = true, legalName: String? = null, keyPair: KeyPair? = null, vararg advertisedServices: ServiceType): MockNode
        fun createNotaryNode(legalName: String? = null, keyPair: KeyPair? = null): MockNode
        fun createPartyNode(networkMapAddr: NodeInfo, legalName: String? = null, keyPair: KeyPair? = null): MockNode
        fun createTwoNodes(nodeFactory: Factory = defaultFactory, notaryKeyPair: KeyPair? = null): <ERROR CLASS><MockNode, MockNode>
        val filesystem: <ERROR CLASS>
        val identities: ArrayList<Party>
        val messagingNetwork: InMemoryMessagingNetwork
        val nodes: List<MockNode>
        fun runNetwork(rounds: Int = -1): Unit
        fun startNodes(): Unit
        fun stopNodes(): Unit
      class MockNetworkMapCache : InMemoryNetworkMapCache
        Module Contents MockNetworkMapCache()
        data class MockAddress : SingleMessageRecipient
          Module Contents MockAddress(id: String)
          val id: String
        fun addRegistration(node: NodeInfo): Unit
        val changed: <ERROR CLASS><MapChange>
        fun deleteRegistration(identity: Party): Boolean
      open class MockServices : ServiceHub
        Module Contents MockServices(key: KeyPair = generateKeyPair())
        open val clock: Clock
        open val identityService: MockIdentityService
        open fun <T : Any> invokeProtocolAsync(logicType: Class<out ProtocolLogic<T>>, vararg args: Any?): <ERROR CLASS><T>
        val key: KeyPair
        open val keyManagementService: MockKeyManagementService
        open val networkMapCache: NetworkMapCache
        open val networkService: MessagingService
        open fun recordTransactions(txs: Iterable<SignedTransaction>): Unit
        open val schedulerService: SchedulerService
        open val storageService: TxWritableStorageService
        open val walletService: WalletService
      class MockStorageService : SingletonSerializeAsToken, TxWritableStorageService
        Module Contents MockStorageService(attachments: AttachmentStorage = MockAttachmentStorage(), validatedTransactions: TransactionStorage = MockTransactionStorage(), myLegalIdentityKey: KeyPair = generateKeyPair(), myLegalIdentity: Party = Party("Unit test party", myLegalIdentityKey.public))
        val attachments: AttachmentStorage
        val myLegalIdentity: Party
        val myLegalIdentityKey: KeyPair
        val validatedTransactions: TransactionStorage
      open class MockTransactionStorage : TransactionStorage
        Module Contents MockTransactionStorage()
        open fun addTransaction(transaction: SignedTransaction): Unit
        open fun getTransaction(id: SecureHash): SignedTransaction?
      class MonitoringService : SingletonSerializeAsToken
        Module Contents MonitoringService(metrics: <ERROR CLASS>)
        val metrics: <ERROR CLASS>
      interface MoveCommand : CommandData
        Module Contents abstract val contractHash: SecureHash?
      data class MultilateralNetState<P> : NetState<P>
        Module Contents MultilateralNetState(template: Terms<P>)
        val template: Terms<P>
      interface MultilateralNettableState<out T : Any>
        Module Contents abstract val multilateralNetState: T
      abstract class MutableClock : Clock
        Module Contents MutableClock()
        val mutationCount: Long
        val mutations: <ERROR CLASS><Long>
        protected fun notifyMutationObservers(): Unit
      class NameServiceConfig
        Module Contents NameServiceConfig(conf: <ERROR CLASS>)
        val address: <ERROR CLASS>
        val hostServiceLocally: Boolean
        val identity: String
      interface NamedByHash
        Module Contents abstract val id: SecureHash
      open class NetClause<P> : SingleClause
        Module Contents NetClause()
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
        fun verifyNetCommand(inputs: List<State<P>>, outputs: List<State<P>>, command: AuthenticatedObject<Net>, netState: NetState<P>): Unit
      interface NetState<P>
        Module Contents abstract val template: Terms<P>
      enum class NetType
        Module Contents CLOSE_OUT
        PAYMENT
      interface NettableState<N : BilateralNettableState<N>, T : Any> : BilateralNettableState<N>, MultilateralNettableState<T>
      sealed class NetworkCacheError : Exception
        Module Contents class DeregistrationFailed : NetworkCacheError
          Module Contents DeregistrationFailed()
      interface NetworkMapCache
        Module Contents data class MapChange
          Module Contents MapChange(node: NodeInfo, type: MapChangeType)
          val node: NodeInfo
          val type: MapChangeType
        enum class MapChangeType
          Module Contents Added
          Removed
        abstract fun addMapService(net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int? = null): <ERROR CLASS><Unit>
        abstract fun addNode(node: NodeInfo): Unit
        abstract val changed: <ERROR CLASS><MapChange>
        abstract fun deregisterForUpdates(net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        abstract fun get(): Collection<NodeInfo>
        abstract fun get(serviceType: ServiceType): Collection<NodeInfo>
        abstract fun getNodeByLegalName(name: String): NodeInfo?
        abstract fun getNodeByPublicKey(publicKey: PublicKey): NodeInfo?
        abstract fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        val logger: <ERROR CLASS>
        abstract val networkMapNodes: List<NodeInfo>
        abstract val notaryNodes: List<NodeInfo>
        abstract val partyNodes: List<NodeInfo>
        abstract val ratesOracleNodes: List<NodeInfo>
        abstract val regulators: List<NodeInfo>
        abstract fun removeNode(node: NodeInfo): Unit
      interface NetworkMapService
        Module Contents val DEFAULT_EXPIRATION_PERIOD: Period
        val FETCH_PROTOCOL_TOPIC: String
        class FetchMapRequest : NetworkMapRequestMessage
          Module Contents FetchMapRequest(subscribe: Boolean, ifChangedSinceVersion: Int?, replyTo: MessageRecipients, sessionID: Long)
          val ifChangedSinceVersion: Int?
          val sessionID: Long
          val subscribe: Boolean
        data class FetchMapResponse
          Module Contents FetchMapResponse(nodes: Collection<NodeRegistration>?, version: Int)
          val nodes: Collection<NodeRegistration>?
          val version: Int
        abstract class NetworkMapRequestMessage : ServiceRequestMessage
          Module Contents NetworkMapRequestMessage(replyTo: MessageRecipients)
          open fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
          val replyTo: MessageRecipients
        val PUSH_ACK_PROTOCOL_TOPIC: String
        val PUSH_PROTOCOL_TOPIC: String
        val QUERY_PROTOCOL_TOPIC: String
        class QueryIdentityRequest : NetworkMapRequestMessage
          Module Contents QueryIdentityRequest(identity: Party, replyTo: MessageRecipients, sessionID: Long)
          val identity: Party
          val sessionID: Long
        data class QueryIdentityResponse
          Module Contents QueryIdentityResponse(node: NodeInfo?)
          val node: NodeInfo?
        val REGISTER_PROTOCOL_TOPIC: String
        class RegistrationRequest : NetworkMapRequestMessage
          Module Contents RegistrationRequest(wireReg: WireNodeRegistration, replyTo: MessageRecipients, sessionID: Long)
          val sessionID: Long
          val wireReg: WireNodeRegistration
        data class RegistrationResponse
          Module Contents RegistrationResponse(success: Boolean)
          val success: Boolean
        val SUBSCRIPTION_PROTOCOL_TOPIC: String
        class SubscribeRequest : NetworkMapRequestMessage
          Module Contents SubscribeRequest(subscribe: Boolean, replyTo: MessageRecipients, sessionID: Long)
          val sessionID: Long
          val subscribe: Boolean
        data class SubscribeResponse
          Module Contents SubscribeResponse(confirmed: Boolean)
          val confirmed: Boolean
        object Type : ServiceType
        data class Update
          Module Contents Update(wireReg: WireNodeRegistration, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireReg: WireNodeRegistration
        data class UpdateAcknowledge
          Module Contents UpdateAcknowledge(wireRegHash: SecureHash, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireRegHash: SecureHash
        val logger: <ERROR CLASS>
        abstract val nodes: List<NodeInfo>
      class NoReferencesSerializer<T>
        Module Contents NoReferencesSerializer(baseSerializer: <ERROR CLASS><T>)
        val baseSerializer: <ERROR CLASS><T>
        fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<T>): T
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit
      open class NoZeroSizedOutputs<in S : FungibleAsset<T>, T : Any> : GroupClause<S, Issued<T>>
        Module Contents NoZeroSizedOutputs()
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        open val requiredCommands: Set<Class<CommandData>>
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<T>): Set<CommandData>
      class Node : AbstractNode
        Module Contents Node(dir: Path, p2pAddr: <ERROR CLASS>, webServerAddr: <ERROR CLASS>, configuration: NodeConfiguration, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, clock: Clock = NodeClock(), messagingServerAddr: <ERROR CLASS>? = null)
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingServiceInternal
        var messageBroker: ArtemisMessagingServer?
        val messagingServerAddr: <ERROR CLASS>?
        val p2pAddr: <ERROR CLASS>
        protected val serverThread: ServiceAffinityExecutor
        fun setup(): Node
        fun start(): Node
        protected fun startMessagingService(): Unit
        fun stop(): Unit
        lateinit var webServer: <ERROR CLASS>
        val webServerAddr: <ERROR CLASS>
      class NodeAttachmentService : AttachmentStorage, AcceptsFileUpload
        Module Contents NodeAttachmentService(storePath: Path, metrics: <ERROR CLASS>)
        class OnDiskHashMismatch : Exception
          Module Contents OnDiskHashMismatch(file: Path, actual: SecureHash)
          val actual: SecureHash
          val file: Path
          fun toString(): String
        val acceptableFileExtensions: <ERROR CLASS>
        var automaticallyExtractAttachments: Boolean
        var checkAttachmentsOnLoad: Boolean
        val dataTypePrefix: String
        fun importAttachment(jar: InputStream): SecureHash
        fun openAttachment(id: SecureHash): Attachment?
        val storePath: Path
        fun upload(data: InputStream): <ERROR CLASS>
      class NodeClock : Clock, SerializeAsToken
        Module Contents NodeClock(delegateClock: Clock = Clock.systemUTC())
        fun getZone(): ZoneId
        fun instant(): Instant
        fun toToken(context: SerializeAsTokenContext): SerializationToken
        fun withZone(zone: ZoneId): Clock
      interface NodeConfiguration
        Module Contents abstract val exportJMXto: String
        abstract val keyStorePassword: String
        abstract val myLegalName: String
        abstract val nearestCity: String
        abstract val trustStorePassword: String
      class NodeConfigurationFromConfig : NodeConfiguration
        Module Contents NodeConfigurationFromConfig(config: <ERROR CLASS> = ConfigFactory.load())
        val config: <ERROR CLASS>
        val exportJMXto: String
        val keyStorePassword: String
        val myLegalName: String
        val nearestCity: String
        val trustStorePassword: String
      data class NodeInfo
        Module Contents NodeInfo(address: SingleMessageRecipient, identity: Party, advertisedServices: Set<ServiceType> = emptySet(), physicalLocation: PhysicalLocation? = null)
        val address: SingleMessageRecipient
        var advertisedServices: Set<ServiceType>
        val identity: Party
        val physicalLocation: PhysicalLocation?
      object NodeInterestRates
        Module Contents class FixContainer
          Module Contents FixContainer(fixes: List<Fix>, factory: InterpolatorFactory = CubicSplineInterpolator)
          val factory: InterpolatorFactory
          operator fun get(fixOf: FixOf): Fix?
          val size: Int
        class InterpolatingRateMap
          Module Contents InterpolatingRateMap(date: LocalDate, inputRates: Map<Tenor, BigDecimal>, calendar: BusinessCalendar, factory: InterpolatorFactory)
          val calendar: BusinessCalendar
          val date: LocalDate
          val factory: InterpolatorFactory
          fun getRate(tenor: Tenor): BigDecimal?
          val size: Int
        class Oracle
          Module Contents Oracle(identity: Party, signingKey: KeyPair, clock: Clock)
          val clock: Clock
          val identity: Party
          var knownFixes: FixContainer
          fun query(queries: List<FixOf>, deadline: Instant): List<Fix>
          fun sign(wtx: WireTransaction): LegallyIdentifiable
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val requiredProtocols: Map<String, Set<String>>
          val servicePlugins: List<Class<*>>
        class Service : AcceptsFileUpload, AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
          val acceptableFileExtensions: <ERROR CLASS>
          val dataTypePrefix: String
          val oracle: Oracle
          val ss: StorageService
          fun upload(data: InputStream): String
        object Type : ServiceType
        class UnknownFix : RetryableException
          Module Contents UnknownFix(fix: FixOf)
          val fix: FixOf
        fun parseFile(s: String): FixContainer
        fun parseFix(s: String): Fix
        fun parseFixOf(key: String): FixOf
      sealed class NodeMapError : Exception
        Module Contents class InvalidSignature : NodeMapError
          Module Contents InvalidSignature()
        class InvalidSubscriber : NodeMapError
          Module Contents InvalidSubscriber()
        class UnknownChangeType : NodeMapError
          Module Contents UnknownChangeType()
      class NodeRegistration
        Module Contents NodeRegistration(node: NodeInfo, serial: Long, type: AddOrRemove, expires: Instant)
        var expires: Instant
        val node: NodeInfo
        val serial: Long
        fun toString(): String
        fun toWire(privateKey: PrivateKey): WireNodeRegistration
        val type: AddOrRemove
      class NodeSchedulerService : SchedulerService, SingletonSerializeAsToken
        Module Contents NodeSchedulerService(services: ServiceHubInternal, protocolLogicRefFactory: ProtocolLogicRefFactory = ProtocolLogicRefFactory(), schedulerTimerExecutor: Executor = Executors.newSingleThreadExecutor())
        fun scheduleStateActivity(action: ScheduledStateRef): Unit
        fun unscheduleStateActivity(ref: StateRef): Unit
      class NodeWalletService : InMemoryWalletService
        Module Contents NodeWalletService(services: ServiceHub)
      class NonEmptySet<T> : MutableSet<T>
        Module Contents NonEmptySet(initial: T)
        inner class Iterator<out T, T> : MutableIterator<T>
          Module Contents Iterator(iterator: MutableIterator<T>)
          fun hasNext(): Boolean
          val iterator: MutableIterator<T>
          fun next(): T
          fun remove(): Unit
        fun add(element: T): Boolean
        fun addAll(elements: Collection<T>): Boolean
        fun clear(): Nothing
        fun contains(element: T): Boolean
        fun containsAll(elements: Collection<T>): Boolean
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        fun isEmpty(): Boolean
        fun iterator(): MutableIterator<T>
        fun remove(element: T): Boolean
        fun removeAll(elements: Collection<T>): Boolean
        fun retainAll(elements: Collection<T>): Boolean
        val size: Int
        fun toString(): String
      object NonEmptySetSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<NonEmptySet<Any>>): NonEmptySet<Any>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: NonEmptySet<Any>): Unit
      object NotaryChange
        Module Contents class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service : AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
          val services: ServiceHubInternal
      object NotaryChangeProtocol : AbstractStateReplacementProtocol<Party>
        Module Contents class Acceptor : Acceptor<Party>
          Module Contents Acceptor(otherSide: Party, sessionIdForSend: Long, sessionIdForReceive: Long, progressTracker: ProgressTracker = tracker())
          val progressTracker: ProgressTracker
          protected val topic: String
        class Instigator<T : ContractState> : Instigator<T, Party>
          Module Contents Instigator(originalState: StateAndRef<T>, newNotary: Party, progressTracker: ProgressTracker = tracker())
          protected val topic: String
        data class Proposal : Proposal<Party>
          Module Contents Proposal(stateRef: StateRef, modification: Party, stx: SignedTransaction)
          val modification: Party
          val stateRef: StateRef
          val stx: SignedTransaction
        val TOPIC: String
      sealed class NotaryError
        Module Contents class Conflict : NotaryError
          Module Contents Conflict(tx: WireTransaction, conflict: SignedData<Conflict>)
          val conflict: SignedData<Conflict>
          fun toString(): String
          val tx: WireTransaction
        class MoreThanOneTimestamp : NotaryError
          Module Contents MoreThanOneTimestamp()
        class NotForMe : NotaryError
          Module Contents NotForMe()
        class SignaturesMissing : NotaryError
          Module Contents SignaturesMissing(missingSigners: List<PublicKey>)
          val missingSigners: List<PublicKey>
        class TimestampInvalid : NotaryError
          Module Contents TimestampInvalid()
        class TransactionInvalid : NotaryError
          Module Contents TransactionInvalid()
      class NotaryException : Exception
        Module Contents NotaryException(error: NotaryError)
        val error: NotaryError
        fun toString(): String
      object NotaryProtocol
        Module Contents class Client : ProtocolLogic<LegallyIdentifiable>
          Module Contents Client(stx: SignedTransaction, progressTracker: ProgressTracker = Client.tracker())
          object REQUESTING : Step
          object VALIDATING : Step
          fun call(): LegallyIdentifiable
          lateinit var notaryParty: Party
          val progressTracker: ProgressTracker
          protected val topic: String
          fun tracker(): ProgressTracker
        object DefaultFactory : Factory
          Module Contents fun create(otherSide: Party, sendSessionID: Long, receiveSessionID: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        interface Factory
          Module Contents abstract fun create(otherSide: Party, sendSessionID: Long, receiveSessionID: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        data class Handshake : PartyRequestMessage
          Module Contents Handshake(replyToParty: Party, sendSessionID: Long, sessionID: Long)
          val replyToParty: Party
          val sendSessionID: Long
          val sessionID: Long
        data class Result
          Module Contents val error: NotaryError?
          fun noError(sig: LegallyIdentifiable): Result
          val sig: LegallyIdentifiable?
          fun withError(error: NotaryError): Result
        class Service : ProtocolLogic<Unit>
          Module Contents Service(otherSide: Party, sendSessionID: Long, receiveSessionID: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
          open fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit
          open fun call(): Unit
          val otherSide: Party
          val receiveSessionID: Long
          val sendSessionID: Long
          val timestampChecker: TimestampChecker
          protected open val topic: String
          val uniquenessProvider: UniquenessProvider
        data class SignRequest
          Module Contents SignRequest(tx: SignedTransaction, callerIdentity: Party)
          val callerIdentity: Party
          val tx: SignedTransaction
        val TOPIC: String
      abstract class NotaryService : AbstractNodeService
        Module Contents NotaryService(smm: StateMachineManager, net: MessagingService, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider, networkMapCache: NetworkMapCache)
        object Type : ServiceType
        abstract val logger: <ERROR CLASS>
        abstract val protocolFactory: Factory
        val smm: StateMachineManager
        val timestampChecker: TimestampChecker
        val uniquenessProvider: UniquenessProvider
      object NullPublicKey : PublicKey, Comparable<PublicKey>
        Module Contents fun compareTo(other: PublicKey): Int
        fun getAlgorithm(): String
        fun getEncoded(): ByteArray
        fun getFormat(): String
        fun toString(): String
      object NullSignature : WithKey
      class Obligation<P> : ClauseVerifier
        Module Contents Obligation()
        interface Clauses
          Module Contents class ConserveAmount<P> : AbstractConserveAmount<State<P>, Terms<P>>
            Module Contents ConserveAmount()
          class Group<P> : GroupClauseVerifier<State<P>, Issued<Terms<P>>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State<P>, Issued<Terms<P>>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue<P> : AbstractIssue<State<P>, Terms<P>>
            Module Contents Issue()
            val requiredCommands: <ERROR CLASS>
          class Net<P> : NetClause<P>
            Module Contents Net()
          class SetLifecycle<P> : GroupClause<State<P>, Issued<Terms<P>>>
            Module Contents SetLifecycle()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms<P>>): Set<CommandData>
          class Settle<P> : GroupClause<State<P>, Issued<Terms<P>>>
            Module Contents Settle()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms<P>>): Set<CommandData>
          class VerifyLifecycle<P> : SingleClause, GroupClause<State<P>, Issued<Terms<P>>>
            Module Contents VerifyLifecycle()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms<P>>): Set<CommandData>
            fun verify(inputs: List<State<P>>, outputs: List<State<P>>): Set<CommandData>
        interface Commands : Commands
          Module Contents data class Exit<P> : Commands, Exit<Terms<P>>
            Module Contents Exit(amount: Amount<Issued<Terms<P>>>)
            val amount: Amount<Issued<Terms<P>>>
          data class Issue : Issue, Commands
            Module Contents Issue(nonce: Long = random63BitValue())
            val nonce: Long
          data class Move : Commands, Move
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
          data class Net : Commands
            Module Contents Net(type: NetType)
            val type: NetType
          data class SetLifecycle : Commands
            Module Contents SetLifecycle(lifecycle: Lifecycle)
            val inverse: Lifecycle
            val lifecycle: Lifecycle
          data class Settle<P> : Commands
            Module Contents Settle(amount: Amount<Issued<Terms<P>>>)
            val amount: Amount<Issued<Terms<P>>>
        enum class Lifecycle
          Module Contents DEFAULTED
          NORMAL
        data class State<P> : FungibleAsset<Terms<P>>, NettableState<State<P>, MultilateralNetState<P>>
          Module Contents State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor: Party, template: Terms<P>, quantity: Long, beneficiary: PublicKey)
          val amount: Amount<Issued<Terms<P>>>
          val beneficiary: PublicKey
          val bilateralNetState: BilateralNetState<P>
          val contract: Obligation<Currency>
          val deposit: PartyAndReference
          val dueBefore: Instant
          val exitKeys: Collection<PublicKey>
          val issuanceDef: Issued<Terms<P>>
          var lifecycle: Lifecycle
          fun move(newAmount: Amount<Issued<Terms<P>>>, newOwner: PublicKey): State<P>
          val multilateralNetState: MultilateralNetState<P>
          fun net(other: State<P>): State<P>
          val obligor: Party
          val owner: PublicKey
          val participants: List<PublicKey>
          val quantity: Long
          val template: Terms<P>
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        data class Terms<P>
          Module Contents Terms(acceptableContracts: NonEmptySet<SecureHash>, acceptableIssuedProducts: NonEmptySet<Issued<P>>, dueBefore: Instant, timeTolerance: Duration = Duration.ofSeconds(30))
          val acceptableContracts: NonEmptySet<SecureHash>
          val acceptableIssuedProducts: NonEmptySet<Issued<P>>
          val dueBefore: Instant
          val product: P
          val timeTolerance: Duration
        val clauses: <ERROR CLASS>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<Commands>>
        fun generateCloseOutNetting(tx: TransactionBuilder, signer: PublicKey, vararg states: State<P>): Unit
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<Terms<P>>>, changeKey: PublicKey, assetStates: List<StateAndRef<State<P>>>): PublicKey
        fun generateIssue(tx: TransactionBuilder, obligor: Party, issuanceDef: Terms<P>, pennies: Long, beneficiary: PublicKey, notary: Party): Unit
        fun generatePaymentNetting(tx: TransactionBuilder, issued: Issued<Terms<P>>, notary: Party, vararg states: State<P>): Unit
        fun generateSetLifecycle(tx: TransactionBuilder, statesAndRefs: List<StateAndRef<State<P>>>, lifecycle: Lifecycle, notary: Party): Unit
        fun generateSettle(tx: TransactionBuilder, statesAndRefs: Iterable<StateAndRef<State<P>>>, assetStatesAndRefs: Iterable<StateAndRef<FungibleAsset<P>>>, moveCommand: MoveCommand, notary: Party): Unit
        val legalContractReference: SecureHash
      abstract class OnLedgerAsset<T : Any, S : FungibleAsset<T>> : ClauseVerifier
        Module Contents OnLedgerAsset()
        abstract val conserveClause: AbstractConserveAmount<S, T>
        abstract fun deriveState(txState: TransactionState<S>, amount: Amount<Issued<T>>, owner: PublicKey): TransactionState<S>
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, changeKey: PublicKey, assetStates: List<StateAndRef<S>>): PublicKey
        abstract fun generateExitCommand(amount: Amount<Issued<T>>): Exit<T>
        abstract fun generateIssueCommand(): Issue
        abstract fun generateMoveCommand(): Move
        fun generateSpend(tx: TransactionBuilder, amount: Amount<T>, to: PublicKey, assetsStates: List<StateAndRef<S>>, onlyFromParties: Set<Party>? = null): List<PublicKey>
      open class OpaqueBytes
        Module Contents OpaqueBytes(bits: ByteArray)
        val bits: ByteArray
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        fun of(vararg b: Byte): OpaqueBytes
        val size: Int
        open fun toString(): String
      interface OutputStateLookup
        Module Contents abstract fun <S : ContractState> retrieveOutputStateAndRef(clazz: Class<S>, label: String): StateAndRef<S>
      interface OwnableState : ContractState
        Module Contents abstract val owner: PublicKey
        abstract fun withNewOwner(newOwner: PublicKey): <ERROR CLASS><CommandData, OwnableState>
      object ParamsSpec
        Module Contents val baseDirectoryArg: <ERROR CLASS>
        val configFileArg: <ERROR CLASS>
        val parser: <ERROR CLASS>
      data class Party
        Module Contents Party(name: String, owningKey: PublicKey)
        val name: String
        val owningKey: PublicKey
        fun ref(bytes: OpaqueBytes): PartyAndReference
        fun ref(vararg bytes: Byte): PartyAndReference
        fun toString(): String
      data class PartyAndReference
        Module Contents PartyAndReference(party: Party, reference: OpaqueBytes)
        val party: Party
        val reference: OpaqueBytes
        fun toString(): String
      interface PartyRequestMessage : ServiceRequestMessage
        Module Contents open fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
        abstract val replyToParty: Party
      abstract class PaymentEvent : Event
        Module Contents PaymentEvent(date: LocalDate)
        abstract fun calculate(): Amount<Currency>
      enum class PaymentRule
        Module Contents InAdvance
        InArrears
      class PerFileCheckpointStorage : CheckpointStorage
        Module Contents PerFileCheckpointStorage(storeDir: Path)
        fun addCheckpoint(checkpoint: Checkpoint): Unit
        val checkpoints: Iterable<Checkpoint>
        fun removeCheckpoint(checkpoint: Checkpoint): Unit
        val storeDir: Path
      class PerFileTransactionStorage : TransactionStorage
        Module Contents PerFileTransactionStorage(storeDir: Path)
        fun addTransaction(transaction: SignedTransaction): Unit
        fun getTransaction(id: SecureHash): SignedTransaction?
        val storeDir: Path
        val transactions: Iterable<SignedTransaction>
      open class PercentageRatioUnit : RatioUnit
        Module Contents PercentageRatioUnit(percentageAsString: String)
        open fun toString(): <ERROR CLASS>
      data class PhysicalLocation
        Module Contents PhysicalLocation(coordinate: WorldCoordinate, description: String)
        val coordinate: WorldCoordinate
        val description: String
      class Polynomial
        Module Contents Polynomial(coefficients: DoubleArray)
        fun getValue(x: Double): <ERROR CLASS>
      class ProgressTracker
        Module Contents ProgressTracker(vararg steps: Step)
        sealed class Change
          Module Contents class Position : Change
            Module Contents Position(tracker: ProgressTracker, newStep: Step)
            val newStep: Step
            fun toString(): String
            val tracker: ProgressTracker
          class Rendering : Change
            Module Contents Rendering(tracker: ProgressTracker, ofStep: Step)
            val ofStep: Step
            fun toString(): String
            val tracker: ProgressTracker
          class Structural : Change
            Module Contents Structural(tracker: ProgressTracker, parent: Step)
            val parent: Step
            fun toString(): String
            val tracker: ProgressTracker
        object DONE : Step
          Module Contents fun equals(other: Any?): Boolean
        inner class RelabelableStep : Step
          Module Contents RelabelableStep(currentLabel: String)
          open val changes: <ERROR CLASS>
          var currentLabel: String
          open val label: String
        class Step
          Module Contents Step(label: String)
          open val changes: <ERROR CLASS><Change>
          open fun childProgressTracker(): ProgressTracker?
          open val label: String
        object UNSTARTED : Step
          Module Contents fun equals(other: Any?): Boolean
        val allSteps: List<<ERROR CLASS><Int, Step>>
        val changes: <ERROR CLASS><Change>
        var currentStep: Step
        val currentStepRecursive: Step
        fun getChildProgressTracker(step: Step): ProgressTracker?
        fun nextStep(): Step
        var parent: ProgressTracker?
        fun setChildProgressTracker(step: Step, childProgressTracker: ProgressTracker): Unit
        var stepIndex: Int
        val steps: Array<Step>
        val topLevelTracker: ProgressTracker
      data class ProtocolClassRef : ProtocolRef
        Module Contents ProtocolClassRef(className: String)
        val className: String
      data class ProtocolInstanceRef
        Module Contents ProtocolInstanceRef(protocolInstance: SecureHash, protocolClass: ProtocolClassRef, protocolStepId: String)
        val protocolClass: ProtocolClassRef
        val protocolInstance: SecureHash
        val protocolStepId: String
      abstract class ProtocolLogic<out T>
        Module Contents ProtocolLogic()
        abstract fun call(): T
        val logger: <ERROR CLASS>
        open val progressTracker: ProgressTracker?
        lateinit var psm: ProtocolStateMachine<*>
        inline fun <reified T : Any> receive(sessionIDForReceive: Long): UntrustworthyData<T>
        fun <T : Any> receive(sessionIDForReceive: Long, receiveType: Class<T>): UntrustworthyData<T>
        fun send(destination: Party, sessionID: Long, payload: Any): Unit
        inline fun <reified T : Any> sendAndReceive(destination: Party, sessionIDForSend: Long, sessionIDForReceive: Long, payload: Any): UntrustworthyData<T>
        val serviceHub: ServiceHub
        fun <R> subProtocol(subLogic: ProtocolLogic<R>): R
        protected abstract val topic: String
      data class ProtocolLogicRef
        Module Contents val appContext: AppContext
        val args: Map<String, Any?>
        val protocolLogicClassName: String
      class ProtocolLogicRefFactory : SingletonSerializeAsToken
        Module Contents ProtocolLogicRefFactory()
        ProtocolLogicRefFactory(protocolWhitelist: Map<String, Set<String>>)
        fun create(type: Class<out ProtocolLogic<*>>, vararg args: Any?): ProtocolLogicRef
        fun createKotlin(protocolLogicClassName: String, args: Map<String, Any?>, attachments: List<SecureHash> = emptyList()): ProtocolLogicRef
        fun createKotlin(type: Class<out ProtocolLogic<*>>, args: Map<String, Any?>): ProtocolLogicRef
        fun toProtocolLogic(ref: ProtocolLogicRef): ProtocolLogic<*>
      interface ProtocolRef
      data class ProtocolRequiringAttention
        Module Contents ProtocolRequiringAttention(ref: ProtocolInstanceRef, prompt: String, choiceIdsToMessages: Map<SecureHash, String>, dueBy: Instant)
        val choiceIdsToMessages: Map<SecureHash, String>
        val dueBy: Instant
        val prompt: String
        val ref: ProtocolInstanceRef
      interface ProtocolStateMachine<R>
        Module Contents abstract val logger: <ERROR CLASS>
        abstract fun <T : Any> receive(topic: String, sessionIDForReceive: Long, recvType: Class<T>): UntrustworthyData<T>
        abstract fun send(topic: String, destination: Party, sessionID: Long, payload: Any): Unit
        abstract fun <T : Any> sendAndReceive(topic: String, destination: Party, sessionIDForSend: Long, sessionIDForReceive: Long, payload: Any, recvType: Class<T>): UntrustworthyData<T>
        abstract val serviceHub: ServiceHub
      class ProtocolStateMachineImpl<R> : ProtocolStateMachine<R>
        Module Contents ProtocolStateMachineImpl(logic: ProtocolLogic<R>, scheduler: <ERROR CLASS>, loggerName: String)
        val logger: <ERROR CLASS>
        val logic: ProtocolLogic<R>
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, recvType: Class<T>): UntrustworthyData<T>
        val resultFuture: <ERROR CLASS><R>
        fun run(): R
        fun send(topic: String, destination: Party, sessionID: Long, payload: Any): Unit
        fun <T : Any> sendAndReceive(topic: String, destination: Party, sessionIDForSend: Long, sessionIDForReceive: Long, payload: Any, recvType: Class<T>): UntrustworthyData<T>
        lateinit var serviceHub: ServiceHubInternal
      open class Rate
        Module Contents Rate(ratioUnit: RatioUnit? = null)
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val ratioUnit: RatioUnit?
        open fun toString(): String
      abstract class RatePaymentEvent : PaymentEvent
        Module Contents RatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount<Currency>, rate: Rate)
        val CSVHeader: String
        val accrualEndDate: LocalDate
        val accrualStartDate: LocalDate
        open fun asCSV(): String
        open fun calculate(): Amount<Currency>
        val dayCountBasisDay: DayCountBasisDay
        val dayCountBasisYear: DayCountBasisYear
        val dayCountFactor: BigDecimal
        val days: Int
        open fun equals(other: Any?): Boolean
        abstract val flow: Amount<Currency>
        open fun hashCode(): Int
        val notional: Amount<Currency>
        val rate: Rate
      open class RatesFixProtocol : ProtocolLogic<Unit>
        Module Contents RatesFixProtocol(tx: TransactionBuilder, oracle: Party, fixOf: FixOf, expectedRate: BigDecimal, rateTolerance: BigDecimal, timeOut: Duration, progressTracker: ProgressTracker = RatesFixProtocol.tracker(fixOf.name))
        class FixOutOfRange : Exception
          Module Contents FixOutOfRange(byAmount: BigDecimal)
          val byAmount: BigDecimal
        class QUERYING : Step
          Module Contents QUERYING(name: String)
          val name: String
        data class QueryRequest : PartyRequestMessage
          Module Contents QueryRequest(queries: List<FixOf>, replyToParty: Party, sessionID: Long, deadline: Instant)
          val deadline: Instant
          val queries: List<FixOf>
          val replyToParty: Party
          val sessionID: Long
        object SIGNING : Step
        data class SignRequest : PartyRequestMessage
          Module Contents SignRequest(tx: WireTransaction, replyToParty: Party, sessionID: Long)
          val replyToParty: Party
          val sessionID: Long
          val tx: WireTransaction
        val TOPIC: String
        object WORKING : Step
        protected open fun beforeSigning(fix: Fix): Unit
        open fun call(): Unit
        open val progressTracker: ProgressTracker
        protected open val topic: String
        fun tracker(fixName: String): ProgressTracker
        protected val tx: TransactionBuilder
      open class RatioUnit
        Module Contents RatioUnit(value: BigDecimal)
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        open fun toString(): String
        val value: BigDecimal
      interface ReadOnlyTransactionStorage
        Module Contents abstract fun getTransaction(id: SecureHash): SignedTransaction?
      class ReferenceRate : FloatingRate
        Module Contents ReferenceRate(oracle: String, tenor: Tenor, name: String)
        val name: String
        val oracle: String
        val tenor: Tenor
        fun toString(): String
      object ReferencesAwareJavaSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<Any>): Any
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: Any): Unit
      interface RegulatorService
        Module Contents object Type : ServiceType
      class Requirements
        Module Contents Requirements()
        infix fun String.by(expr: Boolean): Unit
      class ResolveTransactionsProtocol : ProtocolLogic<List<LedgerTransaction>>
        Module Contents ResolveTransactionsProtocol(stx: SignedTransaction, otherSide: Party)
        ResolveTransactionsProtocol(wtx: WireTransaction, otherSide: Party)
        ResolveTransactionsProtocol(txHashes: Set<SecureHash>, otherSide: Party)
        class ExcessivelyLargeTransactionGraph : Exception
          Module Contents ExcessivelyLargeTransactionGraph()
        fun call(): List<LedgerTransaction>
        protected val topic: String
      class ResponseFilter
        Module Contents ResponseFilter()
        fun filter(requestContext: <ERROR CLASS>, responseContext: <ERROR CLASS>): Unit
      abstract class RetryableException : Exception
        Module Contents RetryableException(message: String)
      enum class Role
        Module Contents BUYER
        SELLER
      interface SchedulableState : ContractState
        Module Contents abstract fun nextScheduledActivity(thisStateRef: StateRef, protocolLogicRefFactory: ProtocolLogicRefFactory): ScheduledActivity?
      interface Scheduled
        Module Contents abstract val scheduledAt: Instant
      data class ScheduledActivity : Scheduled
        Module Contents ScheduledActivity(logicRef: ProtocolLogicRef, scheduledAt: Instant)
        val logicRef: ProtocolLogicRef
        val scheduledAt: Instant
      class ScheduledActivityObserver
        Module Contents ScheduledActivityObserver(services: ServiceHubInternal)
        val services: ServiceHubInternal
      data class ScheduledStateRef : Scheduled
        Module Contents ScheduledStateRef(ref: StateRef, scheduledAt: Instant)
        val ref: StateRef
        val scheduledAt: Instant
      interface SchedulerService
        Module Contents abstract fun scheduleStateActivity(action: ScheduledStateRef): Unit
        abstract fun unscheduleStateActivity(ref: StateRef): Unit
      sealed class SecureHash : OpaqueBytes
        Module Contents class SHA256 : SecureHash
          Module Contents SHA256(bits: ByteArray)
          val signatureAlgorithmName: String
        fun parse(str: String): <ERROR CLASS>
        fun prefixChars(prefixLen: Int = 6): <ERROR CLASS>
        fun randomSHA256(): SHA256
        fun sha256(bits: ByteArray): SHA256
        fun sha256(str: String): <ERROR CLASS>
        fun sha256Twice(bits: ByteArray): SHA256
        abstract val signatureAlgorithmName: String
        open fun toString(): <ERROR CLASS>
      interface SerializationToken
        Module Contents abstract fun fromToken(context: SerializeAsTokenContext): Any
      interface SerializeAsToken
        Module Contents abstract fun toToken(context: SerializeAsTokenContext): SerializationToken
      class SerializeAsTokenContext
        Module Contents SerializeAsTokenContext(toBeTokenized: Any, kryo: <ERROR CLASS> = createKryo())
      class SerializeAsTokenSerializer<T : SerializeAsToken>
        Module Contents SerializeAsTokenSerializer()
        fun clearContext(kryo: <ERROR CLASS>): Unit
        fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<T>): T
        fun setContext(kryo: <ERROR CLASS>, context: SerializeAsTokenContext): Unit
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit
      class SerializedBytes<T : Any> : OpaqueBytes
        Module Contents SerializedBytes(bits: ByteArray)
        val hash: SecureHash
        fun writeToFile(path: Path): Path
      object SerializedBytesSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<SerializedBytes<Any>>): SerializedBytes<Any>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: SerializedBytes<Any>): Unit
      interface ServiceHub
        Module Contents abstract val clock: Clock
        abstract val identityService: IdentityService
        abstract fun <T : Any> invokeProtocolAsync(logicType: Class<out ProtocolLogic<T>>, vararg args: Any?): <ERROR CLASS><T>
        abstract val keyManagementService: KeyManagementService
        open fun loadState(stateRef: StateRef): TransactionState<*>
        abstract val networkMapCache: NetworkMapCache
        abstract val networkService: MessagingService
        abstract fun recordTransactions(txs: Iterable<SignedTransaction>): Unit
        open fun recordTransactions(vararg txs: SignedTransaction): <ERROR CLASS>
        abstract val schedulerService: SchedulerService
        abstract val storageService: StorageService
        abstract val walletService: WalletService
      abstract class ServiceHubInternal : ServiceHub
        Module Contents ServiceHubInternal()
        open fun <T : Any> invokeProtocolAsync(logicType: Class<out ProtocolLogic<T>>, vararg args: Any?): <ERROR CLASS><T>
        abstract val monitoringService: MonitoringService
        abstract val networkService: MessagingServiceInternal
        abstract val protocolLogicRefFactory: ProtocolLogicRefFactory
        abstract fun <T> startProtocol(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
      interface ServiceRequestMessage
        Module Contents abstract fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
        abstract val sessionID: Long
      abstract class ServiceType
        Module Contents ServiceType(id: String)
        open operator fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val id: String
        fun isSubTypeOf(superType: ServiceType): Boolean
        open fun toString(): String
      open class SignedData<T : Any>
        Module Contents SignedData(raw: SerializedBytes<T>, sig: WithKey)
        val raw: SerializedBytes<T>
        val sig: WithKey
        fun verified(): T
        protected open fun verifyData(data: T): Unit
      data class SignedTransaction : NamedByHash
        Module Contents SignedTransaction(txBits: SerializedBytes<WireTransaction>, sigs: List<WithKey>)
        val id: SecureHash
        operator fun plus(sig: WithKey): SignedTransaction
        operator fun plus(sigList: Collection<WithKey>): SignedTransaction
        val sigs: List<WithKey>
        val tx: WireTransaction
        val txBits: SerializedBytes<WireTransaction>
        fun verifySignatures(throwIfSignaturesAreMissing: Boolean = true): Set<PublicKey>
        fun withAdditionalSignature(sig: WithKey): SignedTransaction
        fun withAdditionalSignatures(sigList: Iterable<WithKey>): SignedTransaction
      class SimpleNotaryService : NotaryService
        Module Contents SimpleNotaryService(smm: StateMachineManager, net: MessagingService, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider, networkMapCache: NetworkMapCache)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: DefaultFactory
      abstract class Simulation
        Module Contents Simulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: LatencyCalculator?)
        inner class BankFactory : Factory
          Module Contents BankFactory()
          var counter: Int
          fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
          fun createAll(): List<SimulatedNode>
        object NetworkMapNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        object NotaryNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        object RatesOracleFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        object RegulatorFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        open class SimulatedNode : MockNode
          Module Contents SimulatedNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?)
          open fun findMyLocation(): PhysicalLocation?
        val allProtocolSteps: <ERROR CLASS><<ERROR CLASS><SimulatedNode, Change>>
        val bankFactory: BankFactory
        val bankLocations: <ERROR CLASS>
        val banks: List<SimulatedNode>
        val clocks: <ERROR CLASS>
        var currentDateAndTime: LocalDateTime
        val dateChanges: <ERROR CLASS><LocalDateTime>
        val doneSteps: <ERROR CLASS><Collection<SimulatedNode>>
        val extraNodeLabels: MutableMap<SimulatedNode, String>
        open fun iterate(): MessageTransfer?
        val network: MockNetwork
        val networkInitialisationFinished: <ERROR CLASS><out <ERROR CLASS>>
        val networkMap: SimulatedNode
        val networkSendManuallyPumped: Boolean
        val notary: SimulatedNode
        val ratesOracle: SimulatedNode
        val regulators: List<SimulatedNode>
        val serviceProviders: List<SimulatedNode>
        protected fun showConsensusFor(nodes: List<SimulatedNode>): Unit
        protected fun showProgressFor(nodes: List<SimulatedNode>): Unit
        fun start(): <ERROR CLASS><Unit>
        protected open fun startMainSimulation(): <ERROR CLASS><Unit>
        fun startTradingCircle(tradeBetween: (Int, Int) -> <ERROR CLASS><out <ERROR CLASS>>): Unit
        fun stop(): Unit
      interface SingleClause : Clause, SingleVerify
      interface SingleMessageRecipient : MessageRecipients
      interface SingleVerify
        Module Contents abstract fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
      data class SingletonSerializationToken : SerializationToken
        Module Contents SingletonSerializationToken(toBeTokenized: SerializeAsToken)
        fun fromToken(context: SerializeAsTokenContext): Any
        fun registerWithContext(token: SingletonSerializationToken, toBeTokenized: SerializeAsToken, context: SerializeAsTokenContext): SerializationToken
      abstract class SingletonSerializeAsToken : SerializeAsToken
        Module Contents SingletonSerializeAsToken()
        open fun toToken(context: SerializeAsTokenContext): SerializationToken
      class SplineFunction
        Module Contents SplineFunction(segmentMap: TreeMap<Double, Polynomial>)
        fun getValue(x: Double): Double
      class StackSnapshot : Throwable
        Module Contents StackSnapshot()
      data class StateAndRef<out T : ContractState>
        Module Contents StateAndRef(state: TransactionState<T>, ref: StateRef)
        val ref: StateRef
        val state: TransactionState<T>
      class StateMachineManager
        Module Contents StateMachineManager(serviceHub: ServiceHubInternal, tokenizableServices: List<Any>, checkpointStorage: CheckpointStorage, executor: AffinityExecutor)
        inner class FiberScheduler
          Module Contents FiberScheduler()
        fun <T> add(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
        val allStateMachines: List<ProtocolLogic<*>>
        val changes: <ERROR CLASS><<ERROR CLASS><ProtocolLogic<*>, AddOrRemove, Long>>
        val checkpointStorage: CheckpointStorage
        val executor: AffinityExecutor
        fun <P : ProtocolLogic<T>, T> findStateMachines(protocolClass: Class<P>): List<<ERROR CLASS><P, <ERROR CLASS><T>>>
        val scheduler: FiberScheduler
        val serviceHub: ServiceHubInternal
        fun start(): Unit
      data class StateRef
        Module Contents StateRef(txhash: SecureHash, index: Int)
        val index: Int
        fun toString(): String
        val txhash: SecureHash
      class StateReplacementException : Exception
        Module Contents StateReplacementException(error: StateReplacementRefused)
        val error: StateReplacementRefused
      class StateReplacementRefused
        Module Contents StateReplacementRefused(identity: Party, state: StateRef, detail: String?)
        val detail: String?
        val identity: Party
        val state: StateRef
        fun toString(): String
      interface StatesQuery
        Module Contents interface Criteria
          Module Contents object AllDeals : Criteria
          data class Deal : Criteria
            Module Contents Deal(ref: String)
            val ref: String
        data class Selection : StatesQuery
          Module Contents Selection(criteria: Criteria)
          val criteria: Criteria
        fun select(criteria: Criteria): Selection
      interface StorageService
        Module Contents abstract val attachments: AttachmentStorage
        abstract val myLegalIdentity: Party
        abstract val myLegalIdentityKey: KeyPair
        abstract val validatedTransactions: ReadOnlyTransactionStorage
      open class StorageServiceImpl : SingletonSerializeAsToken, TxWritableStorageService
        Module Contents StorageServiceImpl(attachments: AttachmentStorage, validatedTransactions: TransactionStorage, myLegalIdentityKey: KeyPair, myLegalIdentity: Party = Party("Unit test party", myLegalIdentityKey.public))
        open val attachments: AttachmentStorage
        open val myLegalIdentity: Party
        open val myLegalIdentityKey: KeyPair
        open val validatedTransactions: TransactionStorage
      data class Tenor
        Module Contents Tenor(name: String)
        enum class TimeUnit
          Module Contents Day
          Month
          Week
          Year
          val code: String
        fun daysToMaturity(startDate: LocalDate, calendar: BusinessCalendar): Int
        val name: String
        fun toString(): String
      class TestClock : MutableClock, SerializeAsToken
        Module Contents TestClock(delegateClock: Clock = Clock.systemUTC())
        fun advanceBy(duration: Duration): Unit
        fun getZone(): ZoneId
        fun instant(): Instant
        fun setTo(newInstant: Instant): Unit
        fun toToken(context: SerializeAsTokenContext): SerializationToken
        fun withZone(zone: ZoneId): Clock
      data class TestLedgerDSLInterpreter : LedgerDSLInterpreter<TestTransactionDSLInterpreter>
        Module Contents TestLedgerDSLInterpreter(services: ServiceHub)
        class TypeMismatch : Exception
          Module Contents TypeMismatch(requested: Class<*>, actual: Class<*>)
        class VerifiesFailed : Exception
          Module Contents VerifiesFailed(transactionName: String, cause: Throwable)
        fun _transaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<TestTransactionDSLInterpreter>.() -> EnforceVerifyOrFail): WireTransaction
        fun _unverifiedTransaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<TestTransactionDSLInterpreter>.() -> Unit): WireTransaction
        fun attachment(attachment: InputStream): SecureHash
        fun outputToLabel(state: ContractState): String?
        fun <S : ContractState> retrieveOutputStateAndRef(clazz: Class<S>, label: String): StateAndRef<S>
        val services: ServiceHub
        fun transactionName(transactionHash: SecureHash): String?
        val transactionsToVerify: List<WireTransaction>
        val transactionsUnverified: List<WireTransaction>
        fun tweak(dsl: LedgerDSL<TestTransactionDSLInterpreter, LedgerDSLInterpreter<TestTransactionDSLInterpreter>>.() -> Unit): Unit
        fun verifies(): EnforceVerifyOrFail
        val wireTransactions: List<WireTransaction>
      data class TestTransactionDSLInterpreter : TransactionDSLInterpreter, OutputStateLookup
        Module Contents TestTransactionDSLInterpreter(ledgerInterpreter: TestLedgerDSLInterpreter, transactionBuilder: TransactionBuilder)
        fun _command(signers: List<PublicKey>, commandData: CommandData): Unit
        fun _output(label: String?, notary: Party, contractState: ContractState): Unit
        fun attachment(attachmentId: SecureHash): Unit
        fun input(stateRef: StateRef): Unit
        val ledgerInterpreter: TestLedgerDSLInterpreter
        val services: ServiceHub
        val transactionBuilder: TransactionBuilder
        fun tweak(dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): EnforceVerifyOrFail
        fun verifies(): EnforceVerifyOrFail
      class ThreadBox<out T>
        Module Contents ThreadBox(content: T, lock: ReentrantLock = ReentrantLock())
        inline fun <R> alreadyLocked(body: T.() -> R): R
        val content: T
        val lock: ReentrantLock
        inline fun <R> locked(body: T.() -> R): R
      data class TimeWindow
        Module Contents TimeWindow(start: Instant, duration: Duration)
        val duration: Duration
        val end: Instant
        val start: Instant
      class TimestampChecker
        Module Contents TimestampChecker(clock: Clock = Clock.systemUTC(), tolerance: Duration = 30.seconds)
        val clock: Clock
        fun isValid(timestampCommand: TimestampCommand): Boolean
        val tolerance: Duration
      data class TimestampCommand : CommandData
        Module Contents TimestampCommand(time: Instant, tolerance: Duration)
        TimestampCommand(after: Instant?, before: Instant?)
        val after: Instant?
        val before: Instant?
        val midpoint: Instant
      data class TopicSession
        Module Contents TopicSession(topic: String, sessionID: Long = DEFAULT_SESSION_ID)
        val Blank: TopicSession
        fun isBlank(): Boolean
        val sessionID: Long
        fun toString(): String
        val topic: String
      object TopicStringValidator
        Module Contents fun check(tag: String): <ERROR CLASS>
      class TradeSimulation : Simulation
        Module Contents TradeSimulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        protected fun startMainSimulation(): <ERROR CLASS><Unit>
      data class TransactionBuildStep
        Module Contents TransactionBuildStep(generateMethodName: String, args: Map<String, Any?>)
        val args: Map<String, Any?>
        val generateMethodName: String
      open class TransactionBuilder
        Module Contents TransactionBuilder(type: TransactionType = TransactionType.General(), notary: Party? = null, inputs: MutableList<StateRef> = arrayListOf(), attachments: MutableList<SecureHash> = arrayListOf(), outputs: MutableList<TransactionState<ContractState>> = arrayListOf(), commands: MutableList<Command> = arrayListOf(), signers: MutableSet<PublicKey> = mutableSetOf())
        fun addAttachment(attachmentId: SecureHash): Unit
        fun addCommand(arg: Command): Unit
        fun addCommand(data: CommandData, vararg keys: PublicKey): <ERROR CLASS>
        fun addCommand(data: CommandData, keys: List<PublicKey>): Unit
        open fun addInputState(stateAndRef: StateAndRef<*>): Unit
        fun addInputState(stateRef: StateRef, notary: Party): Unit
        fun addOutputState(state: TransactionState<*>): Int
        fun addOutputState(state: ContractState, notary: Party): Int
        fun addOutputState(state: ContractState): Int
        fun addSignatureUnchecked(sig: WithKey): Unit
        fun attachments(): List<SecureHash>
        protected val attachments: MutableList<SecureHash>
        fun checkAndAddSignature(sig: WithKey): Unit
        fun checkSignature(sig: WithKey): Unit
        fun commands(): List<Command>
        protected val commands: MutableList<Command>
        fun copy(): TransactionBuilder
        protected val currentSigs: <ERROR CLASS>
        fun inputStates(): List<StateRef>
        protected val inputs: MutableList<StateRef>
        protected val notary: Party?
        fun outputStates(): List<TransactionState<*>>
        protected val outputs: MutableList<TransactionState<ContractState>>
        fun setTime(time: Instant, authority: Party, timeTolerance: Duration): Unit
        fun signWith(key: KeyPair): Unit
        protected val signers: MutableSet<PublicKey>
        val time: TimestampCommand?
        fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction
        fun toWireTransaction(): WireTransaction
        protected val type: TransactionType
        fun withItems(vararg items: Any): TransactionBuilder
      class TransactionConflictException : Exception
        Module Contents TransactionConflictException(conflictRef: StateRef, tx1: LedgerTransaction, tx2: LedgerTransaction)
        val conflictRef: StateRef
        val tx1: LedgerTransaction
        val tx2: LedgerTransaction
      class TransactionDSL<out T : TransactionDSLInterpreter> : TransactionDSLInterpreter
        Module Contents TransactionDSL(interpreter: T)
        fun command(vararg signers: PublicKey, commandDataClosure: () -> CommandData): Unit
        fun command(signer: PublicKey, commandData: CommandData): Unit
        fun input(stateLabel: String): <ERROR CLASS>
        fun input(state: ContractState): Unit
        fun input(stateClosure: () -> ContractState): Unit
        val interpreter: T
        fun output(label: String? = null, notary: Party = DUMMY_NOTARY, contractStateClosure: () -> ContractState): Unit
        fun output(label: String, contractState: ContractState): Unit
        fun output(contractState: ContractState): Unit
        fun timestamp(time: Instant, tolerance: Duration = 30.seconds, notary: PublicKey = DUMMY_NOTARY.owningKey): Unit
        fun timestamp(data: TimestampCommand, notary: PublicKey = DUMMY_NOTARY.owningKey): Unit
      interface TransactionDSLInterpreter : Verifies, OutputStateLookup
        Module Contents abstract fun _command(signers: List<PublicKey>, commandData: CommandData): Unit
        abstract fun _output(label: String?, notary: Party, contractState: ContractState): Unit
        abstract fun attachment(attachmentId: SecureHash): Unit
        abstract fun input(stateRef: StateRef): Unit
        abstract val ledgerInterpreter: LedgerDSLInterpreter<TransactionDSLInterpreter>
        abstract fun tweak(dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): EnforceVerifyOrFail
      data class TransactionForContract
        Module Contents TransactionForContract(inputs: List<ContractState>, outputs: List<ContractState>, attachments: List<Attachment>, commands: List<AuthenticatedObject<CommandData>>, origHash: SecureHash, inputNotary: Party? = null)
        data class InOutGroup<out T : ContractState, out K : Any>
          Module Contents InOutGroup(inputs: List<T>, outputs: List<T>, groupingKey: K)
          val groupingKey: K
          val inputs: List<T>
          val outputs: List<T>
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        fun equals(other: Any?): Boolean
        fun getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun getTimestampByName(vararg authorityName: String): TimestampCommand?
        fun <T : ContractState, K : Any> groupStates(ofType: Class<T>, selector: (T) -> K): List<InOutGroup<T, K>>
        inline fun <reified T : ContractState, K : Any> groupStates(selector: (T) -> K): List<InOutGroup<T, K>>
        fun <T : ContractState, K : Any> groupStatesInternal(inGroups: Map<K, List<T>>, outGroups: Map<K, List<T>>): List<InOutGroup<T, K>>
        fun hashCode(): Int
        val inputNotary: Party?
        val inputs: List<ContractState>
        val origHash: SecureHash
        val outputs: List<ContractState>
        val timestamp: TimestampCommand?
      class TransactionGraphSearch : Callable<List<WireTransaction>>
        Module Contents TransactionGraphSearch(transactions: ReadOnlyTransactionStorage, startPoints: List<WireTransaction>)
        class Query
          Module Contents Query(withCommandOfType: Class<out CommandData>? = null)
          val withCommandOfType: Class<out CommandData>?
        fun call(): List<WireTransaction>
        var query: Query
        val startPoints: List<WireTransaction>
        val transactions: ReadOnlyTransactionStorage
      class TransactionResolutionException : Exception
        Module Contents TransactionResolutionException(hash: SecureHash)
        val hash: SecureHash
        fun toString(): String
      data class TransactionState<out T : ContractState>
        Module Contents TransactionState(data: T, notary: Party)
        val data: T
        val notary: Party
        fun withNotary(newNotary: Party): TransactionState<T>
      interface TransactionStorage : ReadOnlyTransactionStorage
        Module Contents abstract fun addTransaction(transaction: SignedTransaction): Unit
      sealed class TransactionType
        Module Contents class General : TransactionType
          Module Contents General()
          class Builder : TransactionBuilder
            Module Contents Builder(notary: Party? = null)
          fun getRequiredSigners(tx: LedgerTransaction): <ERROR CLASS>
          fun verifyTransaction(tx: LedgerTransaction): Unit
        class NotaryChange : TransactionType
          Module Contents NotaryChange()
          class Builder : TransactionBuilder
            Module Contents Builder(notary: Party? = null)
            fun addInputState(stateAndRef: StateAndRef<*>): Unit
          fun getRequiredSigners(tx: LedgerTransaction): <ERROR CLASS>
          fun verifyTransaction(tx: LedgerTransaction): Unit
        open fun equals(other: Any?): Boolean
        abstract fun getRequiredSigners(tx: LedgerTransaction): Set<PublicKey>
        open fun hashCode(): <ERROR CLASS>
        fun verify(tx: LedgerTransaction): Unit
        fun verifySigners(tx: LedgerTransaction): Set<PublicKey>
        abstract fun verifyTransaction(tx: LedgerTransaction): Unit
      sealed class TransactionVerificationException : Exception
        Module Contents class ContractRejection : TransactionVerificationException
          Module Contents ContractRejection(tx: LedgerTransaction, contract: Contract, cause: Throwable?)
          val contract: Contract
        class InvalidNotaryChange : TransactionVerificationException
          Module Contents InvalidNotaryChange(tx: LedgerTransaction)
        class MoreThanOneNotary : TransactionVerificationException
          Module Contents MoreThanOneNotary(tx: LedgerTransaction)
        class SignersMissing : TransactionVerificationException
          Module Contents SignersMissing(tx: LedgerTransaction, missing: List<PublicKey>)
          val missing: List<PublicKey>
          fun toString(): String
        val tx: LedgerTransaction
      class TransientProperty<out T>
        Module Contents TransientProperty(initializer: () -> T)
        operator fun getValue(thisRef: Any?, property: KProperty<*>): T
      object TwoPartyDealProtocol
        Module Contents class Acceptor<T : DealState> : Secondary<T>
          Module Contents Acceptor(otherSide: Party, notary: Party, dealToBuy: T, sessionID: Long, progressTracker: ProgressTracker = Secondary.tracker())
          protected open fun assembleSharedTX(handshake: Handshake<T>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val dealToBuy: T
          val notary: Party
          open val otherSide: Party
          open val progressTracker: ProgressTracker
          open val sessionID: Long
          protected open fun validateHandshake(handshake: Handshake<T>): Handshake<T>
        val DEAL_TOPIC: String
        class DealMismatchException : Exception
          Module Contents DealMismatchException(expectedDeal: ContractState, actualDeal: ContractState)
          val actualDeal: ContractState
          val expectedDeal: ContractState
          fun toString(): String
        class DealRefMismatchException : Exception
          Module Contents DealRefMismatchException(expectedDeal: StateRef, actualDeal: StateRef)
          val actualDeal: StateRef
          val expectedDeal: StateRef
          fun toString(): String
        val FIX_INITIATE_TOPIC: String
        class Fixer : Secondary<StateRef>
          Module Contents Fixer(initiation: FixingSessionInitiation, progressTracker: ProgressTracker = Secondary.tracker())
          protected fun assembleSharedTX(handshake: Handshake<StateRef>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val initiation: FixingSessionInitiation
          val otherSide: Party
          val progressTracker: ProgressTracker
          val sessionID: Long
          protected fun validateHandshake(handshake: Handshake<StateRef>): Handshake<StateRef>
        class FixingRoleDecider : ProtocolLogic<Unit>
          Module Contents FixingRoleDecider(ref: StateRef, timeout: Duration, progressTracker: ProgressTracker = tracker())
          class LOADING : Step
            Module Contents LOADING()
          fun call(): Unit
          val progressTracker: ProgressTracker
          val ref: StateRef
          val timeout: Duration
          protected val topic: String
          fun tracker(): ProgressTracker
        data class FixingSessionInitiation
          Module Contents FixingSessionInitiation(sessionID: Long, party: Party, sender: Party, timeout: Duration)
          val party: Party
          val sender: Party
          val sessionID: Long
          val timeout: Duration
        class Floater : Primary<StateRef>
          Module Contents Floater(payload: StateRef, otherSessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherSessionID: Long
          val otherSide: Party
          val payload: StateRef
          val progressTracker: ProgressTracker
        data class Handshake<out T>
          Module Contents Handshake(payload: T, publicKey: PublicKey, sessionID: Long)
          val payload: T
          val publicKey: PublicKey
          val sessionID: Long
        class Instigator<out T : DealState> : Primary<T>
          Module Contents Instigator(otherSide: Party, notary: Party, payload: T, myKeyPair: KeyPair, otherSessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          open val myKeyPair: KeyPair
          val notary: Party
          open val notaryNode: NodeInfo
          open val otherSessionID: Long
          open val otherSide: Party
          open val payload: T
          open val progressTracker: ProgressTracker
        abstract class Primary<out U> : ProtocolLogic<SignedTransaction>
          Module Contents Primary(progressTracker: ProgressTracker = Primary.tracker())
          object AWAITING_PROPOSAL : Step
          object COPYING_TO_REGULATOR : Step
          object NOTARY : Step
          object RECORDING : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object VERIFYING : Step
          open fun call(): SignedTransaction
          fun getPartialTransaction(): UntrustworthyData<SignedTransaction>
          abstract val myKeyPair: KeyPair
          abstract val notaryNode: NodeInfo
          abstract val otherSessionID: Long
          abstract val otherSide: Party
          abstract val payload: U
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          protected open val topic: String
          fun tracker(): ProgressTracker
          fun verifyPartialTransaction(untrustedPartialTX: UntrustworthyData<SignedTransaction>): SignedTransaction
        abstract class Secondary<U> : ProtocolLogic<SignedTransaction>
          Module Contents Secondary(progressTracker: ProgressTracker = Secondary.tracker())
          object RECEIVING : Step
          object RECORDING : Step
          object SIGNING : Step
          object SWAPPING_SIGNATURES : Step
          object VERIFYING : Step
          protected abstract fun assembleSharedTX(handshake: Handshake<U>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          open fun call(): SignedTransaction
          abstract val otherSide: Party
          open val progressTracker: ProgressTracker
          abstract val sessionID: Long
          protected open val topic: String
          fun tracker(): ProgressTracker
          protected abstract fun validateHandshake(handshake: Handshake<U>): Handshake<U>
        class SignaturesFromPrimary
          Module Contents SignaturesFromPrimary(sellerSig: WithKey, notarySig: LegallyIdentifiable)
          val notarySig: LegallyIdentifiable
          val sellerSig: WithKey
      object TwoPartyTradeProtocol
        Module Contents class AssetMismatchException : Exception
          Module Contents AssetMismatchException(expectedTypeName: String, typeName: String)
          val expectedTypeName: String
          fun toString(): String
          val typeName: String
        class Buyer : ProtocolLogic<SignedTransaction>
          Module Contents Buyer(otherSide: Party, notary: Party, acceptablePrice: Amount<Currency>, typeToBuy: Class<out OwnableState>, sessionID: Long)
          object RECEIVING : Step
          object SIGNING : Step
          object SWAPPING_SIGNATURES : Step
          object VERIFYING : Step
          val acceptablePrice: Amount<Currency>
          open fun call(): SignedTransaction
          val notary: Party
          val otherSide: Party
          open val progressTracker: ProgressTracker
          val sessionID: Long
          protected open val topic: String
          val typeToBuy: Class<out OwnableState>
        class Seller : ProtocolLogic<SignedTransaction>
          Module Contents Seller(otherSide: Party, notaryNode: NodeInfo, assetToSell: StateAndRef<OwnableState>, price: Amount<Currency>, myKeyPair: KeyPair, buyerSessionID: Long, progressTracker: ProgressTracker = Seller.tracker())
          object AWAITING_PROPOSAL : Step
          object NOTARY : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object VERIFYING : Step
          val assetToSell: StateAndRef<OwnableState>
          val buyerSessionID: Long
          open fun call(): SignedTransaction
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherSide: Party
          val price: Amount<Currency>
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          protected open val topic: String
          fun tracker(): ProgressTracker
        class SellerTradeInfo
          Module Contents SellerTradeInfo(assetForSale: StateAndRef<OwnableState>, price: Amount<Currency>, sellerOwnerKey: PublicKey, sessionID: Long)
          val assetForSale: StateAndRef<OwnableState>
          val price: Amount<Currency>
          val sellerOwnerKey: PublicKey
          val sessionID: Long
        class SignaturesFromSeller
          Module Contents SignaturesFromSeller(sellerSig: WithKey, notarySig: LegallyIdentifiable)
          val notarySig: LegallyIdentifiable
          val sellerSig: WithKey
        val TOPIC: String
        class UnacceptablePriceException : Exception
          Module Contents UnacceptablePriceException(givenPrice: Amount<Currency>)
          val givenPrice: Amount<Currency>
      interface TxWritableStorageService : StorageService
        Module Contents abstract val validatedTransactions: TransactionStorage
      abstract class TypeOnlyCommandData : CommandData
        Module Contents TypeOnlyCommandData()
        open fun equals(other: Any?): Boolean
        open fun hashCode(): <ERROR CLASS>
      class UniquenessException : Exception
        Module Contents UniquenessException(error: Conflict)
        val error: Conflict
      interface UniquenessProvider
        Module Contents data class Conflict
          Module Contents Conflict(stateHistory: Map<StateRef, ConsumingTx>)
          val stateHistory: Map<StateRef, ConsumingTx>
        data class ConsumingTx
          Module Contents ConsumingTx(id: SecureHash, inputIndex: Int, requestingParty: Party)
          val id: SecureHash
          val inputIndex: Int
          val requestingParty: Party
        abstract fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party): Unit
      open class UnknownType
        Module Contents UnknownType()
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
      class UntrustworthyData<out T>
        Module Contents UntrustworthyData(fromUntrustedWorld: T)
        val data: T
        inline fun <R> validate(validator: (T) -> R): R
      object UpdateBusinessDayProtocol
        Module Contents class Broadcast : ProtocolLogic<Unit>
          Module Contents Broadcast(date: LocalDate, progressTracker: ProgressTracker = Broadcast.tracker())
          object NOTIFYING : Step
          fun call(): Unit
          val date: LocalDate
          val progressTracker: ProgressTracker
          protected val topic: String
          fun tracker(): ProgressTracker
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service
          Module Contents Service(services: ServiceHubInternal)
        val TOPIC: String
        data class UpdateBusinessDayMessage
          Module Contents UpdateBusinessDayMessage(date: LocalDate)
          val date: LocalDate
      class ValidatingNotaryProtocol : Service
        Module Contents ValidatingNotaryProtocol(otherSide: Party, sessionIdForSend: Long, sessionIdForReceive: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit
      class ValidatingNotaryService : NotaryService
        Module Contents ValidatingNotaryService(smm: StateMachineManager, net: MessagingService, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider, networkMapCache: NetworkMapCache)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: Factory
      interface Verifies
        Module Contents open fun fails(): EnforceVerifyOrFail
        open infix fun fails with(msg: String): EnforceVerifyOrFail
        open fun failsWith(expectedMessage: String?): EnforceVerifyOrFail
        abstract fun verifies(): EnforceVerifyOrFail
      class Wallet
        Module Contents Wallet(states: List<StateAndRef<ContractState>>)
        val NoUpdate: Update
        data class Update
          Module Contents Update(consumed: Set<StateRef>, produced: Set<StateAndRef<ContractState>>)
          val consumed: Set<StateRef>
          operator fun plus(rhs: Update): Update
          val produced: Set<StateAndRef<ContractState>>
        val states: List<StateAndRef<ContractState>>
        inline fun <reified T : OwnableState> statesOfType(): List<StateAndRef<T>>
      interface WalletService
        Module Contents abstract val currentWallet: Wallet
        abstract val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        open fun <T : LinearState> linearHeadsOfType_(stateType: Class<T>): Map<SecureHash, StateAndRef<T>>
        open fun notify(tx: WireTransaction): Wallet
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Wallet
        open fun statesForRefs(refs: List<StateRef>): Map<StateRef, TransactionState<*>?>
        abstract val updates: <ERROR CLASS><Update>
        open fun whenConsumed(ref: StateRef): <ERROR CLASS><Update>
      class WhitelistTrustManager : X509ExtendedTrustManager
        Module Contents WhitelistTrustManager(originalProvider: X509ExtendedTrustManager)
        fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String, socket: Socket?): Unit
        fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String, engine: SSLEngine?): Unit
        fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String): Unit
        fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String, socket: Socket?): Unit
        fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String, engine: SSLEngine?): Unit
        fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String): Unit
        val checker: HostnameChecker
        fun getAcceptedIssuers(): Array<out X509Certificate>
        val originalProvider: X509ExtendedTrustManager
      object WhitelistTrustManagerProvider : Provider
        Module Contents fun addWhitelistEntries(serverNames: List<String>): Unit
        fun addWhitelistEntry(serverName: String): Unit
        val originalTrustProviderAlgorithm: String
        fun register(): Unit
        val whitelist: Set<String>
      class WhitelistTrustManagerSpi : TrustManagerFactorySpi
        Module Contents WhitelistTrustManagerSpi()
        protected fun engineGetTrustManagers(): Array<out TrustManager>
        protected fun engineInit(keyStore: KeyStore?): Unit
        protected fun engineInit(managerFactoryParameters: ManagerFactoryParameters?): Unit
        val originalProvider: TrustManagerFactory
      class WireNodeRegistration : SignedData<NodeRegistration>
        Module Contents WireNodeRegistration(raw: SerializedBytes<NodeRegistration>, sig: WithKey)
        protected fun verifyData(data: NodeRegistration): Unit
      data class WireTransaction : NamedByHash
        Module Contents WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<TransactionState<ContractState>>, commands: List<Command>, signers: List<PublicKey>, type: TransactionType)
        val attachments: List<SecureHash>
        val commands: List<Command>
        fun deserialize(bits: SerializedBytes<WireTransaction>, kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun <T : ContractState> outRef(state: ContractState): StateAndRef<T>
        val outputs: List<TransactionState<ContractState>>
        val serialized: SerializedBytes<WireTransaction>
        val signers: List<PublicKey>
        fun toString(): String
        val type: TransactionType
      object WireTransactionSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<WireTransaction>): WireTransaction
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: WireTransaction): Unit
      data class WorldCoordinate
        Module Contents WorldCoordinate(latitude: Double, longitude: Double)
        val latitude: Double
        val longitude: Double
        fun project(screenWidth: Double, screenHeight: Double, topLatitude: Double, bottomLatitude: Double, leftLongitude: Double, rightLongitude: Double): <ERROR CLASS><Double, Double>
      object X509Utilities
        Module Contents data class CACertAndKey
          Module Contents CACertAndKey(certificate: X509Certificate, keypair: KeyPair)
          val certificate: X509Certificate
          val keypair: KeyPair
        val CA_CERT_ALIAS: String
        val CERT_PRIVATE_KEY_ALIAS: String
        val ECDSA_CURVE: String
        val INTERMEDIATE_CA_PRIVATE_KEY_ALIAS: String
        val KEYSTORE_TYPE: String
        val KEY_GENERATION_ALGORITHM: String
        val ROOT_CA_CERT_PRIVATE_KEY_ALIAS: String
        val SIGNATURE_ALGORITHM: String
        fun createCAKeyStoreAndTrustStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, trustStoreFilePath: Path, trustStorePassword: String): KeyStore
        fun createIntermediateCert(domain: String, certificateAuthority: CACertAndKey): CACertAndKey
        fun createKeystoreForSSL(keyStoreFilePath: Path, storePassword: String, keyPassword: String, caKeyStore: KeyStore, caKeyPassword: String): KeyStore
        fun createSelfSignedCACert(domain: String): CACertAndKey
        fun createServerCert(subject: <ERROR CLASS>, publicKey: PublicKey, certificateAuthority: CACertAndKey, subjectAlternativeNameDomains: List<String>, subjectAlternativeNameIps: List<String>): X509Certificate
        fun generateECDSAKeyPairForSSL(): KeyPair
        fun getDevX509Name(domain: String): <ERROR CLASS>
        fun loadCertificateAndKey(keyStore: KeyStore, keyPassword: String, alias: String): CACertAndKey
        fun loadCertificateFromKeyStore(keyStoreFilePath: Path, storePassword: String, alias: String): X509Certificate
        fun loadCertificateFromPEMFile(filename: Path): X509Certificate
        fun loadKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String): KeyPair
        fun loadKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
        fun loadKeyStore(input: InputStream, storePassword: String): KeyStore
        fun loadOrCreateKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
        fun saveCertificateAsPEMFile(x509Certificate: X509Certificate, filename: Path): Unit
        fun saveKeyStore(keyStore: KeyStore, keyStoreFilePath: Path, storePassword: String): Unit
      java.nio.file.Path
        Module Contents fun <R> Path.use(block: (InputStream) -> R): R
      java.security.KeyPair
        Module Contents operator fun KeyPair.component1(): PrivateKey
        operator fun KeyPair.component2(): PublicKey
        fun KeyPair.signWithECDSA(bitsToSign: ByteArray): WithKey
        fun KeyPair.signWithECDSA(bitsToSign: OpaqueBytes): WithKey
        fun KeyPair.signWithECDSA(bitsToSign: OpaqueBytes, party: Party): LegallyIdentifiable
        fun KeyPair.signWithECDSA(bitsToSign: ByteArray, party: Party): LegallyIdentifiable
      java.security.PrivateKey
        Module Contents fun PrivateKey.signWithECDSA(bits: ByteArray): DigitalSignature
        fun PrivateKey.signWithECDSA(bitsToSign: ByteArray, publicKey: PublicKey): WithKey
      java.security.PublicKey
        Module Contents fun PublicKey.toBase58String(): <ERROR CLASS>
        fun PublicKey.toStringShort(): String
        fun PublicKey.verifyWithECDSA(content: ByteArray, signature: DigitalSignature): Unit
      java.time.Clock
        Module Contents fun Clock.awaitWithDeadline(deadline: Instant, future: Future<*> = SettableFuture<Any>()): Boolean
      java.time.LocalDate
        Module Contents fun LocalDate.isWorkingDay(accordingToCalendar: BusinessCalendar): Boolean
      java.time.temporal.Temporal
        Module Contents infix fun Temporal.until(endExclusive: Temporal): Duration
      java.util.Currency
        Module Contents infix fun Currency.issued by(deposit: PartyAndReference): Issued<Currency>
        infix fun Currency.issuedBy(deposit: PartyAndReference): Issued<Currency>
      kotlin.ByteArray
        Module Contents fun ByteArray.sha256(): SHA256
      kotlin.ByteArray
        Module Contents fun <T : Any> ByteArray.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T
        fun ByteArray.opaque(): OpaqueBytes
      kotlin.Double
        Module Contents val Double.DOLLARS: Amount<Currency>
      kotlin.Double
        Module Contents val Double.bd: BigDecimal
      kotlin.Int
        Module Contents val Int.DOLLARS: Amount<Currency>
        val Int.FCOJ: Amount<Commodity>
        val Int.POUNDS: Amount<Currency>
        val Int.SWISS_FRANCS: Amount<Currency>
      kotlin.Int
        Module Contents val Int.bd: BigDecimal
        infix fun Int.checkedAdd(b: Int): Int
        val Int.days: Duration
        val Int.hours: Duration
        val Int.minutes: Duration
        val Int.seconds: Duration
      kotlin.Int
        Module Contents operator fun Int.times(other: FixedRate): Int
        operator fun Int.times(other: Rate): Int
        operator fun Int.times(other: RatioUnit): Int
      kotlin.Long
        Module Contents val Long.bd: BigDecimal
        infix fun Long.checkedAdd(b: Long): Long
      kotlin.String
        Module Contents fun String.abbreviate(maxWidth: Int): String
        val String.bd: BigDecimal
      kotlin.String
        Module Contents val String.percent: PercentageRatioUnit
      kotlin.collections.Collection
        Module Contents inline fun <reified T : CommandData> Collection<AuthenticatedObject<CommandData>>.requireSingleCommand(): <ERROR CLASS>
        fun <C : CommandData> Collection<AuthenticatedObject<CommandData>>.requireSingleCommand(klass: Class<C>): <ERROR CLASS>
        inline fun <reified T : CommandData> Collection<AuthenticatedObject<CommandData>>.select(signer: PublicKey? = null, party: Party? = null): <ERROR CLASS>
        inline fun <reified T : CommandData> Collection<AuthenticatedObject<CommandData>>.select(signers: Collection<PublicKey>?, parties: Collection<Party>?): <ERROR CLASS>
      kotlin.collections.Iterable
        Module Contents fun <T> Iterable<Amount<T>>.sumOrNull(): Nothing?
        fun <T> Iterable<Amount<T>>.sumOrThrow(): <ERROR CLASS>
        fun <T> Iterable<Amount<T>>.sumOrZero(currency: T): Amount<T>
      kotlin.collections.Iterable
        Module Contents fun Iterable<PublicKey>.toStringsShort(): String
      kotlin.collections.Iterable
        Module Contents fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?
        fun <T> Iterable<T>.noneOrSingle(): T?
      kotlin.collections.Iterable
        Module Contents fun Iterable<ContractState>.sumCash(): Amount<Issued<Currency>>
        fun Iterable<ContractState>.sumCashBy(owner: PublicKey): Amount<Issued<Currency>>
        fun Iterable<ContractState>.sumCashOrNull(): Amount<Issued<Currency>>?
        fun Iterable<ContractState>.sumCashOrZero(currency: Issued<Currency>): Amount<Issued<Currency>>
        fun Iterable<ContractState>.sumCommodities(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCommoditiesOrNull(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCommoditiesOrZero(currency: Issued<Commodity>): <ERROR CLASS>
        fun <T> Iterable<ContractState>.sumFungibleOrNull(): <ERROR CLASS>
        fun <T> Iterable<ContractState>.sumFungibleOrZero(token: Issued<T>): <ERROR CLASS>
        fun <P> Iterable<ContractState>.sumObligations(): Amount<Issued<Terms<P>>>
        fun <P> Iterable<ContractState>.sumObligationsOrNull(): Amount<Issued<Terms<P>>>?
        fun <P> Iterable<ContractState>.sumObligationsOrZero(issuanceDef: Issued<Terms<P>>): Amount<Issued<Terms<P>>>
      kotlin.collections.Iterable
        Module Contents fun Iterable<TestClock>.setTo(instant: Instant): <ERROR CLASS>
      kotlin.collections.List
        Module Contents inline fun <reified T : ContractState> List<StateAndRef<ContractState>>.filterStatesOfType(): List<StateAndRef<T>>
        fun List<AuthenticatedObject<CommandData>>.getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun List<AuthenticatedObject<CommandData>>.getTimestampByName(vararg names: String): TimestampCommand?
      kotlin.collections.List
        Module Contents fun <T> List<T>.indexOfOrThrow(item: T): Int
    package com.r3corda.contracts
      Module Contents val CP_LEGACY_PROGRAM_ID: CommercialPaperLegacy
      val CP_PROGRAM_ID: CommercialPaper
      class CommercialPaper : ClauseVerifier
        Module Contents CommercialPaper()
        interface Clauses
          Module Contents abstract class AbstractGroupClause : GroupClause<State, Issued<Terms>>
            Module Contents AbstractGroupClause()
            open val ifMatched: MatchBehaviour
            open val ifNotMatched: MatchBehaviour
          class Group : GroupClauseVerifier<State, Issued<Terms>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, Issued<Terms>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue : AbstractIssue<State, Terms>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms>): Set<CommandData>
          class Move : AbstractGroupClause
            Module Contents Move()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms>): Set<CommandData>
          class Redeem : AbstractGroupClause
            Module Contents Redeem()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms>): Set<CommandData>
        interface Commands : CommandData
          Module Contents data class Issue : IssueCommand, Commands
            Module Contents Issue(notary: Party, nonce: Long = random63BitValue())
            val nonce: Long
            val notary: Party
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
          data class Redeem : Commands
            Module Contents Redeem(notary: Party)
            val notary: Party
        data class State : OwnableState
          Module Contents State(issuance: PartyAndReference, owner: PublicKey, faceValue: Amount<Issued<Currency>>, maturityDate: Instant)
          val contract: CommercialPaper
          val faceValue: Amount<Issued<Currency>>
          val issuance: PartyAndReference
          val maturityDate: Instant
          val owner: PublicKey
          val participants: List<PublicKey>
          fun toString(): String
          val token: Issued<Terms>
          fun withFaceValue(newFaceValue: Amount<Issued<Currency>>): <ERROR CLASS>
          fun withIssuance(newIssuance: PartyAndReference): <ERROR CLASS>
          fun withMaturityDate(newMaturityDate: Instant): <ERROR CLASS>
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
          fun withOwner(newOwner: PublicKey): <ERROR CLASS>
        data class Terms
          Module Contents Terms(asset: Issued<Currency>, maturityDate: Instant)
          val asset: Issued<Currency>
          val maturityDate: Instant
        val clauses: <ERROR CLASS>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<CommandData>>
        fun generateIssue(issuance: PartyAndReference, faceValue: Amount<Issued<Currency>>, maturityDate: Instant, notary: Party): TransactionBuilder
        fun generateMove(tx: TransactionBuilder, paper: StateAndRef<State>, newOwner: PublicKey): Unit
        fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<State>, wallet: List<StateAndRef<State>>): Unit
        val legalContractReference: SecureHash
      class CommercialPaperLegacy : Contract
        Module Contents CommercialPaperLegacy()
        interface Commands : CommandData
          Module Contents data class Issue : Commands
            Module Contents Issue(notary: Party)
            val notary: Party
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
          data class Redeem : Commands
            Module Contents Redeem(notary: Party)
            val notary: Party
        data class State : OwnableState
          Module Contents State(issuance: PartyAndReference, owner: PublicKey, faceValue: Amount<Issued<Currency>>, maturityDate: Instant)
          val contract: CommercialPaperLegacy
          val faceValue: Amount<Issued<Currency>>
          val issuance: PartyAndReference
          val maturityDate: Instant
          val owner: PublicKey
          val participants: List<PublicKey>
          fun toString(): String
          fun withFaceValue(newFaceValue: Amount<Issued<Currency>>): <ERROR CLASS>
          fun withIssuance(newIssuance: PartyAndReference): <ERROR CLASS>
          fun withMaturityDate(newMaturityDate: Instant): <ERROR CLASS>
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
          fun withOwner(newOwner: PublicKey): <ERROR CLASS>
          fun withoutOwner(): State
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      open class Event
        Module Contents Event(date: LocalDate)
        val date: LocalDate
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
      class FixedRate : Rate
        Module Contents FixedRate(ratioUnit: RatioUnit)
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        fun isPositive(): Boolean
      class FixedRatePaymentEvent : RatePaymentEvent
        Module Contents FixedRatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount<Currency>, rate: Rate)
        val CSVHeader: String
        val flow: Amount<Currency>
        fun toString(): String
      open class FloatingRate : Rate
        Module Contents FloatingRate()
      class FloatingRatePaymentEvent : RatePaymentEvent
        Module Contents FloatingRatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, fixingDate: LocalDate, notional: Amount<Currency>, rate: Rate)
        val CSVHeader: String
        fun asCSV(): String
        fun copy(date: LocalDate = this.date, accrualStartDate: LocalDate = this.accrualStartDate, accrualEndDate: LocalDate = this.accrualEndDate, dayCountBasisDay: DayCountBasisDay = this.dayCountBasisDay, dayCountBasisYear: DayCountBasisYear = this.dayCountBasisYear, fixingDate: LocalDate = this.fixingDate, notional: Amount<Currency> = this.notional, rate: Rate = this.rate): FloatingRatePaymentEvent
        fun equals(other: Any?): Boolean
        val fixingDate: LocalDate
        val flow: Amount<Currency>
        fun hashCode(): Int
        fun toString(): String
        fun withNewRate(newRate: Rate): FloatingRatePaymentEvent
      val IRS_PROGRAM_ID: InterestRateSwap
      class InterestRateSwap : ClauseVerifier
        Module Contents InterestRateSwap()
        data class Calculation
          Module Contents Calculation(expression: Expression, floatingLegPaymentSchedule: Map<LocalDate, FloatingRatePaymentEvent>, fixedLegPaymentSchedule: Map<LocalDate, FixedRatePaymentEvent>)
          fun applyFixing(date: LocalDate, newRate: FixedRate): Calculation
          val expression: Expression
          val fixedLegPaymentSchedule: Map<LocalDate, FixedRatePaymentEvent>
          val floatingLegPaymentSchedule: Map<LocalDate, FloatingRatePaymentEvent>
          fun getFixing(date: LocalDate): FloatingRatePaymentEvent
          fun nextFixingDate(): LocalDate?
        interface Clause
          Module Contents abstract class AbstractIRSClause : GroupClause<State, String>
            Module Contents AbstractIRSClause()
            fun checkLegAmounts(legs: Array<CommonLeg>): Unit
            fun checkLegDates(legs: Array<CommonLeg>): Unit
            fun checkRates(legs: Array<CommonLeg>): Boolean
            fun checkSchedules(legs: Array<CommonLeg>): Boolean
            fun getFloatingLegPaymentsDifferences(payments1: Map<LocalDate, Event>, payments2: Map<LocalDate, Event>): List<<ERROR CLASS><LocalDate, <ERROR CLASS><FloatingRatePaymentEvent, FloatingRatePaymentEvent>>>
            open val ifMatched: MatchBehaviour
            open val ifNotMatched: MatchBehaviour
          class Agree : AbstractIRSClause
            Module Contents Agree()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Fix : AbstractIRSClause
            Module Contents Fix()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Group : GroupClauseVerifier<State, String>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, String>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Mature : AbstractIRSClause
            Module Contents Mature()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Pay : AbstractIRSClause
            Module Contents Pay()
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: Collection<AuthenticatedObject<CommandData>>, token: String): Set<CommandData>
          class Timestamped : SingleClause
            Module Contents Timestamped()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
        interface Commands : CommandData
          Module Contents class Agree : TypeOnlyCommandData, Commands
            Module Contents Agree()
          class Mature : TypeOnlyCommandData, Commands
            Module Contents Mature()
          class Pay : TypeOnlyCommandData, Commands
            Module Contents Pay()
          data class Refix : Commands
            Module Contents Refix(fix: Fix)
            val fix: Fix
        data class Common
          Module Contents Common(baseCurrency: Currency, eligibleCurrency: Currency, eligibleCreditSupport: String, independentAmounts: Amount<Currency>, threshold: Amount<Currency>, minimumTransferAmount: Amount<Currency>, rounding: Amount<Currency>, valuationDate: String, notificationTime: String, resolutionTime: String, interestRate: ReferenceRate, addressForTransfers: String, exposure: UnknownType, localBusinessDay: BusinessCalendar, dailyInterestAmount: Expression, tradeID: String, hashLegalDocs: String)
          val addressForTransfers: String
          val baseCurrency: Currency
          val dailyInterestAmount: Expression
          val eligibleCreditSupport: String
          val eligibleCurrency: Currency
          val exposure: UnknownType
          val hashLegalDocs: String
          val independentAmounts: Amount<Currency>
          val interestRate: ReferenceRate
          val localBusinessDay: BusinessCalendar
          val minimumTransferAmount: Amount<Currency>
          val notificationTime: String
          val resolutionTime: String
          val rounding: Amount<Currency>
          val threshold: Amount<Currency>
          val tradeID: String
          val valuationDate: String
        abstract class CommonLeg
          Module Contents CommonLeg(notional: Amount<Currency>, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment)
          val dayCountBasisDay: DayCountBasisDay
          val dayCountBasisYear: DayCountBasisYear
          val dayInMonth: Int
          val effectiveDate: LocalDate
          val effectiveDateAdjustment: DateRollConvention?
          open fun equals(other: Any?): Boolean
          open fun hashCode(): Int
          val interestPeriodAdjustment: AccrualAdjustment
          val notional: Amount<Currency>
          val paymentCalendar: BusinessCalendar
          val paymentDelay: Int
          val paymentFrequency: Frequency
          val paymentRule: PaymentRule
          val terminationDate: LocalDate
          val terminationDateAdjustment: DateRollConvention?
          open fun toString(): String
        class FixedLeg : CommonLeg
          Module Contents FixedLeg(fixedRatePayer: Party, notional: Amount<Currency>, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment, fixedRate: FixedRate, rollConvention: DateRollConvention)
          fun copy(fixedRatePayer: Party = this.fixedRatePayer, notional: Amount<Currency> = this.notional, paymentFrequency: Frequency = this.paymentFrequency, effectiveDate: LocalDate = this.effectiveDate, effectiveDateAdjustment: DateRollConvention? = this.effectiveDateAdjustment, terminationDate: LocalDate = this.terminationDate, terminationDateAdjustment: DateRollConvention? = this.terminationDateAdjustment, dayCountBasisDay: DayCountBasisDay = this.dayCountBasisDay, dayCountBasisYear: DayCountBasisYear = this.dayCountBasisYear, dayInMonth: Int = this.dayInMonth, paymentRule: PaymentRule = this.paymentRule, paymentDelay: Int = this.paymentDelay, paymentCalendar: BusinessCalendar = this.paymentCalendar, interestPeriodAdjustment: AccrualAdjustment = this.interestPeriodAdjustment, fixedRate: FixedRate = this.fixedRate): FixedLeg
          open fun equals(other: Any?): Boolean
          var fixedRate: FixedRate
          var fixedRatePayer: Party
          open fun hashCode(): Int
          var rollConvention: DateRollConvention
          open fun toString(): String
        class FloatingLeg : CommonLeg
          Module Contents FloatingLeg(floatingRatePayer: Party, notional: Amount<Currency>, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment, rollConvention: DateRollConvention, fixingRollConvention: DateRollConvention, resetDayInMonth: Int, fixingPeriodOffset: Int, resetRule: PaymentRule, fixingsPerPayment: Frequency, fixingCalendar: BusinessCalendar, index: String, indexSource: String, indexTenor: Tenor)
          fun copy(floatingRatePayer: Party = this.floatingRatePayer, notional: Amount<Currency> = this.notional, paymentFrequency: Frequency = this.paymentFrequency, effectiveDate: LocalDate = this.effectiveDate, effectiveDateAdjustment: DateRollConvention? = this.effectiveDateAdjustment, terminationDate: LocalDate = this.terminationDate, terminationDateAdjustment: DateRollConvention? = this.terminationDateAdjustment, dayCountBasisDay: DayCountBasisDay = this.dayCountBasisDay, dayCountBasisYear: DayCountBasisYear = this.dayCountBasisYear, dayInMonth: Int = this.dayInMonth, paymentRule: PaymentRule = this.paymentRule, paymentDelay: Int = this.paymentDelay, paymentCalendar: BusinessCalendar = this.paymentCalendar, interestPeriodAdjustment: AccrualAdjustment = this.interestPeriodAdjustment, rollConvention: DateRollConvention = this.rollConvention, fixingRollConvention: DateRollConvention = this.fixingRollConvention, resetDayInMonth: Int = this.resetDayInMonth, fixingPeriod: Int = this.fixingPeriodOffset, resetRule: PaymentRule = this.resetRule, fixingsPerPayment: Frequency = this.fixingsPerPayment, fixingCalendar: BusinessCalendar = this.fixingCalendar, index: String = this.index, indexSource: String = this.indexSource, indexTenor: Tenor = this.indexTenor): FloatingLeg
          open fun equals(other: Any?): Boolean
          var fixingCalendar: BusinessCalendar
          var fixingPeriodOffset: Int
          var fixingRollConvention: DateRollConvention
          var fixingsPerPayment: Frequency
          var floatingRatePayer: Party
          open fun hashCode(): Int
          var index: String
          var indexSource: String
          var indexTenor: Tenor
          var resetDayInMonth: Int
          var resetRule: PaymentRule
          var rollConvention: DateRollConvention
          open fun toString(): String
        data class State : FixableDealState, SchedulableState
          Module Contents State(fixedLeg: FixedLeg, floatingLeg: FloatingLeg, calculation: Calculation, common: Common)
          val calculation: Calculation
          val common: Common
          val contract: InterestRateSwap
          fun evaluateCalculation(businessDate: LocalDate, expression: Expression = calculation.expression): Any
          val fixedLeg: FixedLeg
          val floatingLeg: FloatingLeg
          fun generateAgreement(notary: Party): TransactionBuilder
          fun generateFix(ptx: TransactionBuilder, oldState: StateAndRef<*>, fix: Fix): Unit
          fun isRelevant(ourKeys: Set<PublicKey>): Boolean
          fun nextFixingOf(): FixOf?
          fun nextScheduledActivity(thisStateRef: StateRef, protocolLogicRefFactory: ProtocolLogicRefFactory): ScheduledActivity?
          val participants: List<PublicKey>
          val parties: Array<Party>
          fun prettyPrint(): <ERROR CLASS>
          val ref: String
          val thread: <ERROR CLASS>
          fun withPublicKey(before: Party, after: PublicKey): DealState
        val clauses: List<SingleClause>
        fun extractCommands(tx: TransactionForContract): Collection<AuthenticatedObject<CommandData>>
        fun generateAgreement(floatingLeg: FloatingLeg, fixedLeg: FixedLeg, calculation: Calculation, common: Common, notary: Party): TransactionBuilder
        fun generateFix(tx: TransactionBuilder, irs: StateAndRef<State>, fixing: Fix): Unit
        val legalContractReference: <ERROR CLASS>
      abstract class PaymentEvent : Event
        Module Contents PaymentEvent(date: LocalDate)
        abstract fun calculate(): Amount<Currency>
      open class PercentageRatioUnit : RatioUnit
        Module Contents PercentageRatioUnit(percentageAsString: String)
        open fun toString(): <ERROR CLASS>
      open class Rate
        Module Contents Rate(ratioUnit: RatioUnit? = null)
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val ratioUnit: RatioUnit?
        open fun toString(): String
      abstract class RatePaymentEvent : PaymentEvent
        Module Contents RatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount<Currency>, rate: Rate)
        val CSVHeader: String
        val accrualEndDate: LocalDate
        val accrualStartDate: LocalDate
        open fun asCSV(): String
        open fun calculate(): Amount<Currency>
        val dayCountBasisDay: DayCountBasisDay
        val dayCountBasisYear: DayCountBasisYear
        val dayCountFactor: BigDecimal
        val days: Int
        open fun equals(other: Any?): Boolean
        abstract val flow: Amount<Currency>
        open fun hashCode(): Int
        val notional: Amount<Currency>
        val rate: Rate
      open class RatioUnit
        Module Contents RatioUnit(value: BigDecimal)
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        open fun toString(): String
        val value: BigDecimal
      class ReferenceRate : FloatingRate
        Module Contents ReferenceRate(oracle: String, tenor: Tenor, name: String)
        val name: String
        val oracle: String
        val tenor: Tenor
        fun toString(): String
      open class UnknownType
        Module Contents UnknownType()
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
      fun State.exportIRSToCSV(): String
      kotlin.Int
        Module Contents operator fun Int.times(other: FixedRate): Int
        operator fun Int.times(other: Rate): Int
        operator fun Int.times(other: RatioUnit): Int
      kotlin.String
        Module Contents val String.percent: PercentageRatioUnit
      infix fun State.owned by(owner: PublicKey): State
      infix fun <ERROR CLASS>.owned by(newOwner: PublicKey): <ERROR CLASS>
      operator fun Amount<Currency>.times(other: RatioUnit): Amount<Currency>
      infix fun State.with notary(notary: Party): TransactionState<State>
    package com.r3corda.contracts.asset
      Module Contents val Amount<Currency>.CASH: State
      val CASH_PROGRAM_ID: Cash
      val COMMODITY_PROGRAM_ID: CommodityContract
      class Cash : OnLedgerAsset<Currency, State>
        Module Contents Cash()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Currency>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Issued<Currency>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, Issued<Currency>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue : AbstractIssue<State, Currency>
            Module Contents Issue()
            val requiredCommands: <ERROR CLASS>
        interface Commands : Commands
          Module Contents data class Exit : Commands, Exit<Currency>
            Module Contents Exit(amount: Amount<Issued<Currency>>)
            val amount: Amount<Issued<Currency>>
          data class Issue : Issue, Commands
            Module Contents Issue(nonce: Long = newSecureRandom().nextLong())
            val nonce: Long
          data class Move : Move, Commands
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
        data class State : FungibleAsset<Currency>
          Module Contents State(deposit: PartyAndReference, amount: Amount<Currency>, owner: PublicKey)
          State(amount: Amount<Issued<Currency>>, owner: PublicKey)
          val amount: Amount<Issued<Currency>>
          val contract: Cash
          val deposit: PartyAndReference
          val exitKeys: <ERROR CLASS>
          val issuanceDef: Issued<Currency>
          fun move(newAmount: Amount<Issued<Currency>>, newOwner: PublicKey): FungibleAsset<Currency>
          val owner: PublicKey
          val participants: <ERROR CLASS>
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        val clauses: <ERROR CLASS>
        val conserveClause: AbstractConserveAmount<State, Currency>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Currency>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<Commands>>
        fun generateExitCommand(amount: Amount<Issued<Currency>>): Exit
        fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Currency>, pennies: Long, owner: PublicKey, notary: Party): Unit
        fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Currency>>, owner: PublicKey, notary: Party): Unit
        fun generateIssueCommand(): Issue
        fun generateMoveCommand(): Move
        val legalContractReference: SecureHash
      class CommodityContract : OnLedgerAsset<Commodity, State>
        Module Contents CommodityContract()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Commodity>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Issued<Commodity>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State, Issued<Commodity>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue : AbstractIssue<State, Commodity>
            Module Contents Issue()
            val requiredCommands: <ERROR CLASS>
        interface Commands : Commands
          Module Contents data class Exit : Commands, Exit<Commodity>
            Module Contents Exit(amount: Amount<Issued<Commodity>>)
            val amount: Amount<Issued<Commodity>>
          data class Issue : Issue, Commands
            Module Contents Issue(nonce: Long = newSecureRandom().nextLong())
            val nonce: Long
          data class Move : Move, Commands
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
        data class State : FungibleAsset<Commodity>
          Module Contents State(deposit: PartyAndReference, amount: Amount<Commodity>, owner: PublicKey)
          State(amount: Amount<Issued<Commodity>>, owner: PublicKey)
          val amount: Amount<Issued<Commodity>>
          val contract: CommodityContract
          val deposit: PartyAndReference
          val exitKeys: MutableSet<PublicKey>
          val issuanceDef: Issued<Commodity>
          fun move(newAmount: Amount<Issued<Commodity>>, newOwner: PublicKey): FungibleAsset<Commodity>
          val owner: PublicKey
          val participants: <ERROR CLASS>
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        val clauses: <ERROR CLASS>
        val conserveClause: AbstractConserveAmount<State, Commodity>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Commodity>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<Commands>>
        fun generateExitCommand(amount: Amount<Issued<Commodity>>): Exit
        fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Commodity>, pennies: Long, owner: PublicKey, notary: Party): Unit
        fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Commodity>>, owner: PublicKey, notary: Party): Unit
        fun generateIssueCommand(): Issue
        fun generateMoveCommand(): Move
        val legalContractReference: SecureHash
      val DUMMY_CASH_ISSUER: <ERROR CLASS>
      val DUMMY_CASH_ISSUER_KEY: <ERROR CLASS>
      interface FungibleAsset<T> : OwnableState
        Module Contents interface Commands : CommandData
          Module Contents interface Exit<T> : Commands
            Module Contents abstract val amount: Amount<Issued<T>>
          interface Issue : IssueCommand, Commands
          interface Move : MoveCommand, Commands
        abstract val amount: Amount<Issued<T>>
        abstract val deposit: PartyAndReference
        abstract val exitKeys: Collection<PublicKey>
        abstract val issuanceDef: Issued<T>
        abstract fun move(newAmount: Amount<Issued<T>>, newOwner: PublicKey): FungibleAsset<T>
        abstract val owner: PublicKey
      class InsufficientBalanceException : Exception
        Module Contents InsufficientBalanceException(amountMissing: Amount<*>)
        val amountMissing: Amount<*>
        fun toString(): String
      val Amount<Issued<Currency>>.OBLIGATION: State<Currency>
      val Issued<Currency>.OBLIGATION_DEF: Terms<Currency>
      val OBLIGATION_PROGRAM_ID: Obligation<Currency>
      class Obligation<P> : ClauseVerifier
        Module Contents Obligation()
        interface Clauses
          Module Contents class ConserveAmount<P> : AbstractConserveAmount<State<P>, Terms<P>>
            Module Contents ConserveAmount()
          class Group<P> : GroupClauseVerifier<State<P>, Issued<Terms<P>>>
            Module Contents Group()
            val clauses: <ERROR CLASS>
            fun extractGroups(tx: TransactionForContract): List<InOutGroup<State<P>, Issued<Terms<P>>>>
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
          class Issue<P> : AbstractIssue<State<P>, Terms<P>>
            Module Contents Issue()
            val requiredCommands: <ERROR CLASS>
          class Net<P> : NetClause<P>
            Module Contents Net()
          class SetLifecycle<P> : GroupClause<State<P>, Issued<Terms<P>>>
            Module Contents SetLifecycle()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms<P>>): Set<CommandData>
          class Settle<P> : GroupClause<State<P>, Issued<Terms<P>>>
            Module Contents Settle()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: <ERROR CLASS>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms<P>>): Set<CommandData>
          class VerifyLifecycle<P> : SingleClause, GroupClause<State<P>, Issued<Terms<P>>>
            Module Contents VerifyLifecycle()
            val ifMatched: MatchBehaviour
            val ifNotMatched: MatchBehaviour
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<Terms<P>>): Set<CommandData>
            fun verify(inputs: List<State<P>>, outputs: List<State<P>>): Set<CommandData>
        interface Commands : Commands
          Module Contents data class Exit<P> : Commands, Exit<Terms<P>>
            Module Contents Exit(amount: Amount<Issued<Terms<P>>>)
            val amount: Amount<Issued<Terms<P>>>
          data class Issue : Issue, Commands
            Module Contents Issue(nonce: Long = random63BitValue())
            val nonce: Long
          data class Move : Commands, Move
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
          data class Net : Commands
            Module Contents Net(type: NetType)
            val type: NetType
          data class SetLifecycle : Commands
            Module Contents SetLifecycle(lifecycle: Lifecycle)
            val inverse: Lifecycle
            val lifecycle: Lifecycle
          data class Settle<P> : Commands
            Module Contents Settle(amount: Amount<Issued<Terms<P>>>)
            val amount: Amount<Issued<Terms<P>>>
        enum class Lifecycle
          Module Contents DEFAULTED
          NORMAL
        data class State<P> : FungibleAsset<Terms<P>>, NettableState<State<P>, MultilateralNetState<P>>
          Module Contents State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor: Party, template: Terms<P>, quantity: Long, beneficiary: PublicKey)
          val amount: Amount<Issued<Terms<P>>>
          val beneficiary: PublicKey
          val bilateralNetState: BilateralNetState<P>
          val contract: Obligation<Currency>
          val deposit: PartyAndReference
          val dueBefore: Instant
          val exitKeys: Collection<PublicKey>
          val issuanceDef: Issued<Terms<P>>
          var lifecycle: Lifecycle
          fun move(newAmount: Amount<Issued<Terms<P>>>, newOwner: PublicKey): State<P>
          val multilateralNetState: MultilateralNetState<P>
          fun net(other: State<P>): State<P>
          val obligor: Party
          val owner: PublicKey
          val participants: List<PublicKey>
          val quantity: Long
          val template: Terms<P>
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        data class Terms<P>
          Module Contents Terms(acceptableContracts: NonEmptySet<SecureHash>, acceptableIssuedProducts: NonEmptySet<Issued<P>>, dueBefore: Instant, timeTolerance: Duration = Duration.ofSeconds(30))
          val acceptableContracts: NonEmptySet<SecureHash>
          val acceptableIssuedProducts: NonEmptySet<Issued<P>>
          val dueBefore: Instant
          val product: P
          val timeTolerance: Duration
        val clauses: <ERROR CLASS>
        fun extractCommands(tx: TransactionForContract): List<AuthenticatedObject<Commands>>
        fun generateCloseOutNetting(tx: TransactionBuilder, signer: PublicKey, vararg states: State<P>): Unit
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<Terms<P>>>, changeKey: PublicKey, assetStates: List<StateAndRef<State<P>>>): PublicKey
        fun generateIssue(tx: TransactionBuilder, obligor: Party, issuanceDef: Terms<P>, pennies: Long, beneficiary: PublicKey, notary: Party): Unit
        fun generatePaymentNetting(tx: TransactionBuilder, issued: Issued<Terms<P>>, notary: Party, vararg states: State<P>): Unit
        fun generateSetLifecycle(tx: TransactionBuilder, statesAndRefs: List<StateAndRef<State<P>>>, lifecycle: Lifecycle, notary: Party): Unit
        fun generateSettle(tx: TransactionBuilder, statesAndRefs: Iterable<StateAndRef<State<P>>>, assetStatesAndRefs: Iterable<StateAndRef<FungibleAsset<P>>>, moveCommand: MoveCommand, notary: Party): Unit
        val legalContractReference: SecureHash
      abstract class OnLedgerAsset<T : Any, S : FungibleAsset<T>> : ClauseVerifier
        Module Contents OnLedgerAsset()
        abstract val conserveClause: AbstractConserveAmount<S, T>
        abstract fun deriveState(txState: TransactionState<S>, amount: Amount<Issued<T>>, owner: PublicKey): TransactionState<S>
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, changeKey: PublicKey, assetStates: List<StateAndRef<S>>): PublicKey
        abstract fun generateExitCommand(amount: Amount<Issued<T>>): Exit<T>
        abstract fun generateIssueCommand(): Issue
        abstract fun generateMoveCommand(): Move
        fun generateSpend(tx: TransactionBuilder, amount: Amount<T>, to: PublicKey, assetsStates: List<StateAndRef<S>>, onlyFromParties: Set<Party>? = null): List<PublicKey>
      val Amount<Issued<Currency>>.STATE: State
      infix fun <T> State<T>.at(dueBefore: Instant): State<T>
      infix fun <T> State<T>.between(parties: <ERROR CLASS><Party, PublicKey>): State<T>
      val Wallet.cashBalances: Map<Currency, Amount<Currency>>
      fun <P> extractAmountsDue(product: Terms<P>, states: Iterable<State<P>>): Map<<ERROR CLASS><PublicKey, PublicKey>, Amount<Terms<P>>>
      infix fun State.issued by(party: Party): State
      infix fun State.issued by(deposit: PartyAndReference): State
      infix fun <T> State<T>.issued by(party: Party): State<T>
      fun State.issuedBy(party: Party): State
      fun State.issuedBy(deposit: PartyAndReference): State
      fun <T> State<T>.issuedBy(party: Party): State<T>
      kotlin.collections.Iterable
        Module Contents fun Iterable<ContractState>.sumCash(): Amount<Issued<Currency>>
        fun Iterable<ContractState>.sumCashBy(owner: PublicKey): Amount<Issued<Currency>>
        fun Iterable<ContractState>.sumCashOrNull(): Amount<Issued<Currency>>?
        fun Iterable<ContractState>.sumCashOrZero(currency: Issued<Currency>): Amount<Issued<Currency>>
        fun Iterable<ContractState>.sumCommodities(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCommoditiesOrNull(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCommoditiesOrZero(currency: Issued<Commodity>): <ERROR CLASS>
        fun <T> Iterable<ContractState>.sumFungibleOrNull(): <ERROR CLASS>
        fun <T> Iterable<ContractState>.sumFungibleOrZero(token: Issued<T>): <ERROR CLASS>
        fun <P> Iterable<ContractState>.sumObligations(): Amount<Issued<Terms<P>>>
        fun <P> Iterable<ContractState>.sumObligationsOrNull(): Amount<Issued<Terms<P>>>?
        fun <P> Iterable<ContractState>.sumObligationsOrZero(issuanceDef: Issued<Terms<P>>): Amount<Issued<Terms<P>>>
      fun <P> netAmountsDue(balances: Map<<ERROR CLASS><PublicKey, PublicKey>, Amount<P>>): Map<<ERROR CLASS><PublicKey, PublicKey>, Amount<P>>
      infix fun State.owned by(owner: PublicKey): State
      infix fun <T> State<T>.owned by(owner: PublicKey): State<T>
      fun State.ownedBy(owner: PublicKey): State
      fun <T> State<T>.ownedBy(owner: PublicKey): State<T>
      fun <P> sumAmountsDue(balances: Map<<ERROR CLASS><PublicKey, PublicKey>, Amount<P>>): Map<PublicKey, Long>
      infix fun State.with deposit(deposit: PartyAndReference): State
      fun State.withDeposit(deposit: PartyAndReference): State
    package com.r3corda.contracts.clause
      Module Contents abstract class AbstractConserveAmount<S : FungibleAsset<T>, T : Any> : GroupClause<S, Issued<T>>
        Module Contents AbstractConserveAmount()
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, changeKey: PublicKey, assetStates: List<StateAndRef<S>>, deriveState: (TransactionState<S>, Amount<Issued<T>>, PublicKey) -> TransactionState<S>, generateExitCommand: (Amount<Issued<T>>) -> CommandData): PublicKey
        fun generateSpend(tx: TransactionBuilder, amount: Amount<T>, to: PublicKey, assetsStates: List<StateAndRef<S>>, onlyFromParties: Set<Party>? = null, deriveState: (TransactionState<S>, Amount<Issued<T>>, PublicKey) -> TransactionState<S>, generateMoveCommand: () -> CommandData): List<PublicKey>
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<T>): Set<CommandData>
      abstract class AbstractIssue<in S : ContractState, T : Any> : GroupClause<S, Issued<T>>
        Module Contents AbstractIssue(sum: List<S>.() -> Amount<Issued<T>>, sumOrZero: List<S>.(Issued<T>) -> Amount<Issued<T>>)
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        val sum: List<S>.() -> Amount<Issued<T>>
        val sumOrZero: List<S>.(Issued<T>) -> Amount<Issued<T>>
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<T>): Set<CommandData>
      data class BilateralNetState<P> : NetState<P>
        Module Contents BilateralNetState(partyKeys: Set<PublicKey>, template: Terms<P>)
        val partyKeys: Set<PublicKey>
        val template: Terms<P>
      data class MultilateralNetState<P> : NetState<P>
        Module Contents MultilateralNetState(template: Terms<P>)
        val template: Terms<P>
      open class NetClause<P> : SingleClause
        Module Contents NetClause()
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
        fun verifyNetCommand(inputs: List<State<P>>, outputs: List<State<P>>, command: AuthenticatedObject<Net>, netState: NetState<P>): Unit
      interface NetState<P>
        Module Contents abstract val template: Terms<P>
      open class NoZeroSizedOutputs<in S : FungibleAsset<T>, T : Any> : GroupClause<S, Issued<T>>
        Module Contents NoZeroSizedOutputs()
        open val ifMatched: MatchBehaviour
        open val ifNotMatched: MatchBehaviour
        open val requiredCommands: Set<Class<CommandData>>
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: Issued<T>): Set<CommandData>
    package com.r3corda.contracts.testing
      Module Contents fun ServiceHub.fillWithSomeTestCash(howMuch: Amount<Currency>, notary: Party = DUMMY_NOTARY, atLeastThisManyStates: Int = 3, atMostThisManyStates: Int = 10, rng: Random = Random(), ref: OpaqueBytes = OpaqueBytes(ByteArray(1, { 1 })), ownedBy: PublicKey? = null): Wallet
    package com.r3corda.core
      Module Contents abstract class RetryableException : Exception
        Module Contents RetryableException(message: String)
      val RunOnCallerThread: <ERROR CLASS>
      class ThreadBox<out T>
        Module Contents ThreadBox(content: T, lock: ReentrantLock = ReentrantLock())
        inline fun <R> alreadyLocked(body: T.() -> R): R
        val content: T
        val lock: ReentrantLock
        inline fun <R> locked(body: T.() -> R): R
      class TransientProperty<out T>
        Module Contents TransientProperty(initializer: () -> T)
        operator fun getValue(thisRef: Any?, property: KProperty<*>): T
      fun extractZipFile(zipPath: Path, toPath: Path): Unit
      fun <T> <ERROR CLASS><T>.failure(executor: Executor, body: (Throwable) -> Unit): <ERROR CLASS>
      infix fun <T> <ERROR CLASS><T>.failure(body: (Throwable) -> Unit): <ERROR CLASS><T>
      java.nio.file.Path
        Module Contents fun <R> Path.use(block: (InputStream) -> R): R
      java.time.temporal.Temporal
        Module Contents infix fun Temporal.until(endExclusive: Temporal): Duration
      kotlin.Double
        Module Contents val Double.bd: BigDecimal
      kotlin.Int
        Module Contents val Int.bd: BigDecimal
        infix fun Int.checkedAdd(b: Int): Int
        val Int.days: Duration
        val Int.hours: Duration
        val Int.minutes: Duration
        val Int.seconds: Duration
      kotlin.Long
        Module Contents val Long.bd: BigDecimal
        infix fun Long.checkedAdd(b: Long): Long
      kotlin.String
        Module Contents fun String.abbreviate(maxWidth: Int): String
        val String.bd: BigDecimal
      kotlin.collections.Iterable
        Module Contents fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?
        fun <T> Iterable<T>.noneOrSingle(): T?
      kotlin.collections.List
        Module Contents fun <T> List<T>.indexOfOrThrow(item: T): Int
      fun <T> logElapsedTime(label: String, logger: <ERROR CLASS>? = null, body: () -> T): T
      fun random63BitValue(): Long
      fun <T> <ERROR CLASS><T>.setFrom(logger: <ERROR CLASS>? = null, block: () -> T): <ERROR CLASS><T>
      fun <T> <ERROR CLASS><T>.success(executor: Executor, body: (T) -> Unit): <ERROR CLASS>
      infix fun <T> <ERROR CLASS><T>.success(body: (T) -> Unit): <ERROR CLASS><T>
      fun <T> <ERROR CLASS><T>.then(executor: Executor, body: () -> Unit): <ERROR CLASS>
      infix fun <T> <ERROR CLASS><T>.then(body: () -> Unit): <ERROR CLASS><T>
    package com.r3corda.core.contracts
      Module Contents enum class AccrualAdjustment
        Module Contents Adjusted
        Unadjusted
      data class Amount<T> : Comparable<Amount<T>>
        Module Contents Amount(amount: BigDecimal, currency: T)
        Amount(quantity: Long, token: T)
        fun compareTo(other: Amount<T>): Int
        operator fun div(other: Long): Amount<T>
        operator fun div(other: Int): Amount<T>
        operator fun minus(other: Amount<T>): Amount<T>
        operator fun plus(other: Amount<T>): Amount<T>
        val quantity: Long
        operator fun times(other: Long): Amount<T>
        operator fun times(other: Int): Amount<T>
        fun toString(): String
        val token: T
      interface Attachment : NamedByHash
        Module Contents open fun extractFile(path: String, outputTo: OutputStream): Unit
        abstract fun open(): InputStream
        open fun openAsJAR(): JarInputStream
      data class AuthenticatedObject<out T : Any>
        Module Contents AuthenticatedObject(signers: List<PublicKey>, signingParties: List<Party>, value: T)
        val signers: List<PublicKey>
        val signingParties: List<Party>
        val value: T
      interface BilateralNettableState<N : BilateralNettableState<N>>
        Module Contents abstract val bilateralNetState: Any
        abstract fun net(other: N): N
      open class BusinessCalendar
        Module Contents val TEST_CALENDAR_DATA: <ERROR CLASS>
        class UnknownCalendar : Exception
          Module Contents UnknownCalendar(name: String)
        open fun applyRollConvention(testDate: LocalDate, dateRollConvention: DateRollConvention): LocalDate
        val calendars: <ERROR CLASS>
        fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = getInstance(), dateRollConvention: DateRollConvention = DateRollConvention.Following, noOfAdditionalPeriods: Int = Integer.MAX_VALUE, endDate: LocalDate? = null, periodOffset: Int? = null): List<LocalDate>
        open fun equals(other: Any?): Boolean
        fun getInstance(vararg calname: String): BusinessCalendar
        fun getOffsetDate(startDate: LocalDate, period: Frequency, steps: Int = 1): LocalDate
        open fun hashCode(): Int
        val holidayDates: List<LocalDate>
        open fun isWorkingDay(date: LocalDate): Boolean
        fun moveBusinessDays(date: LocalDate, direction: DateRollDirection, i: Int): LocalDate
        fun parseDateFromString(it: String): LocalDate
      val CHF: Currency
      data class Command
        Module Contents Command(data: CommandData, key: PublicKey)
        Command(value: CommandData, signers: List<PublicKey>)
        val signers: List<PublicKey>
        fun toString(): String
        val value: CommandData
      interface CommandData
      data class Commodity
        Module Contents Commodity(symbol: String, displayName: String, commodityCode: String = symbol, defaultFractionDigits: Int = 0)
        val commodityCode: String
        val defaultFractionDigits: Int
        val displayName: String
        fun getInstance(symbol: String): Commodity?
        val symbol: String
      interface Contract
        Module Contents abstract val legalContractReference: SecureHash
        abstract fun verify(tx: TransactionForContract): Unit
      interface ContractState
        Module Contents abstract val contract: Contract
        abstract val participants: List<PublicKey>
      fun DOLLARS(amount: Int): Amount<Currency>
      fun DOLLARS(amount: Double): Amount<Currency>
      val DUMMY_PROGRAM_ID: DummyContract
      enum class DateRollConvention
        Module Contents Actual
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        Following
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        ModifiedFollowing
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        ModifiedPrevious
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        Previous
          Module Contents fun direction(): DateRollDirection
          val isModified: Boolean
        abstract fun direction(): DateRollDirection
        abstract val isModified: Boolean
      enum class DateRollDirection
        Module Contents BACKWARD
        FORWARD
        val value: Long
      enum class DayCountBasisDay
        Module Contents D30
        D30E
        D30F
        D30G
        D30N
        D30P
        D30Z
        DActual
        DActualJ
        DBus_SaoPaulo
        fun toString(): String
      enum class DayCountBasisYear
        Module Contents Y252
        Y360
        Y365
        Y365B
        Y365F
        Y365L
        Y365Q
        Y366
        YActual
        YActualA
        YICMA
        YISMA
        fun toString(): String
      interface DealState : LinearState
        Module Contents abstract fun generateAgreement(notary: Party): TransactionBuilder
        abstract val parties: Array<Party>
        abstract val ref: String
        abstract fun withPublicKey(before: Party, after: PublicKey): DealState
      class DummyContract : Contract
        Module Contents DummyContract()
        interface Commands : CommandData
          Module Contents class Create : TypeOnlyCommandData, Commands
            Module Contents Create()
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
        data class MultiOwnerState : ContractState, State
          Module Contents MultiOwnerState(magicNumber: Int = 0, owners: List<PublicKey>)
          val contract: DummyContract
          val magicNumber: Int
          val owners: List<PublicKey>
          val participants: List<PublicKey>
        data class SingleOwnerState : OwnableState, State
          Module Contents SingleOwnerState(magicNumber: Int = 0, owner: PublicKey)
          val contract: DummyContract
          val magicNumber: Int
          val owner: PublicKey
          val participants: List<PublicKey>
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        interface State : ContractState
          Module Contents abstract val magicNumber: Int
        fun generateInitial(owner: PartyAndReference, magicNumber: Int, notary: Party): TransactionBuilder
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      data class DummyState : ContractState
        Module Contents DummyState(magicNumber: Int = 0)
        val contract: DummyContract
        val magicNumber: Int
        val participants: List<PublicKey>
      data class Expression
        Module Contents Expression(expr: String)
        val expr: String
      object ExpressionDeserializer
        Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): Expression
      object ExpressionSerializer
        Module Contents fun serialize(expr: Expression, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
      val FCOJ: Commodity
      fun FCOJ(amount: Int): Amount<Commodity>
      data class Fix : CommandData
        Module Contents Fix(of: FixOf, value: BigDecimal)
        val of: FixOf
        val value: BigDecimal
      data class FixOf
        Module Contents FixOf(name: String, forDay: LocalDate, ofTenor: Tenor)
        val forDay: LocalDate
        val name: String
        val ofTenor: Tenor
      interface FixableDealState : DealState
        Module Contents abstract fun generateFix(ptx: TransactionBuilder, oldState: StateAndRef<*>, fix: Fix): Unit
        abstract fun nextFixingOf(): FixOf?
      enum class Frequency
        Module Contents Annual
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        BiWeekly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Daily
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Monthly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Quarterly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        SemiAnnual
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        Weekly
          Module Contents fun offset(d: LocalDate, n: Long): LocalDate
        val annualCompoundCount: Int
        abstract fun offset(d: LocalDate, n: Long = 1): LocalDate
      val GBP: Currency
      interface IssuanceDefinition
      interface IssueCommand : CommandData
        Module Contents abstract val nonce: Long
      data class Issued<out P>
        Module Contents Issued(issuer: PartyAndReference, product: P)
        val issuer: PartyAndReference
        val product: P
        fun toString(): String
      data class LedgerTransaction : NamedByHash
        Module Contents LedgerTransaction(inputs: List<StateAndRef<*>>, outputs: List<TransactionState<*>>, commands: List<AuthenticatedObject<CommandData>>, attachments: List<Attachment>, id: SecureHash, signers: List<PublicKey>, type: TransactionType)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        val id: SecureHash
        val inputs: List<StateAndRef<*>>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        val outputs: List<TransactionState<*>>
        val signers: List<PublicKey>
        fun toTransactionForContract(): TransactionForContract
        val type: TransactionType
        fun verify(): Unit
      interface LinearState : ContractState
        Module Contents abstract fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        abstract val thread: SecureHash
      interface MoveCommand : CommandData
        Module Contents abstract val contractHash: SecureHash?
      interface MultilateralNettableState<out T : Any>
        Module Contents abstract val multilateralNetState: T
      interface NamedByHash
        Module Contents abstract val id: SecureHash
      enum class NetType
        Module Contents CLOSE_OUT
        PAYMENT
      interface NettableState<N : BilateralNettableState<N>, T : Any> : BilateralNettableState<N>, MultilateralNettableState<T>
      interface OwnableState : ContractState
        Module Contents abstract val owner: PublicKey
        abstract fun withNewOwner(newOwner: PublicKey): <ERROR CLASS><CommandData, OwnableState>
      fun POUNDS(amount: Int): Amount<Currency>
      data class PartyAndReference
        Module Contents PartyAndReference(party: Party, reference: OpaqueBytes)
        val party: Party
        val reference: OpaqueBytes
        fun toString(): String
      enum class PaymentRule
        Module Contents InAdvance
        InArrears
      val R: Requirements
      class Requirements
        Module Contents Requirements()
        infix fun String.by(expr: Boolean): Unit
      fun SWISS_FRANCS(amount: Int): Amount<Currency>
      interface SchedulableState : ContractState
        Module Contents abstract fun nextScheduledActivity(thisStateRef: StateRef, protocolLogicRefFactory: ProtocolLogicRefFactory): ScheduledActivity?
      interface Scheduled
        Module Contents abstract val scheduledAt: Instant
      data class ScheduledActivity : Scheduled
        Module Contents ScheduledActivity(logicRef: ProtocolLogicRef, scheduledAt: Instant)
        val logicRef: ProtocolLogicRef
        val scheduledAt: Instant
      data class ScheduledStateRef : Scheduled
        Module Contents ScheduledStateRef(ref: StateRef, scheduledAt: Instant)
        val ref: StateRef
        val scheduledAt: Instant
      data class SignedTransaction : NamedByHash
        Module Contents SignedTransaction(txBits: SerializedBytes<WireTransaction>, sigs: List<WithKey>)
        val id: SecureHash
        operator fun plus(sig: WithKey): SignedTransaction
        operator fun plus(sigList: Collection<WithKey>): SignedTransaction
        val sigs: List<WithKey>
        val tx: WireTransaction
        val txBits: SerializedBytes<WireTransaction>
        fun verifySignatures(throwIfSignaturesAreMissing: Boolean = true): Set<PublicKey>
        fun withAdditionalSignature(sig: WithKey): SignedTransaction
        fun withAdditionalSignatures(sigList: Iterable<WithKey>): SignedTransaction
      data class StateAndRef<out T : ContractState>
        Module Contents StateAndRef(state: TransactionState<T>, ref: StateRef)
        val ref: StateRef
        val state: TransactionState<T>
      data class StateRef
        Module Contents StateRef(txhash: SecureHash, index: Int)
        val index: Int
        fun toString(): String
        val txhash: SecureHash
      data class Tenor
        Module Contents Tenor(name: String)
        enum class TimeUnit
          Module Contents Day
          Month
          Week
          Year
          val code: String
        fun daysToMaturity(startDate: LocalDate, calendar: BusinessCalendar): Int
        val name: String
        fun toString(): String
      data class TimestampCommand : CommandData
        Module Contents TimestampCommand(time: Instant, tolerance: Duration)
        TimestampCommand(after: Instant?, before: Instant?)
        val after: Instant?
        val before: Instant?
        val midpoint: Instant
      open class TransactionBuilder
        Module Contents TransactionBuilder(type: TransactionType = TransactionType.General(), notary: Party? = null, inputs: MutableList<StateRef> = arrayListOf(), attachments: MutableList<SecureHash> = arrayListOf(), outputs: MutableList<TransactionState<ContractState>> = arrayListOf(), commands: MutableList<Command> = arrayListOf(), signers: MutableSet<PublicKey> = mutableSetOf())
        fun addAttachment(attachmentId: SecureHash): Unit
        fun addCommand(arg: Command): Unit
        fun addCommand(data: CommandData, vararg keys: PublicKey): <ERROR CLASS>
        fun addCommand(data: CommandData, keys: List<PublicKey>): Unit
        open fun addInputState(stateAndRef: StateAndRef<*>): Unit
        fun addInputState(stateRef: StateRef, notary: Party): Unit
        fun addOutputState(state: TransactionState<*>): Int
        fun addOutputState(state: ContractState, notary: Party): Int
        fun addOutputState(state: ContractState): Int
        fun addSignatureUnchecked(sig: WithKey): Unit
        fun attachments(): List<SecureHash>
        protected val attachments: MutableList<SecureHash>
        fun checkAndAddSignature(sig: WithKey): Unit
        fun checkSignature(sig: WithKey): Unit
        fun commands(): List<Command>
        protected val commands: MutableList<Command>
        fun copy(): TransactionBuilder
        protected val currentSigs: <ERROR CLASS>
        fun inputStates(): List<StateRef>
        protected val inputs: MutableList<StateRef>
        protected val notary: Party?
        fun outputStates(): List<TransactionState<*>>
        protected val outputs: MutableList<TransactionState<ContractState>>
        fun setTime(time: Instant, authority: Party, timeTolerance: Duration): Unit
        fun signWith(key: KeyPair): Unit
        protected val signers: MutableSet<PublicKey>
        val time: TimestampCommand?
        fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction
        fun toWireTransaction(): WireTransaction
        protected val type: TransactionType
        fun withItems(vararg items: Any): TransactionBuilder
      class TransactionConflictException : Exception
        Module Contents TransactionConflictException(conflictRef: StateRef, tx1: LedgerTransaction, tx2: LedgerTransaction)
        val conflictRef: StateRef
        val tx1: LedgerTransaction
        val tx2: LedgerTransaction
      data class TransactionForContract
        Module Contents TransactionForContract(inputs: List<ContractState>, outputs: List<ContractState>, attachments: List<Attachment>, commands: List<AuthenticatedObject<CommandData>>, origHash: SecureHash, inputNotary: Party? = null)
        data class InOutGroup<out T : ContractState, out K : Any>
          Module Contents InOutGroup(inputs: List<T>, outputs: List<T>, groupingKey: K)
          val groupingKey: K
          val inputs: List<T>
          val outputs: List<T>
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        fun equals(other: Any?): Boolean
        fun getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun getTimestampByName(vararg authorityName: String): TimestampCommand?
        fun <T : ContractState, K : Any> groupStates(ofType: Class<T>, selector: (T) -> K): List<InOutGroup<T, K>>
        inline fun <reified T : ContractState, K : Any> groupStates(selector: (T) -> K): List<InOutGroup<T, K>>
        fun <T : ContractState, K : Any> groupStatesInternal(inGroups: Map<K, List<T>>, outGroups: Map<K, List<T>>): List<InOutGroup<T, K>>
        fun hashCode(): Int
        val inputNotary: Party?
        val inputs: List<ContractState>
        val origHash: SecureHash
        val outputs: List<ContractState>
        val timestamp: TimestampCommand?
      class TransactionGraphSearch : Callable<List<WireTransaction>>
        Module Contents TransactionGraphSearch(transactions: ReadOnlyTransactionStorage, startPoints: List<WireTransaction>)
        class Query
          Module Contents Query(withCommandOfType: Class<out CommandData>? = null)
          val withCommandOfType: Class<out CommandData>?
        fun call(): List<WireTransaction>
        var query: Query
        val startPoints: List<WireTransaction>
        val transactions: ReadOnlyTransactionStorage
      class TransactionResolutionException : Exception
        Module Contents TransactionResolutionException(hash: SecureHash)
        val hash: SecureHash
        fun toString(): String
      data class TransactionState<out T : ContractState>
        Module Contents TransactionState(data: T, notary: Party)
        val data: T
        val notary: Party
        fun withNotary(newNotary: Party): TransactionState<T>
      sealed class TransactionType
        Module Contents class General : TransactionType
          Module Contents General()
          class Builder : TransactionBuilder
            Module Contents Builder(notary: Party? = null)
          fun getRequiredSigners(tx: LedgerTransaction): <ERROR CLASS>
          fun verifyTransaction(tx: LedgerTransaction): Unit
        class NotaryChange : TransactionType
          Module Contents NotaryChange()
          class Builder : TransactionBuilder
            Module Contents Builder(notary: Party? = null)
            fun addInputState(stateAndRef: StateAndRef<*>): Unit
          fun getRequiredSigners(tx: LedgerTransaction): <ERROR CLASS>
          fun verifyTransaction(tx: LedgerTransaction): Unit
        open fun equals(other: Any?): Boolean
        abstract fun getRequiredSigners(tx: LedgerTransaction): Set<PublicKey>
        open fun hashCode(): <ERROR CLASS>
        fun verify(tx: LedgerTransaction): Unit
        fun verifySigners(tx: LedgerTransaction): Set<PublicKey>
        abstract fun verifyTransaction(tx: LedgerTransaction): Unit
      sealed class TransactionVerificationException : Exception
        Module Contents class ContractRejection : TransactionVerificationException
          Module Contents ContractRejection(tx: LedgerTransaction, contract: Contract, cause: Throwable?)
          val contract: Contract
        class InvalidNotaryChange : TransactionVerificationException
          Module Contents InvalidNotaryChange(tx: LedgerTransaction)
        class MoreThanOneNotary : TransactionVerificationException
          Module Contents MoreThanOneNotary(tx: LedgerTransaction)
        class SignersMissing : TransactionVerificationException
          Module Contents SignersMissing(tx: LedgerTransaction, missing: List<PublicKey>)
          val missing: List<PublicKey>
          fun toString(): String
        val tx: LedgerTransaction
      abstract class TypeOnlyCommandData : CommandData
        Module Contents TypeOnlyCommandData()
        open fun equals(other: Any?): Boolean
        open fun hashCode(): <ERROR CLASS>
      val USD: Currency
      data class WireTransaction : NamedByHash
        Module Contents WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<TransactionState<ContractState>>, commands: List<Command>, signers: List<PublicKey>, type: TransactionType)
        val attachments: List<SecureHash>
        val commands: List<Command>
        fun deserialize(bits: SerializedBytes<WireTransaction>, kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun <T : ContractState> outRef(state: ContractState): StateAndRef<T>
        val outputs: List<TransactionState<ContractState>>
        val serialized: SerializedBytes<WireTransaction>
        val signers: List<PublicKey>
        fun toString(): String
        val type: TransactionType
      fun calculateDaysBetween(startDate: LocalDate, endDate: LocalDate, dcbYear: DayCountBasisYear, dcbDay: DayCountBasisDay): Int
      fun commodity(code: String): Commodity
      fun currency(code: String): Currency
      fun ContractState.hash(): SecureHash
      infix fun Commodity.issued by(deposit: PartyAndReference): Issued<Commodity>
      infix fun Amount<Currency>.issued by(deposit: PartyAndReference): Amount<Issued<Currency>>
      infix fun Commodity.issuedBy(deposit: PartyAndReference): Issued<Commodity>
      infix fun Amount<Currency>.issuedBy(deposit: PartyAndReference): Amount<Issued<Currency>>
      java.time.LocalDate
        Module Contents fun LocalDate.isWorkingDay(accordingToCalendar: BusinessCalendar): Boolean
      java.util.Currency
        Module Contents infix fun Currency.issued by(deposit: PartyAndReference): Issued<Currency>
        infix fun Currency.issuedBy(deposit: PartyAndReference): Issued<Currency>
      kotlin.Double
        Module Contents val Double.DOLLARS: Amount<Currency>
      kotlin.Int
        Module Contents val Int.DOLLARS: Amount<Currency>
        val Int.FCOJ: Amount<Commodity>
        val Int.POUNDS: Amount<Currency>
        val Int.SWISS_FRANCS: Amount<Currency>
      kotlin.collections.Collection
        Module Contents inline fun <reified T : CommandData> Collection<AuthenticatedObject<CommandData>>.requireSingleCommand(): <ERROR CLASS>
        fun <C : CommandData> Collection<AuthenticatedObject<CommandData>>.requireSingleCommand(klass: Class<C>): <ERROR CLASS>
        inline fun <reified T : CommandData> Collection<AuthenticatedObject<CommandData>>.select(signer: PublicKey? = null, party: Party? = null): <ERROR CLASS>
        inline fun <reified T : CommandData> Collection<AuthenticatedObject<CommandData>>.select(signers: Collection<PublicKey>?, parties: Collection<Party>?): <ERROR CLASS>
      kotlin.collections.Iterable
        Module Contents fun <T> Iterable<Amount<T>>.sumOrNull(): Nothing?
        fun <T> Iterable<Amount<T>>.sumOrThrow(): <ERROR CLASS>
        fun <T> Iterable<Amount<T>>.sumOrZero(currency: T): Amount<T>
      kotlin.collections.List
        Module Contents inline fun <reified T : ContractState> List<StateAndRef<ContractState>>.filterStatesOfType(): List<StateAndRef<T>>
        fun List<AuthenticatedObject<CommandData>>.getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun List<AuthenticatedObject<CommandData>>.getTimestampByName(vararg names: String): TimestampCommand?
      inline fun <R> requireThat(body: Requirements.() -> R): R
      fun WireTransaction.toLedgerTransaction(services: ServiceHub): LedgerTransaction
      fun SignedTransaction.toLedgerTransaction(services: ServiceHub): LedgerTransaction
      inline fun <reified T : MoveCommand> verifyMoveCommand(inputs: List<OwnableState>, tx: TransactionForContract): MoveCommand
      inline fun <reified T : MoveCommand> verifyMoveCommand(inputs: List<OwnableState>, commands: List<AuthenticatedObject<CommandData>>): MoveCommand
      infix fun <T : ContractState> T.with notary(newNotary: Party): TransactionState<T>
      infix fun <T : ContractState> T.withNotary(newNotary: Party): TransactionState<T>
      fun <T> Amount<Issued<T>>.withoutIssuer(): Amount<T>
    package com.r3corda.core.contracts.clauses
      Module Contents interface Clause
        Module Contents abstract val ifMatched: MatchBehaviour
        abstract val ifNotMatched: MatchBehaviour
        abstract val requiredCommands: Set<Class<out CommandData>>
      abstract class ClauseVerifier : Contract
        Module Contents ClauseVerifier()
        abstract val clauses: List<SingleClause>
        abstract fun extractCommands(tx: TransactionForContract): Collection<AuthenticatedObject<CommandData>>
        open fun verify(tx: TransactionForContract): Unit
      interface GroupClause<in S : ContractState, in T : Any> : Clause, GroupVerify<S, T>
      abstract class GroupClauseVerifier<S : ContractState, T : Any> : SingleClause
        Module Contents GroupClauseVerifier()
        abstract val clauses: List<GroupClause<S, T>>
        abstract fun extractGroups(tx: TransactionForContract): List<InOutGroup<S, T>>
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
      interface GroupVerify<in S, in T : Any>
        Module Contents abstract fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: Collection<AuthenticatedObject<CommandData>>, token: T): Set<CommandData>
      data class InterceptorClause : SingleClause
        Module Contents InterceptorClause(preclause: SingleVerify, clause: SingleClause)
        val clause: SingleClause
        val ifMatched: MatchBehaviour
        val ifNotMatched: MatchBehaviour
        val preclause: SingleVerify
        val requiredCommands: Set<Class<out CommandData>>
        fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
      enum class MatchBehaviour
        Module Contents CONTINUE
        END
        ERROR
      interface SingleClause : Clause, SingleVerify
      interface SingleVerify
        Module Contents abstract fun verify(tx: TransactionForContract, commands: Collection<AuthenticatedObject<CommandData>>): Set<CommandData>
      inline fun <reified T : CommandData> verifyClauses(tx: TransactionForContract, clauses: List<SingleClause>): Unit
      fun verifyClauses(tx: TransactionForContract, clauses: List<SingleClause>, commands: Collection<AuthenticatedObject<CommandData>>): Unit
    package com.r3corda.core.crypto
      Module Contents open class DigitalSignature : OpaqueBytes
        Module Contents DigitalSignature(bits: ByteArray)
        class LegallyIdentifiable : WithKey
          Module Contents LegallyIdentifiable(signer: Party, bits: ByteArray, covering: Int)
          val signer: Party
        open class WithKey : DigitalSignature
          Module Contents WithKey(by: PublicKey, bits: ByteArray, covering: Int = 0)
          val by: PublicKey
          fun verifyWithECDSA(content: ByteArray): Unit
          fun verifyWithECDSA(content: OpaqueBytes): Unit
      class DummyPublicKey : PublicKey, Comparable<PublicKey>
        Module Contents DummyPublicKey(s: String)
        fun compareTo(other: PublicKey): Int
        fun equals(other: Any?): Boolean
        fun getAlgorithm(): String
        fun getEncoded(): <ERROR CLASS>
        fun getFormat(): String
        fun hashCode(): Int
        val s: String
        fun toString(): String
      object NullPublicKey : PublicKey, Comparable<PublicKey>
        Module Contents fun compareTo(other: PublicKey): Int
        fun getAlgorithm(): String
        fun getEncoded(): ByteArray
        fun getFormat(): String
        fun toString(): String
      object NullSignature : WithKey
      data class Party
        Module Contents Party(name: String, owningKey: PublicKey)
        val name: String
        val owningKey: PublicKey
        fun ref(bytes: OpaqueBytes): PartyAndReference
        fun ref(vararg bytes: Byte): PartyAndReference
        fun toString(): String
      sealed class SecureHash : OpaqueBytes
        Module Contents class SHA256 : SecureHash
          Module Contents SHA256(bits: ByteArray)
          val signatureAlgorithmName: String
        fun parse(str: String): <ERROR CLASS>
        fun prefixChars(prefixLen: Int = 6): <ERROR CLASS>
        fun randomSHA256(): SHA256
        fun sha256(bits: ByteArray): SHA256
        fun sha256(str: String): <ERROR CLASS>
        fun sha256Twice(bits: ByteArray): SHA256
        abstract val signatureAlgorithmName: String
        open fun toString(): <ERROR CLASS>
      open class SignedData<T : Any>
        Module Contents SignedData(raw: SerializedBytes<T>, sig: WithKey)
        val raw: SerializedBytes<T>
        val sig: WithKey
        fun verified(): T
        protected open fun verifyData(data: T): Unit
      class WhitelistTrustManager : X509ExtendedTrustManager
        Module Contents WhitelistTrustManager(originalProvider: X509ExtendedTrustManager)
        fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String, socket: Socket?): Unit
        fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String, engine: SSLEngine?): Unit
        fun checkClientTrusted(chain: Array<out X509Certificate>, authType: String): Unit
        fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String, socket: Socket?): Unit
        fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String, engine: SSLEngine?): Unit
        fun checkServerTrusted(chain: Array<out X509Certificate>, authType: String): Unit
        val checker: HostnameChecker
        fun getAcceptedIssuers(): Array<out X509Certificate>
        val originalProvider: X509ExtendedTrustManager
      object WhitelistTrustManagerProvider : Provider
        Module Contents fun addWhitelistEntries(serverNames: List<String>): Unit
        fun addWhitelistEntry(serverName: String): Unit
        val originalTrustProviderAlgorithm: String
        fun register(): Unit
        val whitelist: Set<String>
      class WhitelistTrustManagerSpi : TrustManagerFactorySpi
        Module Contents WhitelistTrustManagerSpi()
        protected fun engineGetTrustManagers(): Array<out TrustManager>
        protected fun engineInit(keyStore: KeyStore?): Unit
        protected fun engineInit(managerFactoryParameters: ManagerFactoryParameters?): Unit
        val originalProvider: TrustManagerFactory
      object X509Utilities
        Module Contents data class CACertAndKey
          Module Contents CACertAndKey(certificate: X509Certificate, keypair: KeyPair)
          val certificate: X509Certificate
          val keypair: KeyPair
        val CA_CERT_ALIAS: String
        val CERT_PRIVATE_KEY_ALIAS: String
        val ECDSA_CURVE: String
        val INTERMEDIATE_CA_PRIVATE_KEY_ALIAS: String
        val KEYSTORE_TYPE: String
        val KEY_GENERATION_ALGORITHM: String
        val ROOT_CA_CERT_PRIVATE_KEY_ALIAS: String
        val SIGNATURE_ALGORITHM: String
        fun createCAKeyStoreAndTrustStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, trustStoreFilePath: Path, trustStorePassword: String): KeyStore
        fun createIntermediateCert(domain: String, certificateAuthority: CACertAndKey): CACertAndKey
        fun createKeystoreForSSL(keyStoreFilePath: Path, storePassword: String, keyPassword: String, caKeyStore: KeyStore, caKeyPassword: String): KeyStore
        fun createSelfSignedCACert(domain: String): CACertAndKey
        fun createServerCert(subject: <ERROR CLASS>, publicKey: PublicKey, certificateAuthority: CACertAndKey, subjectAlternativeNameDomains: List<String>, subjectAlternativeNameIps: List<String>): X509Certificate
        fun generateECDSAKeyPairForSSL(): KeyPair
        fun getDevX509Name(domain: String): <ERROR CLASS>
        fun loadCertificateAndKey(keyStore: KeyStore, keyPassword: String, alias: String): CACertAndKey
        fun loadCertificateFromKeyStore(keyStoreFilePath: Path, storePassword: String, alias: String): X509Certificate
        fun loadCertificateFromPEMFile(filename: Path): X509Certificate
        fun loadKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String): KeyPair
        fun loadKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
        fun loadKeyStore(input: InputStream, storePassword: String): KeyStore
        fun loadOrCreateKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
        fun saveCertificateAsPEMFile(x509Certificate: X509Certificate, filename: Path): Unit
        fun saveKeyStore(keyStore: KeyStore, keyStoreFilePath: Path, storePassword: String): Unit
      val ed25519Curve: <ERROR CLASS>
      fun entropyToKeyPair(entropy: BigInteger): KeyPair
      fun generateKeyPair(): KeyPair
      java.security.KeyPair
        Module Contents operator fun KeyPair.component1(): PrivateKey
        operator fun KeyPair.component2(): PublicKey
        fun KeyPair.signWithECDSA(bitsToSign: ByteArray): WithKey
        fun KeyPair.signWithECDSA(bitsToSign: OpaqueBytes): WithKey
        fun KeyPair.signWithECDSA(bitsToSign: OpaqueBytes, party: Party): LegallyIdentifiable
        fun KeyPair.signWithECDSA(bitsToSign: ByteArray, party: Party): LegallyIdentifiable
      java.security.PrivateKey
        Module Contents fun PrivateKey.signWithECDSA(bits: ByteArray): DigitalSignature
        fun PrivateKey.signWithECDSA(bitsToSign: ByteArray, publicKey: PublicKey): WithKey
      java.security.PublicKey
        Module Contents fun PublicKey.toBase58String(): <ERROR CLASS>
        fun PublicKey.toStringShort(): String
        fun PublicKey.verifyWithECDSA(content: ByteArray, signature: DigitalSignature): Unit
      kotlin.ByteArray
        Module Contents fun ByteArray.sha256(): SHA256
      kotlin.collections.Iterable
        Module Contents fun Iterable<PublicKey>.toStringsShort(): String
      fun newSecureRandom(): SecureRandom
      fun parsePublicKeyBase58(base58String: String): <ERROR CLASS>
      fun registerWhitelistTrustManager(): Unit
      fun OpaqueBytes.sha256(): SHA256
    package com.r3corda.core.math
      Module Contents class CubicSplineInterpolator : Interpolator
        Module Contents CubicSplineInterpolator(xs: DoubleArray, ys: DoubleArray)
        fun create(xs: DoubleArray, ys: DoubleArray): CubicSplineInterpolator
        fun interpolate(x: Double): Double
      interface Interpolator
        Module Contents abstract fun interpolate(x: Double): Double
      interface InterpolatorFactory
        Module Contents abstract fun create(xs: DoubleArray, ys: DoubleArray): Interpolator
      class LinearInterpolator : Interpolator
        Module Contents LinearInterpolator(xs: DoubleArray, ys: DoubleArray)
        fun create(xs: DoubleArray, ys: DoubleArray): LinearInterpolator
        fun interpolate(x: Double): Double
      class Polynomial
        Module Contents Polynomial(coefficients: DoubleArray)
        fun getValue(x: Double): <ERROR CLASS>
      class SplineFunction
        Module Contents SplineFunction(segmentMap: TreeMap<Double, Polynomial>)
        fun getValue(x: Double): Double
    package com.r3corda.core.messaging
      Module Contents object Ack : DeserializeAsKotlinObjectDef
      interface AllPossibleRecipients : MessageRecipients
      interface Message
        Module Contents abstract val data: ByteArray
        abstract val debugMessageID: String
        abstract val debugTimestamp: Instant
        abstract fun serialise(): ByteArray
        abstract val topicSession: TopicSession
      interface MessageHandlerRegistration
      interface MessageRecipientGroup : MessageRecipients
      interface MessageRecipients
      interface MessagingService
        Module Contents abstract fun addMessageHandler(topic: String = "", sessionID: Long = DEFAULT_SESSION_ID, executor: Executor? = null, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        abstract fun addMessageHandler(topicSession: TopicSession, executor: Executor? = null, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        abstract fun createMessage(topic: String, sessionID: Long = DEFAULT_SESSION_ID, data: ByteArray): Message
        abstract fun createMessage(topicSession: TopicSession, data: ByteArray): Message
        abstract val myAddress: SingleMessageRecipient
        abstract fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        abstract fun send(message: Message, target: MessageRecipients): Unit
      interface SingleMessageRecipient : MessageRecipients
      data class TopicSession
        Module Contents TopicSession(topic: String, sessionID: Long = DEFAULT_SESSION_ID)
        val Blank: TopicSession
        fun isBlank(): Boolean
        val sessionID: Long
        fun toString(): String
        val topic: String
      object TopicStringValidator
        Module Contents fun check(tag: String): <ERROR CLASS>
      fun MessagingService.runOnNextMessage(topic: String, sessionID: Long, executor: Executor? = null, callback: (Message) -> Unit): Unit
      fun MessagingService.runOnNextMessage(topicSession: TopicSession, executor: Executor? = null, callback: (Message) -> Unit): Unit
      fun MessagingService.send(topic: String, sessionID: Long, payload: Any, to: MessageRecipients): Unit
      fun MessagingService.send(topicSession: TopicSession, payload: Any, to: MessageRecipients): Unit
    package com.r3corda.core.node
      Module Contents class AttachmentsClassLoader : SecureClassLoader
        Module Contents AttachmentsClassLoader(attachments: List<Attachment>, parent: ClassLoader = ClassLoader.getSystemClassLoader())
        class OverlappingAttachments : Exception
          Module Contents OverlappingAttachments(path: String)
          val path: String
          fun toString(): String
        protected fun findClass(name: String): Class<*>
        protected fun findResource(name: String): URL?
        fun getResourceAsStream(name: String): InputStream?
      object CityDatabase
        Module Contents operator fun get(name: String): PhysicalLocation?
      abstract class CordaPluginRegistry
        Module Contents CordaPluginRegistry()
        open val requiredProtocols: Map<String, Set<String>>
        open val servicePlugins: List<Class<*>>
        open val staticServeDirs: Map<String, String>
        open val webApis: List<Class<*>>
      data class NodeInfo
        Module Contents NodeInfo(address: SingleMessageRecipient, identity: Party, advertisedServices: Set<ServiceType> = emptySet(), physicalLocation: PhysicalLocation? = null)
        val address: SingleMessageRecipient
        var advertisedServices: Set<ServiceType>
        val identity: Party
        val physicalLocation: PhysicalLocation?
      data class PhysicalLocation
        Module Contents PhysicalLocation(coordinate: WorldCoordinate, description: String)
        val coordinate: WorldCoordinate
        val description: String
      interface ServiceHub
        Module Contents abstract val clock: Clock
        abstract val identityService: IdentityService
        abstract fun <T : Any> invokeProtocolAsync(logicType: Class<out ProtocolLogic<T>>, vararg args: Any?): <ERROR CLASS><T>
        abstract val keyManagementService: KeyManagementService
        open fun loadState(stateRef: StateRef): TransactionState<*>
        abstract val networkMapCache: NetworkMapCache
        abstract val networkService: MessagingService
        abstract fun recordTransactions(txs: Iterable<SignedTransaction>): Unit
        open fun recordTransactions(vararg txs: SignedTransaction): <ERROR CLASS>
        abstract val schedulerService: SchedulerService
        abstract val storageService: StorageService
        abstract val walletService: WalletService
      data class WorldCoordinate
        Module Contents WorldCoordinate(latitude: Double, longitude: Double)
        val latitude: Double
        val longitude: Double
        fun project(screenWidth: Double, screenHeight: Double, topLatitude: Double, bottomLatitude: Double, leftLongitude: Double, rightLongitude: Double): <ERROR CLASS><Double, Double>
    package com.r3corda.core.node.services
      Module Contents interface AttachmentStorage
        Module Contents abstract fun importAttachment(jar: InputStream): SecureHash
        abstract fun openAttachment(id: SecureHash): Attachment?
      val DEFAULT_SESSION_ID: Long
      interface IdentityService
        Module Contents abstract fun partyFromKey(key: PublicKey): Party?
        abstract fun partyFromName(name: String): Party?
        abstract fun registerIdentity(party: Party): Unit
      interface KeyManagementService
        Module Contents abstract fun freshKey(): KeyPair
        abstract val keys: Map<PublicKey, PrivateKey>
        open fun toKeyPair(publicKey: PublicKey): KeyPair
        open fun toPrivate(publicKey: PublicKey): PrivateKey
      sealed class NetworkCacheError : Exception
        Module Contents class DeregistrationFailed : NetworkCacheError
          Module Contents DeregistrationFailed()
      interface NetworkMapCache
        Module Contents data class MapChange
          Module Contents MapChange(node: NodeInfo, type: MapChangeType)
          val node: NodeInfo
          val type: MapChangeType
        enum class MapChangeType
          Module Contents Added
          Removed
        abstract fun addMapService(net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int? = null): <ERROR CLASS><Unit>
        abstract fun addNode(node: NodeInfo): Unit
        abstract val changed: <ERROR CLASS><MapChange>
        abstract fun deregisterForUpdates(net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        abstract fun get(): Collection<NodeInfo>
        abstract fun get(serviceType: ServiceType): Collection<NodeInfo>
        abstract fun getNodeByLegalName(name: String): NodeInfo?
        abstract fun getNodeByPublicKey(publicKey: PublicKey): NodeInfo?
        abstract fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        val logger: <ERROR CLASS>
        abstract val networkMapNodes: List<NodeInfo>
        abstract val notaryNodes: List<NodeInfo>
        abstract val partyNodes: List<NodeInfo>
        abstract val ratesOracleNodes: List<NodeInfo>
        abstract val regulators: List<NodeInfo>
        abstract fun removeNode(node: NodeInfo): Unit
      interface ReadOnlyTransactionStorage
        Module Contents abstract fun getTransaction(id: SecureHash): SignedTransaction?
      interface SchedulerService
        Module Contents abstract fun scheduleStateActivity(action: ScheduledStateRef): Unit
        abstract fun unscheduleStateActivity(ref: StateRef): Unit
      abstract class ServiceType
        Module Contents ServiceType(id: String)
        open operator fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val id: String
        fun isSubTypeOf(superType: ServiceType): Boolean
        open fun toString(): String
      interface StorageService
        Module Contents abstract val attachments: AttachmentStorage
        abstract val myLegalIdentity: Party
        abstract val myLegalIdentityKey: KeyPair
        abstract val validatedTransactions: ReadOnlyTransactionStorage
      class TimestampChecker
        Module Contents TimestampChecker(clock: Clock = Clock.systemUTC(), tolerance: Duration = 30.seconds)
        val clock: Clock
        fun isValid(timestampCommand: TimestampCommand): Boolean
        val tolerance: Duration
      interface TransactionStorage : ReadOnlyTransactionStorage
        Module Contents abstract fun addTransaction(transaction: SignedTransaction): Unit
      interface TxWritableStorageService : StorageService
        Module Contents abstract val validatedTransactions: TransactionStorage
      class UniquenessException : Exception
        Module Contents UniquenessException(error: Conflict)
        val error: Conflict
      interface UniquenessProvider
        Module Contents data class Conflict
          Module Contents Conflict(stateHistory: Map<StateRef, ConsumingTx>)
          val stateHistory: Map<StateRef, ConsumingTx>
        data class ConsumingTx
          Module Contents ConsumingTx(id: SecureHash, inputIndex: Int, requestingParty: Party)
          val id: SecureHash
          val inputIndex: Int
          val requestingParty: Party
        abstract fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party): Unit
      class Wallet
        Module Contents Wallet(states: List<StateAndRef<ContractState>>)
        val NoUpdate: Update
        data class Update
          Module Contents Update(consumed: Set<StateRef>, produced: Set<StateAndRef<ContractState>>)
          val consumed: Set<StateRef>
          operator fun plus(rhs: Update): Update
          val produced: Set<StateAndRef<ContractState>>
        val states: List<StateAndRef<ContractState>>
        inline fun <reified T : OwnableState> statesOfType(): List<StateAndRef<T>>
      interface WalletService
        Module Contents abstract val currentWallet: Wallet
        abstract val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        open fun <T : LinearState> linearHeadsOfType_(stateType: Class<T>): Map<SecureHash, StateAndRef<T>>
        open fun notify(tx: WireTransaction): Wallet
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Wallet
        open fun statesForRefs(refs: List<StateRef>): Map<StateRef, TransactionState<*>?>
        abstract val updates: <ERROR CLASS><Update>
        open fun whenConsumed(ref: StateRef): <ERROR CLASS><Update>
      inline fun <reified T : LinearState> WalletService.linearHeadsOfType(): <ERROR CLASS>
    package com.r3corda.core.node.services.testing
      Module Contents class MockAttachmentStorage : AttachmentStorage
        Module Contents MockAttachmentStorage()
        val files: HashMap<SecureHash, ByteArray>
        fun importAttachment(jar: InputStream): SecureHash
        fun openAttachment(id: SecureHash): Attachment?
      class MockIdentityService : IdentityService, SingletonSerializeAsToken
        Module Contents MockIdentityService(identities: List<Party>)
        val identities: List<Party>
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
      class MockKeyManagementService : SingletonSerializeAsToken, KeyManagementService
        Module Contents MockKeyManagementService(vararg initialKeys: KeyPair)
        fun freshKey(): KeyPair
        val keys: MutableMap<PublicKey, PrivateKey>
        val nextKeys: LinkedList<KeyPair>
      open class MockServices : ServiceHub
        Module Contents MockServices(key: KeyPair = generateKeyPair())
        open val clock: Clock
        open val identityService: MockIdentityService
        open fun <T : Any> invokeProtocolAsync(logicType: Class<out ProtocolLogic<T>>, vararg args: Any?): <ERROR CLASS><T>
        val key: KeyPair
        open val keyManagementService: MockKeyManagementService
        open val networkMapCache: NetworkMapCache
        open val networkService: MessagingService
        open fun recordTransactions(txs: Iterable<SignedTransaction>): Unit
        open val schedulerService: SchedulerService
        open val storageService: TxWritableStorageService
        open val walletService: WalletService
      class MockStorageService : SingletonSerializeAsToken, TxWritableStorageService
        Module Contents MockStorageService(attachments: AttachmentStorage = MockAttachmentStorage(), validatedTransactions: TransactionStorage = MockTransactionStorage(), myLegalIdentityKey: KeyPair = generateKeyPair(), myLegalIdentity: Party = Party("Unit test party", myLegalIdentityKey.public))
        val attachments: AttachmentStorage
        val myLegalIdentity: Party
        val myLegalIdentityKey: KeyPair
        val validatedTransactions: TransactionStorage
      open class MockTransactionStorage : TransactionStorage
        Module Contents MockTransactionStorage()
        open fun addTransaction(transaction: SignedTransaction): Unit
        open fun getTransaction(id: SecureHash): SignedTransaction?
    package com.r3corda.core.protocols
      Module Contents data class AppContext
        Module Contents AppContext(attachments: List<SecureHash>)
        val attachments: List<SecureHash>
        val classLoader: ClassLoader
      class IllegalProtocolLogicException : IllegalArgumentException
        Module Contents IllegalProtocolLogicException(type: Class<*>, msg: String)
      abstract class ProtocolLogic<out T>
        Module Contents ProtocolLogic()
        abstract fun call(): T
        val logger: <ERROR CLASS>
        open val progressTracker: ProgressTracker?
        lateinit var psm: ProtocolStateMachine<*>
        inline fun <reified T : Any> receive(sessionIDForReceive: Long): UntrustworthyData<T>
        fun <T : Any> receive(sessionIDForReceive: Long, receiveType: Class<T>): UntrustworthyData<T>
        fun send(destination: Party, sessionID: Long, payload: Any): Unit
        inline fun <reified T : Any> sendAndReceive(destination: Party, sessionIDForSend: Long, sessionIDForReceive: Long, payload: Any): UntrustworthyData<T>
        val serviceHub: ServiceHub
        fun <R> subProtocol(subLogic: ProtocolLogic<R>): R
        protected abstract val topic: String
      data class ProtocolLogicRef
        Module Contents val appContext: AppContext
        val args: Map<String, Any?>
        val protocolLogicClassName: String
      class ProtocolLogicRefFactory : SingletonSerializeAsToken
        Module Contents ProtocolLogicRefFactory()
        ProtocolLogicRefFactory(protocolWhitelist: Map<String, Set<String>>)
        fun create(type: Class<out ProtocolLogic<*>>, vararg args: Any?): ProtocolLogicRef
        fun createKotlin(protocolLogicClassName: String, args: Map<String, Any?>, attachments: List<SecureHash> = emptyList()): ProtocolLogicRef
        fun createKotlin(type: Class<out ProtocolLogic<*>>, args: Map<String, Any?>): ProtocolLogicRef
        fun toProtocolLogic(ref: ProtocolLogicRef): ProtocolLogic<*>
      interface ProtocolStateMachine<R>
        Module Contents abstract val logger: <ERROR CLASS>
        abstract fun <T : Any> receive(topic: String, sessionIDForReceive: Long, recvType: Class<T>): UntrustworthyData<T>
        abstract fun send(topic: String, destination: Party, sessionID: Long, payload: Any): Unit
        abstract fun <T : Any> sendAndReceive(topic: String, destination: Party, sessionIDForSend: Long, sessionIDForReceive: Long, payload: Any, recvType: Class<T>): UntrustworthyData<T>
        abstract val serviceHub: ServiceHub
    package com.r3corda.core.serialization
      Module Contents val ATTACHMENT_STORAGE: String
      interface DeserializeAsKotlinObjectDef
      object Ed25519PrivateKeySerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<<ERROR CLASS>>): <ERROR CLASS>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit
      object Ed25519PublicKeySerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<<ERROR CLASS>>): <ERROR CLASS>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit
      class ImmutableClassSerializer<T : Any>
        Module Contents ImmutableClassSerializer(klass: KClass<T>)
        val constructor: <ERROR CLASS>
        val klass: KClass<T>
        val props: <ERROR CLASS>
        val propsByName: <ERROR CLASS>
        fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<T>): T
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit
      object KotlinObjectSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<DeserializeAsKotlinObjectDef>): DeserializeAsKotlinObjectDef
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: DeserializeAsKotlinObjectDef): Unit
      class MissingAttachmentsException : Exception
        Module Contents MissingAttachmentsException(ids: List<SecureHash>)
        val ids: List<SecureHash>
      class NoReferencesSerializer<T>
        Module Contents NoReferencesSerializer(baseSerializer: <ERROR CLASS><T>)
        val baseSerializer: <ERROR CLASS><T>
        fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<T>): T
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit
      open class OpaqueBytes
        Module Contents OpaqueBytes(bits: ByteArray)
        val bits: ByteArray
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        fun of(vararg b: Byte): OpaqueBytes
        val size: Int
        open fun toString(): String
      object ReferencesAwareJavaSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<Any>): Any
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: Any): Unit
      interface SerializationToken
        Module Contents abstract fun fromToken(context: SerializeAsTokenContext): Any
      interface SerializeAsToken
        Module Contents abstract fun toToken(context: SerializeAsTokenContext): SerializationToken
      class SerializeAsTokenContext
        Module Contents SerializeAsTokenContext(toBeTokenized: Any, kryo: <ERROR CLASS> = createKryo())
      class SerializeAsTokenSerializer<T : SerializeAsToken>
        Module Contents SerializeAsTokenSerializer()
        fun clearContext(kryo: <ERROR CLASS>): Unit
        fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<T>): T
        fun setContext(kryo: <ERROR CLASS>, context: SerializeAsTokenContext): Unit
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit
      class SerializedBytes<T : Any> : OpaqueBytes
        Module Contents SerializedBytes(bits: ByteArray)
        val hash: SecureHash
        fun writeToFile(path: Path): Path
      object SerializedBytesSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<SerializedBytes<Any>>): SerializedBytes<Any>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: SerializedBytes<Any>): Unit
      data class SingletonSerializationToken : SerializationToken
        Module Contents SingletonSerializationToken(toBeTokenized: SerializeAsToken)
        fun fromToken(context: SerializeAsTokenContext): Any
        fun registerWithContext(token: SingletonSerializationToken, toBeTokenized: SerializeAsToken, context: SerializeAsTokenContext): SerializationToken
      abstract class SingletonSerializeAsToken : SerializeAsToken
        Module Contents SingletonSerializeAsToken()
        open fun toToken(context: SerializeAsTokenContext): SerializationToken
      val THREAD_LOCAL_KRYO: <ERROR CLASS>
      object WireTransactionSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<WireTransaction>): WireTransaction
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: WireTransaction): Unit
      var <ERROR CLASS>.attachmentStorage: AttachmentStorage?
      fun createKryo(k: <ERROR CLASS> = Kryo()): <ERROR CLASS>
      fun <T : Any> OpaqueBytes.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T
      fun SerializedBytes<WireTransaction>.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
      fun <T : Any> SerializedBytes<T>.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T
      kotlin.ByteArray
        Module Contents fun <T : Any> ByteArray.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T
        fun ByteArray.opaque(): OpaqueBytes
      inline fun <reified T : Any> <ERROR CLASS>.noReferencesWithin(): Unit
      fun <ERROR CLASS>.readBytesWithLength(): ByteArray
      fun <T : Any> T.serialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): SerializedBytes<T>
      inline fun <T> <ERROR CLASS>.useClassLoader(cl: ClassLoader, body: () -> T): T
      fun <ERROR CLASS>.writeBytesWithLength(byteArray: ByteArray): Unit
    package com.r3corda.core.testing
      Module Contents val ALICE: Party
      val ALICE_KEY: KeyPair
      val ALICE_PUBKEY: PublicKey
      val ALL_TEST_KEYS: List<KeyPair>
      class AlwaysSucceedContract : Contract
        Module Contents AlwaysSucceedContract(legalContractReference: SecureHash = SecureHash.sha256("Always succeed contract"))
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      class AttachmentResolutionException : Exception
        Module Contents AttachmentResolutionException(attachmentId: SecureHash)
      val BOB: Party
      val BOB_KEY: KeyPair
      val BOB_PUBKEY: PublicKey
      val CHARLIE: Party
      val CHARLIE_KEY: KeyPair
      val CHARLIE_PUBKEY: PublicKey
      val DUMMY_KEY_1: KeyPair
      val DUMMY_KEY_2: KeyPair
      val DUMMY_NOTARY: Party
      val DUMMY_NOTARY_KEY: KeyPair
      val DUMMY_PUBKEY_1: PublicKey
      val DUMMY_PUBKEY_2: PublicKey
      class DummyLinearState : LinearState
        Module Contents DummyLinearState(thread: SecureHash = SecureHash.randomSHA256(), contract: Contract = AlwaysSucceedContract(), participants: List<PublicKey> = listOf(), nonce: SecureHash = SecureHash.randomSHA256())
        val contract: Contract
        fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        val nonce: SecureHash
        val participants: List<PublicKey>
        val thread: SecureHash
      class DuplicateOutputLabel : Exception
        Module Contents DuplicateOutputLabel(label: String)
      sealed class EnforceVerifyOrFail
      open class InMemoryWalletService : SingletonSerializeAsToken, WalletService
        Module Contents InMemoryWalletService(services: ServiceHub)
        class ClashingThreads : Exception
          Module Contents ClashingThreads(threads: Set<SecureHash>, transactions: Iterable<WireTransaction>)
        val Wallet.clashingThreads: Set<SecureHash>
        open val currentWallet: Wallet
        open val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        open fun notifyAll(txns: Iterable<WireTransaction>): Wallet
        open val updates: <ERROR CLASS><Update>
      class LedgerDSL<out T : TransactionDSLInterpreter, out L : LedgerDSLInterpreter<T>> : LedgerDSLInterpreter<TransactionDSLInterpreter>
        Module Contents LedgerDSL(interpreter: L)
        val interpreter: L
        inline fun <reified S : ContractState> String.output(): S
        inline fun <reified S : ContractState> String.outputStateAndRef(): StateAndRef<S>
        fun <S : ContractState> retrieveOutput(clazz: Class<S>, label: String): S
        fun transaction(label: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(), dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): WireTransaction
        fun unverifiedTransaction(label: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(), dsl: TransactionDSL<TransactionDSLInterpreter>.() -> Unit): WireTransaction
      interface LedgerDSLInterpreter<out T : TransactionDSLInterpreter> : Verifies, OutputStateLookup
        Module Contents abstract fun _transaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<T>.() -> EnforceVerifyOrFail): WireTransaction
        abstract fun _unverifiedTransaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<T>.() -> Unit): WireTransaction
        abstract fun attachment(attachment: InputStream): SecureHash
        abstract fun tweak(dsl: LedgerDSL<T, LedgerDSLInterpreter<T>>.() -> Unit): Unit
      val MEGA_CORP: Party
      val MEGA_CORP_KEY: KeyPair
      val MEGA_CORP_PUBKEY: PublicKey
      val MINI_CORP: Party
      val MINI_CORP_KEY: KeyPair
      val MINI_CORP_PUBKEY: PublicKey
      val MOCK_IDENTITY_SERVICE: MockIdentityService
      val ORACLE_KEY: KeyPair
      val ORACLE_PUBKEY: PublicKey
      interface OutputStateLookup
        Module Contents abstract fun <S : ContractState> retrieveOutputStateAndRef(clazz: Class<S>, label: String): StateAndRef<S>
      val TEST_TX_TIME: Instant
      data class TestLedgerDSLInterpreter : LedgerDSLInterpreter<TestTransactionDSLInterpreter>
        Module Contents TestLedgerDSLInterpreter(services: ServiceHub)
        class TypeMismatch : Exception
          Module Contents TypeMismatch(requested: Class<*>, actual: Class<*>)
        class VerifiesFailed : Exception
          Module Contents VerifiesFailed(transactionName: String, cause: Throwable)
        fun _transaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<TestTransactionDSLInterpreter>.() -> EnforceVerifyOrFail): WireTransaction
        fun _unverifiedTransaction(transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TransactionDSL<TestTransactionDSLInterpreter>.() -> Unit): WireTransaction
        fun attachment(attachment: InputStream): SecureHash
        fun outputToLabel(state: ContractState): String?
        fun <S : ContractState> retrieveOutputStateAndRef(clazz: Class<S>, label: String): StateAndRef<S>
        val services: ServiceHub
        fun transactionName(transactionHash: SecureHash): String?
        val transactionsToVerify: List<WireTransaction>
        val transactionsUnverified: List<WireTransaction>
        fun tweak(dsl: LedgerDSL<TestTransactionDSLInterpreter, LedgerDSLInterpreter<TestTransactionDSLInterpreter>>.() -> Unit): Unit
        fun verifies(): EnforceVerifyOrFail
        val wireTransactions: List<WireTransaction>
      data class TestTransactionDSLInterpreter : TransactionDSLInterpreter, OutputStateLookup
        Module Contents TestTransactionDSLInterpreter(ledgerInterpreter: TestLedgerDSLInterpreter, transactionBuilder: TransactionBuilder)
        fun _command(signers: List<PublicKey>, commandData: CommandData): Unit
        fun _output(label: String?, notary: Party, contractState: ContractState): Unit
        fun attachment(attachmentId: SecureHash): Unit
        fun input(stateRef: StateRef): Unit
        val ledgerInterpreter: TestLedgerDSLInterpreter
        val services: ServiceHub
        val transactionBuilder: TransactionBuilder
        fun tweak(dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): EnforceVerifyOrFail
        fun verifies(): EnforceVerifyOrFail
      class TransactionDSL<out T : TransactionDSLInterpreter> : TransactionDSLInterpreter
        Module Contents TransactionDSL(interpreter: T)
        fun command(vararg signers: PublicKey, commandDataClosure: () -> CommandData): Unit
        fun command(signer: PublicKey, commandData: CommandData): Unit
        fun input(stateLabel: String): <ERROR CLASS>
        fun input(state: ContractState): Unit
        fun input(stateClosure: () -> ContractState): Unit
        val interpreter: T
        fun output(label: String? = null, notary: Party = DUMMY_NOTARY, contractStateClosure: () -> ContractState): Unit
        fun output(label: String, contractState: ContractState): Unit
        fun output(contractState: ContractState): Unit
        fun timestamp(time: Instant, tolerance: Duration = 30.seconds, notary: PublicKey = DUMMY_NOTARY.owningKey): Unit
        fun timestamp(data: TimestampCommand, notary: PublicKey = DUMMY_NOTARY.owningKey): Unit
      interface TransactionDSLInterpreter : Verifies, OutputStateLookup
        Module Contents abstract fun _command(signers: List<PublicKey>, commandData: CommandData): Unit
        abstract fun _output(label: String?, notary: Party, contractState: ContractState): Unit
        abstract fun attachment(attachmentId: SecureHash): Unit
        abstract fun input(stateRef: StateRef): Unit
        abstract val ledgerInterpreter: LedgerDSLInterpreter<TransactionDSLInterpreter>
        abstract fun tweak(dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): EnforceVerifyOrFail
      interface Verifies
        Module Contents open fun fails(): EnforceVerifyOrFail
        open infix fun fails with(msg: String): EnforceVerifyOrFail
        open fun failsWith(expectedMessage: String?): EnforceVerifyOrFail
        abstract fun verifies(): EnforceVerifyOrFail
      fun freeLocalHostAndPort(): <ERROR CLASS>
      fun generateStateRef(): StateRef
      fun ledger(services: ServiceHub = MockServices(), dsl: LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.() -> Unit): LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>
      fun TransactionDSLInterpreter.ledger(dsl: LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.() -> Unit): Unit
      fun LedgerDSLInterpreter<TransactionDSLInterpreter>.ledger(dsl: LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.() -> Unit): Unit
      inline fun <R> rootCauseExceptions(body: () -> R): R
      fun signAll(transactionsToSign: List<WireTransaction>, extraKeys: List<KeyPair>): <ERROR CLASS>
      fun LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.signAll(vararg extraKeys: KeyPair): <ERROR CLASS>
      fun transaction(transactionLabel: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(), dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>
      fun TransactionDSLInterpreter.transaction(dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail): Unit
    package com.r3corda.core.utilities
      Module Contents class BriefLogFormatter : Formatter
        Module Contents BriefLogFormatter()
        fun format(logRecord: LogRecord): String
        fun init(): Unit
        fun initVerbose(vararg loggerNames: String): Unit
        fun loggingOff(vararg names: String): Unit
        fun loggingOff(vararg classes: KClass<*>): Unit
        fun loggingOn(vararg names: String): Unit
        fun loggingOn(vararg classes: KClass<*>): Unit
      object Emoji
        Module Contents const val CODE_BAG_OF_CASH: String
        const val CODE_DIAMOND: String
        const val CODE_GREEN_TICK: String
        const val CODE_LEFT_ARROW: String
        const val CODE_NEWSPAPER: String
        const val CODE_PAPERCLIP: String
        const val CODE_RIGHT_ARROW: String
        val bagOfCash: String
        val diamond: String
        val hasEmojiTerminal: <ERROR CLASS>
        val leftArrow: String
        val newspaper: String
        val paperclip: String
        fun renderIfSupported(obj: Any): String
        val rightArrow: String
      class NonEmptySet<T> : MutableSet<T>
        Module Contents NonEmptySet(initial: T)
        inner class Iterator<out T, T> : MutableIterator<T>
          Module Contents Iterator(iterator: MutableIterator<T>)
          fun hasNext(): Boolean
          val iterator: MutableIterator<T>
          fun next(): T
          fun remove(): Unit
        fun add(element: T): Boolean
        fun addAll(elements: Collection<T>): Boolean
        fun clear(): Nothing
        fun contains(element: T): Boolean
        fun containsAll(elements: Collection<T>): Boolean
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        fun isEmpty(): Boolean
        fun iterator(): MutableIterator<T>
        fun remove(element: T): Boolean
        fun removeAll(elements: Collection<T>): Boolean
        fun retainAll(elements: Collection<T>): Boolean
        val size: Int
        fun toString(): String
      object NonEmptySetSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<NonEmptySet<Any>>): NonEmptySet<Any>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: NonEmptySet<Any>): Unit
      class ProgressTracker
        Module Contents ProgressTracker(vararg steps: Step)
        sealed class Change
          Module Contents class Position : Change
            Module Contents Position(tracker: ProgressTracker, newStep: Step)
            val newStep: Step
            fun toString(): String
            val tracker: ProgressTracker
          class Rendering : Change
            Module Contents Rendering(tracker: ProgressTracker, ofStep: Step)
            val ofStep: Step
            fun toString(): String
            val tracker: ProgressTracker
          class Structural : Change
            Module Contents Structural(tracker: ProgressTracker, parent: Step)
            val parent: Step
            fun toString(): String
            val tracker: ProgressTracker
        object DONE : Step
          Module Contents fun equals(other: Any?): Boolean
        inner class RelabelableStep : Step
          Module Contents RelabelableStep(currentLabel: String)
          open val changes: <ERROR CLASS>
          var currentLabel: String
          open val label: String
        class Step
          Module Contents Step(label: String)
          open val changes: <ERROR CLASS><Change>
          open fun childProgressTracker(): ProgressTracker?
          open val label: String
        object UNSTARTED : Step
          Module Contents fun equals(other: Any?): Boolean
        val allSteps: List<<ERROR CLASS><Int, Step>>
        val changes: <ERROR CLASS><Change>
        var currentStep: Step
        val currentStepRecursive: Step
        fun getChildProgressTracker(step: Step): ProgressTracker?
        fun nextStep(): Step
        var parent: ProgressTracker?
        fun setChildProgressTracker(step: Step, childProgressTracker: ProgressTracker): Unit
        var stepIndex: Int
        val steps: Array<Step>
        val topLevelTracker: ProgressTracker
      data class TimeWindow
        Module Contents TimeWindow(start: Instant, duration: Duration)
        val duration: Duration
        val end: Instant
        val start: Instant
      class UntrustworthyData<out T>
        Module Contents UntrustworthyData(fromUntrustedWorld: T)
        val data: T
        inline fun <R> validate(validator: (T) -> R): R
      inline fun <reified T : Any> loggerFor(): <ERROR CLASS>
      fun <T> nonEmptySetOf(initial: T, vararg elements: T): NonEmptySet<T>
      fun suggestInterestRateAnnouncementTimeWindow(index: String, source: String, date: LocalDate): TimeWindow
      inline fun <ERROR CLASS>.trace(msg: () -> String): Unit
    package com.r3corda.demos
      Module Contents sealed class CliParams
        Module Contents class DateChange : CliParams
          Module Contents DateChange(apiAddress: <ERROR CLASS>, dateString: String)
          val apiAddress: <ERROR CLASS>
          val dateString: String
        object Help : CliParams
        class RunNode : CliParams
          Module Contents RunNode(node: IRSDemoNode, dir: Path, networkAddress: <ERROR CLASS>, apiAddress: <ERROR CLASS>, mapAddress: String, identityFile: Path, tradeWithIdentities: List<Path>, uploadRates: Boolean, defaultLegalName: String, autoSetup: Boolean)
          val apiAddress: <ERROR CLASS>
          val autoSetup: Boolean
          val defaultLegalName: String
          val dir: Path
          val identityFile: Path
          val mapAddress: String
          val networkAddress: <ERROR CLASS>
          val node: IRSDemoNode
          val tradeWithIdentities: List<Path>
          val uploadRates: Boolean
        class SetupNode : CliParams
          Module Contents SetupNode(node: IRSDemoNode, dir: Path, defaultLegalName: String)
          val defaultLegalName: String
          val dir: Path
          val node: IRSDemoNode
        class Trade : CliParams
          Module Contents Trade(apiAddress: <ERROR CLASS>, tradeId: String)
          val apiAddress: <ERROR CLASS>
          val tradeId: String
        val defaultBaseDirectory: String
        fun legalName(node: IRSDemoNode): String
        fun parse(options: <ERROR CLASS>): CliParams
      object CliParamsSpec
        Module Contents val apiAddressArg: <ERROR CLASS>
        val baseDirectoryArg: <ERROR CLASS>
        val fakeTradeWithIdentityFile: <ERROR CLASS>
        val help: <ERROR CLASS>
        val networkAddressArg: <ERROR CLASS>
        val networkMapIdentityFile: <ERROR CLASS>
        val networkMapNetAddr: <ERROR CLASS>
        val nonOptions: <ERROR CLASS>
        val parser: <ERROR CLASS>
        val roleArg: <ERROR CLASS>
      val DEFAULT_BASE_DIRECTORY: String
      val DEMO_TOPIC: String
      class DemoClock : MutableClock, SerializeAsToken
        Module Contents DemoClock(delegateClock: Clock = Clock.systemUTC())
        fun getZone(): ZoneId
        fun instant(): Instant
        fun toToken(context: SerializeAsTokenContext): SerializationToken
        fun updateDate(date: LocalDate): Boolean
        fun withZone(zone: ZoneId): Clock
      enum class IRSDemoNode
        Module Contents NodeA
        NodeB
        val other: IRSDemoNode
      class IRSDemoPluginRegistry : CordaPluginRegistry
        Module Contents IRSDemoPluginRegistry()
        val requiredProtocols: Map<String, Set<String>>
        val staticServeDirs: Map<String, String>
        val webApis: List<Class<*>>
      enum class IRSDemoRole
        Module Contents Date
        NodeA
        NodeB
        SetupNodeA
        SetupNodeB
        Trade
      enum class Role
        Module Contents BUYER
        SELLER
      fun main(args: Array<String>): Unit
      fun main(args: Array<String>): Unit
      fun main(args: Array<String>): Unit
      fun runIRSDemo(args: Array<String>): Int
      fun runTraderDemo(args: Array<String>): Int
    package com.r3corda.demos.api
      Module Contents class InterestRateSwapAPI
        Module Contents InterestRateSwapAPI(services: ServiceHub)
        fun exitServer(): <ERROR CLASS>
        fun fetchDeal(ref: String): <ERROR CLASS>
        fun fetchDeals(): Array<State>
        fun fetchDemoDate(): LocalDate
        val services: ServiceHub
        fun storeDeal(newDeal: State): <ERROR CLASS>
        fun storeDemoDate(newDemoDate: LocalDate): <ERROR CLASS>
    package com.r3corda.demos.protocols
      Module Contents object AutoOfferProtocol
        Module Contents data class AutoOfferMessage
          Module Contents AutoOfferMessage(otherSide: Party, notary: Party, otherSessionID: Long, dealBeingOffered: DealState)
          val dealBeingOffered: DealState
          val notary: Party
          val otherSessionID: Long
          val otherSide: Party
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Requester : ProtocolLogic<SignedTransaction>
          Module Contents Requester(dealToBeOffered: DealState)
          object ANNOUNCING : Step
          object DEALING : Step
            Module Contents fun childProgressTracker(): ProgressTracker
          object RECEIVED : Step
          fun call(): SignedTransaction
          val dealToBeOffered: DealState
          val progressTracker: ProgressTracker
          protected val topic: String
          fun tracker(): ProgressTracker
        class Service
          Module Contents Service(services: ServiceHubInternal)
          class Callback
            Module Contents Callback(success: (SignedTransaction) -> Unit)
            fun onFailure(t: Throwable?): Unit
            fun onSuccess(st: SignedTransaction?): Unit
            val success: (SignedTransaction) -> Unit
          object DEALING : Step
            Module Contents fun childProgressTracker(): ProgressTracker
          object RECEIVED : Step
          fun tracker(): ProgressTracker
        val TOPIC: String
      object ExitServerProtocol
        Module Contents class Broadcast : ProtocolLogic<Boolean>
          Module Contents Broadcast(exitCode: Int)
          fun call(): Boolean
          val exitCode: Int
          protected val topic: String
        data class ExitMessage
          Module Contents ExitMessage(exitCode: Int)
          val exitCode: Int
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service
          Module Contents Service(services: ServiceHubInternal)
        val TOPIC: String
      object UpdateBusinessDayProtocol
        Module Contents class Broadcast : ProtocolLogic<Unit>
          Module Contents Broadcast(date: LocalDate, progressTracker: ProgressTracker = Broadcast.tracker())
          object NOTIFYING : Step
          fun call(): Unit
          val date: LocalDate
          val progressTracker: ProgressTracker
          protected val topic: String
          fun tracker(): ProgressTracker
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service
          Module Contents Service(services: ServiceHubInternal)
        val TOPIC: String
        data class UpdateBusinessDayMessage
          Module Contents UpdateBusinessDayMessage(date: LocalDate)
          val date: LocalDate
    package com.r3corda.demos.utilities
      Module Contents fun postJson(url: URL, data: String): Boolean
      fun putJson(url: URL, data: String): Boolean
      fun uploadFile(url: URL, file: String): Boolean
    package com.r3corda.node
      Module Contents object ParamsSpec
        Module Contents val baseDirectoryArg: <ERROR CLASS>
        val configFileArg: <ERROR CLASS>
        val parser: <ERROR CLASS>
      val log: <ERROR CLASS>
      fun main(args: Array<String>): Unit
    package com.r3corda.node.api
      Module Contents interface APIServer
        Module Contents abstract fun buildTransaction(type: ContractDefRef, steps: List<TransactionBuildStep>): SerializedBytes<WireTransaction>
        abstract fun commitTransaction(tx: SerializedBytes<WireTransaction>, signatures: List<WithKey>): SecureHash
        abstract fun fetchProtocolsRequiringAttention(query: StatesQuery): Map<StateRef, ProtocolRequiringAttention>
        abstract fun fetchStates(states: List<StateRef>): Map<StateRef, TransactionState<ContractState>?>
        abstract fun fetchTransactions(txs: List<SecureHash>): Map<SecureHash, SignedTransaction?>
        abstract fun generateTransactionSignature(tx: SerializedBytes<WireTransaction>): WithKey
        abstract fun invokeProtocolSync(type: ProtocolRef, args: Map<String, Any?>): Any?
        abstract fun provideProtocolResponse(protocol: ProtocolInstanceRef, choice: SecureHash, args: Map<String, Any?>): Unit
        abstract fun queryStates(query: StatesQuery): List<StateRef>
        abstract fun serverTime(): LocalDateTime
        abstract fun status(): <ERROR CLASS>
      data class ContractClassRef : ContractDefRef
        Module Contents ContractClassRef(className: String)
        val className: String
      interface ContractDefRef
      data class ContractLedgerRef : ContractDefRef
        Module Contents ContractLedgerRef(hash: SecureHash)
        val hash: SecureHash
      data class ProtocolClassRef : ProtocolRef
        Module Contents ProtocolClassRef(className: String)
        val className: String
      data class ProtocolInstanceRef
        Module Contents ProtocolInstanceRef(protocolInstance: SecureHash, protocolClass: ProtocolClassRef, protocolStepId: String)
        val protocolClass: ProtocolClassRef
        val protocolInstance: SecureHash
        val protocolStepId: String
      interface ProtocolRef
      data class ProtocolRequiringAttention
        Module Contents ProtocolRequiringAttention(ref: ProtocolInstanceRef, prompt: String, choiceIdsToMessages: Map<SecureHash, String>, dueBy: Instant)
        val choiceIdsToMessages: Map<SecureHash, String>
        val dueBy: Instant
        val prompt: String
        val ref: ProtocolInstanceRef
      interface StatesQuery
        Module Contents interface Criteria
          Module Contents object AllDeals : Criteria
          data class Deal : Criteria
            Module Contents Deal(ref: String)
            val ref: String
        data class Selection : StatesQuery
          Module Contents Selection(criteria: Criteria)
          val criteria: Criteria
        fun select(criteria: Criteria): Selection
      data class TransactionBuildStep
        Module Contents TransactionBuildStep(generateMethodName: String, args: Map<String, Any?>)
        val args: Map<String, Any?>
        val generateMethodName: String
    package com.r3corda.node.internal
      Module Contents class APIServerImpl : APIServer
        Module Contents APIServerImpl(node: AbstractNode)
        fun buildTransaction(type: ContractDefRef, steps: List<TransactionBuildStep>): SerializedBytes<WireTransaction>
        fun commitTransaction(tx: SerializedBytes<WireTransaction>, signatures: List<WithKey>): SecureHash
        fun fetchProtocolsRequiringAttention(query: StatesQuery): Map<StateRef, ProtocolRequiringAttention>
        fun fetchStates(states: List<StateRef>): Map<StateRef, TransactionState<ContractState>?>
        fun fetchTransactions(txs: List<SecureHash>): Map<SecureHash, SignedTransaction?>
        fun generateTransactionSignature(tx: SerializedBytes<WireTransaction>): WithKey
        fun invokeProtocolSync(type: ProtocolRef, args: Map<String, Any?>): Any?
        val node: AbstractNode
        fun provideProtocolResponse(protocol: ProtocolInstanceRef, choice: SecureHash, args: Map<String, Any?>): Unit
        fun queryStates(query: StatesQuery): List<StateRef>
        fun serverTime(): LocalDateTime
        fun status(): <ERROR CLASS>
      abstract class AbstractNode : SingletonSerializeAsToken
        Module Contents AbstractNode(dir: Path, configuration: NodeConfiguration, networkMapService: NodeInfo?, advertisedServices: Set<ServiceType>, platformClock: Clock)
        val PRIVATE_KEY_FILE_NAME: String
        val PUBLIC_IDENTITY_FILE_NAME: String
        protected val _servicesThatAcceptUploads: ArrayList<AcceptsFileUpload>
        val advertisedServices: Set<ServiceType>
        lateinit var api: APIServer
        lateinit var checkpointStorage: CheckpointStorage
        val configuration: NodeConfiguration
        protected open fun constructStorageService(attachments: NodeAttachmentService, transactionStorage: TransactionStorage, keypair: KeyPair, identity: Party): StorageServiceImpl
        protected fun createNodeDir(): Unit
        val customServices: ArrayList<Any>
        val dir: Path
        open fun findMyLocation(): PhysicalLocation?
        inline fun <reified T : Any> findService(): <ERROR CLASS>
        protected open fun generateKeyPair(): KeyPair
        lateinit var identity: IdentityService
        var inNodeNetworkMapService: NetworkMapService?
        var inNodeNotaryService: NotaryService?
        val info: NodeInfo
        protected open fun initialiseStorageService(dir: Path): <ERROR CLASS><TxWritableStorageService, CheckpointStorage>
        var isPreviousCheckpointsPresent: Boolean
        lateinit var keyManagement: E2ETestKeyManagementService
        protected abstract val log: <ERROR CLASS>
        protected fun makeAttachmentStorage(dir: Path): NodeAttachmentService
        protected open fun makeIdentityService(): IdentityService
        protected abstract fun makeMessagingService(): MessagingServiceInternal
        protected open fun makeNetworkMapService(): Unit
        protected open fun makeNotaryService(type: ServiceType): Unit
        lateinit var net: MessagingServiceInternal
        lateinit var netMapCache: NetworkMapCache
        val networkMapRegistrationFuture: <ERROR CLASS><Unit>
        var networkMapSeq: Long
        val networkMapService: NodeInfo?
        protected open fun noNetworkMapConfigured(): <ERROR CLASS><Unit>
        val platformClock: Clock
        protected val pluginRegistries: List<CordaPluginRegistry>
        lateinit var protocolLogicFactory: ProtocolLogicRefFactory
        lateinit var scheduler: SchedulerService
        protected abstract val serverThread: AffinityExecutor
        val services: ServiceHubInternal
        val servicesThatAcceptUploads: List<AcceptsFileUpload>
        open fun setup(): AbstractNode
        lateinit var smm: StateMachineManager
        open fun start(): AbstractNode
        protected abstract fun startMessagingService(): Unit
        var started: Boolean
        open fun stop(): Unit
        lateinit var storage: TxWritableStorageService
        lateinit var wallet: WalletService
      class ConfigurationException : Exception
        Module Contents ConfigurationException(message: String)
      class Node : AbstractNode
        Module Contents Node(dir: Path, p2pAddr: <ERROR CLASS>, webServerAddr: <ERROR CLASS>, configuration: NodeConfiguration, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, clock: Clock = NodeClock(), messagingServerAddr: <ERROR CLASS>? = null)
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingServiceInternal
        var messageBroker: ArtemisMessagingServer?
        val messagingServerAddr: <ERROR CLASS>?
        val p2pAddr: <ERROR CLASS>
        protected val serverThread: ServiceAffinityExecutor
        fun setup(): Node
        fun start(): Node
        protected fun startMessagingService(): Unit
        fun stop(): Unit
        lateinit var webServer: <ERROR CLASS>
        val webServerAddr: <ERROR CLASS>
    package com.r3corda.node.internal.testing
      Module Contents class IRSSimulation : Simulation
        Module Contents IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: LatencyCalculator?)
        fun iterate(): MessageTransfer?
        val om: <ERROR CLASS>
        protected fun startMainSimulation(): <ERROR CLASS><Unit>
      class MockNetwork
        Module Contents MockNetwork(networkSendManuallyPumped: Boolean = false, threadPerNode: Boolean = false, defaultFactory: Factory = MockNetwork.DefaultFactory)
        object DefaultFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        interface Factory
          Module Contents abstract fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        class MockNode : AbstractNode
          Module Contents MockNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?)
          open fun findMyLocation(): PhysicalLocation?
          protected open fun generateKeyPair(): KeyPair
          val id: Int
          val keyPair: KeyPair?
          protected open val log: <ERROR CLASS>
          protected open fun makeIdentityService(): MockIdentityService
          protected open fun makeMessagingService(): MessagingServiceInternal
          val mockNet: MockNetwork
          protected open fun noNetworkMapConfigured(): <ERROR CLASS>
          val place: PhysicalLocation
          protected open val serverThread: AffinityExecutor
          open fun start(): MockNode
          protected open fun startMessagingService(): Unit
        fun addressToNode(address: SingleMessageRecipient): MockNode
        fun createNode(networkMapAddress: NodeInfo? = null, forcedID: Int = -1, nodeFactory: Factory = defaultFactory, start: Boolean = true, legalName: String? = null, keyPair: KeyPair? = null, vararg advertisedServices: ServiceType): MockNode
        fun createNotaryNode(legalName: String? = null, keyPair: KeyPair? = null): MockNode
        fun createPartyNode(networkMapAddr: NodeInfo, legalName: String? = null, keyPair: KeyPair? = null): MockNode
        fun createTwoNodes(nodeFactory: Factory = defaultFactory, notaryKeyPair: KeyPair? = null): <ERROR CLASS><MockNode, MockNode>
        val filesystem: <ERROR CLASS>
        val identities: ArrayList<Party>
        val messagingNetwork: InMemoryMessagingNetwork
        val nodes: List<MockNode>
        fun runNetwork(rounds: Int = -1): Unit
        fun startNodes(): Unit
        fun stopNodes(): Unit
      abstract class Simulation
        Module Contents Simulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: LatencyCalculator?)
        inner class BankFactory : Factory
          Module Contents BankFactory()
          var counter: Int
          fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
          fun createAll(): List<SimulatedNode>
        object NetworkMapNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        object NotaryNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        object RatesOracleFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        object RegulatorFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): MockNode
        open class SimulatedNode : MockNode
          Module Contents SimulatedNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?)
          open fun findMyLocation(): PhysicalLocation?
        val allProtocolSteps: <ERROR CLASS><<ERROR CLASS><SimulatedNode, Change>>
        val bankFactory: BankFactory
        val bankLocations: <ERROR CLASS>
        val banks: List<SimulatedNode>
        val clocks: <ERROR CLASS>
        var currentDateAndTime: LocalDateTime
        val dateChanges: <ERROR CLASS><LocalDateTime>
        val doneSteps: <ERROR CLASS><Collection<SimulatedNode>>
        val extraNodeLabels: MutableMap<SimulatedNode, String>
        open fun iterate(): MessageTransfer?
        val network: MockNetwork
        val networkInitialisationFinished: <ERROR CLASS><out <ERROR CLASS>>
        val networkMap: SimulatedNode
        val networkSendManuallyPumped: Boolean
        val notary: SimulatedNode
        val ratesOracle: SimulatedNode
        val regulators: List<SimulatedNode>
        val serviceProviders: List<SimulatedNode>
        protected fun showConsensusFor(nodes: List<SimulatedNode>): Unit
        protected fun showProgressFor(nodes: List<SimulatedNode>): Unit
        fun start(): <ERROR CLASS><Unit>
        protected open fun startMainSimulation(): <ERROR CLASS><Unit>
        fun startTradingCircle(tradeBetween: (Int, Int) -> <ERROR CLASS><out <ERROR CLASS>>): Unit
        fun stop(): Unit
      class TestClock : MutableClock, SerializeAsToken
        Module Contents TestClock(delegateClock: Clock = Clock.systemUTC())
        fun advanceBy(duration: Duration): Unit
        fun getZone(): ZoneId
        fun instant(): Instant
        fun setTo(newInstant: Instant): Unit
        fun toToken(context: SerializeAsTokenContext): SerializationToken
        fun withZone(zone: ZoneId): Clock
      class TradeSimulation : Simulation
        Module Contents TradeSimulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        protected fun startMainSimulation(): <ERROR CLASS><Unit>
      kotlin.collections.Iterable
        Module Contents fun Iterable<TestClock>.setTo(instant: Instant): <ERROR CLASS>
    package com.r3corda.node.serialization
      Module Contents class NodeClock : Clock, SerializeAsToken
        Module Contents NodeClock(delegateClock: Clock = Clock.systemUTC())
        fun getZone(): ZoneId
        fun instant(): Instant
        fun toToken(context: SerializeAsTokenContext): SerializationToken
        fun withZone(zone: ZoneId): Clock
    package com.r3corda.node.services
      Module Contents object NotaryChange
        Module Contents class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service : AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
          val services: ServiceHubInternal
    package com.r3corda.node.services.api
      Module Contents abstract class AbstractNodeService : SingletonSerializeAsToken
        Module Contents AbstractNodeService(net: MessagingService, networkMapCache: NetworkMapCache)
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R, crossinline exceptionConsumer: (Message, Exception) -> Unit): Unit
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R): Unit
        val net: MessagingService
        val networkMapCache: NetworkMapCache
      interface AcceptsFileUpload
        Module Contents abstract val acceptableFileExtensions: List<String>
        abstract val dataTypePrefix: String
        abstract fun upload(data: InputStream): String
      data class Checkpoint
        Module Contents Checkpoint(serialisedFiber: SerializedBytes<ProtocolStateMachineImpl<*>>, request: FiberRequest?)
        val request: FiberRequest?
        val serialisedFiber: SerializedBytes<ProtocolStateMachineImpl<*>>
      interface CheckpointStorage
        Module Contents abstract fun addCheckpoint(checkpoint: Checkpoint): Unit
        abstract val checkpoints: Iterable<Checkpoint>
        abstract fun removeCheckpoint(checkpoint: Checkpoint): Unit
      interface MessagingServiceBuilder<out T : MessagingServiceInternal>
        Module Contents abstract fun start(): <ERROR CLASS><out T>
      interface MessagingServiceInternal : MessagingService
        Module Contents abstract fun stop(): Unit
      class MonitoringService : SingletonSerializeAsToken
        Module Contents MonitoringService(metrics: <ERROR CLASS>)
        val metrics: <ERROR CLASS>
      interface RegulatorService
        Module Contents object Type : ServiceType
      abstract class ServiceHubInternal : ServiceHub
        Module Contents ServiceHubInternal()
        open fun <T : Any> invokeProtocolAsync(logicType: Class<out ProtocolLogic<T>>, vararg args: Any?): <ERROR CLASS><T>
        abstract val monitoringService: MonitoringService
        abstract val networkService: MessagingServiceInternal
        abstract val protocolLogicRefFactory: ProtocolLogicRefFactory
        abstract fun <T> startProtocol(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
    package com.r3corda.node.services.clientapi
      Module Contents object FixingSessionInitiation
        Module Contents class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service
          Module Contents Service(services: ServiceHubInternal)
      object NodeInterestRates
        Module Contents class FixContainer
          Module Contents FixContainer(fixes: List<Fix>, factory: InterpolatorFactory = CubicSplineInterpolator)
          val factory: InterpolatorFactory
          operator fun get(fixOf: FixOf): Fix?
          val size: Int
        class InterpolatingRateMap
          Module Contents InterpolatingRateMap(date: LocalDate, inputRates: Map<Tenor, BigDecimal>, calendar: BusinessCalendar, factory: InterpolatorFactory)
          val calendar: BusinessCalendar
          val date: LocalDate
          val factory: InterpolatorFactory
          fun getRate(tenor: Tenor): BigDecimal?
          val size: Int
        class Oracle
          Module Contents Oracle(identity: Party, signingKey: KeyPair, clock: Clock)
          val clock: Clock
          val identity: Party
          var knownFixes: FixContainer
          fun query(queries: List<FixOf>, deadline: Instant): List<Fix>
          fun sign(wtx: WireTransaction): LegallyIdentifiable
        class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val requiredProtocols: Map<String, Set<String>>
          val servicePlugins: List<Class<*>>
        class Service : AcceptsFileUpload, AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
          val acceptableFileExtensions: <ERROR CLASS>
          val dataTypePrefix: String
          val oracle: Oracle
          val ss: StorageService
          fun upload(data: InputStream): String
        object Type : ServiceType
        class UnknownFix : RetryableException
          Module Contents UnknownFix(fix: FixOf)
          val fix: FixOf
        fun parseFile(s: String): FixContainer
        fun parseFix(s: String): Fix
        fun parseFixOf(key: String): FixOf
    package com.r3corda.node.services.config
      Module Contents class FullNodeConfiguration : NodeConfiguration
        Module Contents FullNodeConfiguration(conf: <ERROR CLASS>)
        val artemisAddress: <ERROR CLASS>
        val basedir: Path
        val clock: Clock
        fun createNode(): Node
        val exportJMXto: String
        val extraAdvertisedServiceIds: String
        val hostNotaryServiceLocally: Boolean
        val keyStorePassword: String
        val mapService: NameServiceConfig
        val messagingServerAddress: <ERROR CLASS>?
        val myLegalName: String
        val nearestCity: String
        val trustStorePassword: String
        val webAddress: <ERROR CLASS>
      class NameServiceConfig
        Module Contents NameServiceConfig(conf: <ERROR CLASS>)
        val address: <ERROR CLASS>
        val hostServiceLocally: Boolean
        val identity: String
      interface NodeConfiguration
        Module Contents abstract val exportJMXto: String
        abstract val keyStorePassword: String
        abstract val myLegalName: String
        abstract val nearestCity: String
        abstract val trustStorePassword: String
      class NodeConfigurationFromConfig : NodeConfiguration
        Module Contents NodeConfigurationFromConfig(config: <ERROR CLASS> = ConfigFactory.load())
        val config: <ERROR CLASS>
        val exportJMXto: String
        val keyStorePassword: String
        val myLegalName: String
        val nearestCity: String
        val trustStorePassword: String
      operator fun <T> <ERROR CLASS>.getValue(receiver: Any, metadata: KProperty<*>): T
    package com.r3corda.node.services.events
      Module Contents class NodeSchedulerService : SchedulerService, SingletonSerializeAsToken
        Module Contents NodeSchedulerService(services: ServiceHubInternal, protocolLogicRefFactory: ProtocolLogicRefFactory = ProtocolLogicRefFactory(), schedulerTimerExecutor: Executor = Executors.newSingleThreadExecutor())
        fun scheduleStateActivity(action: ScheduledStateRef): Unit
        fun unscheduleStateActivity(ref: StateRef): Unit
      class ScheduledActivityObserver
        Module Contents ScheduledActivityObserver(services: ServiceHubInternal)
        val services: ServiceHubInternal
    package com.r3corda.node.services.identity
      Module Contents class InMemoryIdentityService : SingletonSerializeAsToken, IdentityService
        Module Contents InMemoryIdentityService()
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
    package com.r3corda.node.services.keys
      Module Contents class E2ETestKeyManagementService : SingletonSerializeAsToken, KeyManagementService
        Module Contents E2ETestKeyManagementService(initialKeys: Set<KeyPair>)
        fun freshKey(): KeyPair
        val keys: Map<PublicKey, PrivateKey>
    package com.r3corda.node.services.messaging
      Module Contents class ArtemisMessagingClient : ArtemisMessagingComponent, MessagingServiceInternal
        Module Contents ArtemisMessagingClient(directory: Path, config: NodeConfiguration, serverHostPort: <ERROR CLASS>, myHostPort: <ERROR CLASS>, defaultExecutor: Executor = RunOnCallerThread)
        data class Handler : MessageHandlerRegistration
          Module Contents Handler(executor: Executor?, topicSession: TopicSession, callback: (Message, MessageHandlerRegistration) -> Unit)
          val callback: (Message, MessageHandlerRegistration) -> Unit
          val executor: Executor?
          val topicSession: TopicSession
        val SESSION_ID_PROPERTY: String
        val TOPIC_PROPERTY: String
        fun addMessageHandler(topic: String, sessionID: Long, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        fun addMessageHandler(topicSession: TopicSession, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        fun createMessage(topicSession: TopicSession, data: ByteArray): Message
        fun createMessage(topic: String, sessionID: Long, data: ByteArray): Message
        val defaultExecutor: Executor
        val log: <ERROR CLASS>
        fun makeRecipient(hostAndPort: <ERROR CLASS>): SingleMessageRecipient
        fun makeRecipient(hostname: String): <ERROR CLASS>
        val myAddress: SingleMessageRecipient
        val myHostPort: <ERROR CLASS>
        fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        fun send(message: Message, target: MessageRecipients): Unit
        val serverHostPort: <ERROR CLASS>
        fun start(): Unit
        fun stop(): Unit
        fun toHostAndPort(hostname: String): <ERROR CLASS>
      abstract class ArtemisMessagingComponent : SingletonSerializeAsToken
        Module Contents ArtemisMessagingComponent(directory: Path, config: NodeConfiguration)
        protected data class Address : SingleMessageRecipient
          Module Contents Address(hostAndPort: <ERROR CLASS>)
          val hostAndPort: <ERROR CLASS>
        protected enum class ConnectionDirection
          Module Contents INBOUND
          OUTBOUND
        val config: NodeConfiguration
        fun configureWithDevSSLCertificate(): Unit
        val directory: Path
        protected fun tcpTransport(direction: ConnectionDirection, host: String, port: Int): <ERROR CLASS>
      class ArtemisMessagingServer : ArtemisMessagingComponent
        Module Contents ArtemisMessagingServer(directory: Path, config: NodeConfiguration, myHostPort: <ERROR CLASS>)
        val log: <ERROR CLASS>
        val myAddress: SingleMessageRecipient
        val myHostPort: <ERROR CLASS>
        fun start(): Unit
        fun stop(): Unit
    package com.r3corda.node.services.network
      Module Contents class InMemoryMessagingNetwork : SingletonSerializeAsToken
        Module Contents InMemoryMessagingNetwork(sendManuallyPumped: Boolean)
        inner class Builder : MessagingServiceBuilder<InMemoryMessaging>
          Module Contents Builder(manuallyPumped: Boolean, id: Handle)
          val id: Handle
          val manuallyPumped: Boolean
          fun start(): <ERROR CLASS><InMemoryMessaging>
        class Handle : SingleMessageRecipient
          Module Contents Handle(id: Int, description: String)
          val description: String
          fun equals(other: Any?): Boolean
          fun hashCode(): Int
          val id: Int
          fun toString(): String
        inner class InMemoryMessaging : SingletonSerializeAsToken, MessagingServiceInternal
          Module Contents InMemoryMessaging(manuallyPumped: Boolean, handle: Handle)
          inner class Handler : MessageHandlerRegistration
            Module Contents Handler(executor: Executor?, topicSession: TopicSession, callback: (Message, MessageHandlerRegistration) -> Unit)
            val callback: (Message, MessageHandlerRegistration) -> Unit
            val executor: Executor?
            val topicSession: TopicSession
          fun addMessageHandler(topic: String, sessionID: Long, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
          fun addMessageHandler(topicSession: TopicSession, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
          fun createMessage(topic: String, sessionID: Long, data: ByteArray): Message
          fun createMessage(topicSession: TopicSession, data: ByteArray): Message
          val myAddress: SingleMessageRecipient
          fun pumpReceive(block: Boolean): MessageTransfer?
          fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
          fun send(message: Message, target: MessageRecipients): Unit
          fun stop(): Unit
        interface LatencyCalculator
          Module Contents abstract fun between(sender: SingleMessageRecipient, receiver: SingleMessageRecipient): Duration
        val MESSAGES_LOG_NAME: String
        data class MessageTransfer
          Module Contents MessageTransfer(sender: InMemoryMessaging, message: Message, recipients: MessageRecipients)
          val message: Message
          val recipients: MessageRecipients
          val sender: InMemoryMessaging
          fun toString(): String
        fun createNode(manuallyPumped: Boolean): <ERROR CLASS><Handle, MessagingServiceBuilder<InMemoryMessaging>>
        fun createNodeWithID(manuallyPumped: Boolean, id: Int, description: String? = null): MessagingServiceBuilder<InMemoryMessaging>
        val endpoints: List<InMemoryMessaging>
        val everyoneOnline: AllPossibleRecipients
        var latencyCalculator: LatencyCalculator?
        fun pumpSend(block: Boolean): MessageTransfer?
        fun pumpSendInternal(transfer: MessageTransfer): Unit
        val receivedMessages: <ERROR CLASS><MessageTransfer>
        val sendManuallyPumped: Boolean
        val sentMessages: <ERROR CLASS><MessageTransfer>
        fun stop(): Unit
      open class InMemoryNetworkMapCache : SingletonSerializeAsToken, NetworkMapCache
        Module Contents InMemoryNetworkMapCache()
        open fun addMapService(net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int?): <ERROR CLASS><Unit>
        open fun addNode(node: NodeInfo): Unit
        open val changed: <ERROR CLASS><MapChange>
        open fun deregisterForUpdates(net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        open fun get(): <ERROR CLASS>
        open fun get(serviceType: ServiceType): <ERROR CLASS>
        open fun getNodeByLegalName(name: String): <ERROR CLASS>
        open fun getNodeByPublicKey(publicKey: PublicKey): <ERROR CLASS>
        open fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        open val networkMapNodes: List<NodeInfo>
        open val notaryNodes: List<NodeInfo>
        open val partyNodes: List<NodeInfo>
        fun processUpdatePush(req: Update): Unit
        open val ratesOracleNodes: List<NodeInfo>
        protected var registeredNodes: MutableMap<Party, NodeInfo>
        open val regulators: List<NodeInfo>
        open fun removeNode(node: NodeInfo): Unit
      class InMemoryNetworkMapService : NetworkMapService, AbstractNodeService
        Module Contents InMemoryNetworkMapService(net: MessagingService, home: NodeRegistration, cache: NetworkMapCache)
        val cache: NetworkMapCache
        fun getUnacknowledgedCount(subscriber: SingleMessageRecipient): Int?
        val maxSizeRegistrationRequestBytes: Int
        val maxUnacknowledgedUpdates: Int
        val nodes: List<NodeInfo>
        fun notifySubscribers(wireReg: WireNodeRegistration): Unit
        fun processAcknowledge(req: UpdateAcknowledge): Unit
        fun processFetchAllRequest(req: FetchMapRequest): FetchMapResponse
        fun processQueryRequest(req: QueryIdentityRequest): QueryIdentityResponse
        fun processRegistrationChangeRequest(req: RegistrationRequest): RegistrationResponse
        fun processSubscriptionRequest(req: SubscribeRequest): SubscribeResponse
      class MockNetworkMapCache : InMemoryNetworkMapCache
        Module Contents MockNetworkMapCache()
        data class MockAddress : SingleMessageRecipient
          Module Contents MockAddress(id: String)
          val id: String
        fun addRegistration(node: NodeInfo): Unit
        val changed: <ERROR CLASS><MapChange>
        fun deleteRegistration(identity: Party): Boolean
      interface NetworkMapService
        Module Contents val DEFAULT_EXPIRATION_PERIOD: Period
        val FETCH_PROTOCOL_TOPIC: String
        class FetchMapRequest : NetworkMapRequestMessage
          Module Contents FetchMapRequest(subscribe: Boolean, ifChangedSinceVersion: Int?, replyTo: MessageRecipients, sessionID: Long)
          val ifChangedSinceVersion: Int?
          val sessionID: Long
          val subscribe: Boolean
        data class FetchMapResponse
          Module Contents FetchMapResponse(nodes: Collection<NodeRegistration>?, version: Int)
          val nodes: Collection<NodeRegistration>?
          val version: Int
        abstract class NetworkMapRequestMessage : ServiceRequestMessage
          Module Contents NetworkMapRequestMessage(replyTo: MessageRecipients)
          open fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
          val replyTo: MessageRecipients
        val PUSH_ACK_PROTOCOL_TOPIC: String
        val PUSH_PROTOCOL_TOPIC: String
        val QUERY_PROTOCOL_TOPIC: String
        class QueryIdentityRequest : NetworkMapRequestMessage
          Module Contents QueryIdentityRequest(identity: Party, replyTo: MessageRecipients, sessionID: Long)
          val identity: Party
          val sessionID: Long
        data class QueryIdentityResponse
          Module Contents QueryIdentityResponse(node: NodeInfo?)
          val node: NodeInfo?
        val REGISTER_PROTOCOL_TOPIC: String
        class RegistrationRequest : NetworkMapRequestMessage
          Module Contents RegistrationRequest(wireReg: WireNodeRegistration, replyTo: MessageRecipients, sessionID: Long)
          val sessionID: Long
          val wireReg: WireNodeRegistration
        data class RegistrationResponse
          Module Contents RegistrationResponse(success: Boolean)
          val success: Boolean
        val SUBSCRIPTION_PROTOCOL_TOPIC: String
        class SubscribeRequest : NetworkMapRequestMessage
          Module Contents SubscribeRequest(subscribe: Boolean, replyTo: MessageRecipients, sessionID: Long)
          val sessionID: Long
          val subscribe: Boolean
        data class SubscribeResponse
          Module Contents SubscribeResponse(confirmed: Boolean)
          val confirmed: Boolean
        object Type : ServiceType
        data class Update
          Module Contents Update(wireReg: WireNodeRegistration, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireReg: WireNodeRegistration
        data class UpdateAcknowledge
          Module Contents UpdateAcknowledge(wireRegHash: SecureHash, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireRegHash: SecureHash
        val logger: <ERROR CLASS>
        abstract val nodes: List<NodeInfo>
      sealed class NodeMapError : Exception
        Module Contents class InvalidSignature : NodeMapError
          Module Contents InvalidSignature()
        class InvalidSubscriber : NodeMapError
          Module Contents InvalidSubscriber()
        class UnknownChangeType : NodeMapError
          Module Contents UnknownChangeType()
      class NodeRegistration
        Module Contents NodeRegistration(node: NodeInfo, serial: Long, type: AddOrRemove, expires: Instant)
        var expires: Instant
        val node: NodeInfo
        val serial: Long
        fun toString(): String
        fun toWire(privateKey: PrivateKey): WireNodeRegistration
        val type: AddOrRemove
      class WireNodeRegistration : SignedData<NodeRegistration>
        Module Contents WireNodeRegistration(raw: SerializedBytes<NodeRegistration>, sig: WithKey)
        protected fun verifyData(data: NodeRegistration): Unit
    package com.r3corda.node.services.persistence
      Module Contents object DataVending
        Module Contents class Plugin : CordaPluginRegistry
          Module Contents Plugin()
          val servicePlugins: List<Class<*>>
        class Service : AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
          val NOTIFY_TX_PROTOCOL_TOPIC: String
          data class NotifyTxRequestMessage : PartyRequestMessage
            Module Contents NotifyTxRequestMessage(tx: SignedTransaction, replyToParty: Party, sessionID: Long)
            val replyToParty: Party
            val sessionID: Long
            val tx: SignedTransaction
          data class NotifyTxResponseMessage
            Module Contents NotifyTxResponseMessage(accepted: Boolean)
            val accepted: Boolean
          class TransactionRejectedError : Exception
            Module Contents TransactionRejectedError(msg: String)
          val logger: <ERROR CLASS>
          fun notify(net: MessagingService, myIdentity: Party, recipient: NodeInfo, transaction: SignedTransaction): <ERROR CLASS><Unit>
          val services: ServiceHubInternal
          val storage: StorageService
      class NodeAttachmentService : AttachmentStorage, AcceptsFileUpload
        Module Contents NodeAttachmentService(storePath: Path, metrics: <ERROR CLASS>)
        class OnDiskHashMismatch : Exception
          Module Contents OnDiskHashMismatch(file: Path, actual: SecureHash)
          val actual: SecureHash
          val file: Path
          fun toString(): String
        val acceptableFileExtensions: <ERROR CLASS>
        var automaticallyExtractAttachments: Boolean
        var checkAttachmentsOnLoad: Boolean
        val dataTypePrefix: String
        fun importAttachment(jar: InputStream): SecureHash
        fun openAttachment(id: SecureHash): Attachment?
        val storePath: Path
        fun upload(data: InputStream): <ERROR CLASS>
      class PerFileCheckpointStorage : CheckpointStorage
        Module Contents PerFileCheckpointStorage(storeDir: Path)
        fun addCheckpoint(checkpoint: Checkpoint): Unit
        val checkpoints: Iterable<Checkpoint>
        fun removeCheckpoint(checkpoint: Checkpoint): Unit
        val storeDir: Path
      class PerFileTransactionStorage : TransactionStorage
        Module Contents PerFileTransactionStorage(storeDir: Path)
        fun addTransaction(transaction: SignedTransaction): Unit
        fun getTransaction(id: SecureHash): SignedTransaction?
        val storeDir: Path
        val transactions: Iterable<SignedTransaction>
      open class StorageServiceImpl : SingletonSerializeAsToken, TxWritableStorageService
        Module Contents StorageServiceImpl(attachments: AttachmentStorage, validatedTransactions: TransactionStorage, myLegalIdentityKey: KeyPair, myLegalIdentity: Party = Party("Unit test party", myLegalIdentityKey.public))
        open val attachments: AttachmentStorage
        open val myLegalIdentity: Party
        open val myLegalIdentityKey: KeyPair
        open val validatedTransactions: TransactionStorage
    package com.r3corda.node.services.statemachine
      Module Contents sealed class FiberRequest
        Module Contents class ExpectingResponse<R : Any> : FiberRequest
          Module Contents ExpectingResponse(topic: String, destination: Party?, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any?, type: Class<R>)
          fun equals(other: Any?): Boolean
          val responseType: Class<R>
          fun toString(): String
        class NotExpectingResponse : FiberRequest
          Module Contents NotExpectingResponse(topic: String, destination: Party, sessionIDForSend: Long, obj: Any?)
        val destination: Party?
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val payload: Any?
        val receiveTopicSession: TopicSession
        val sessionIDForReceive: Long
        val sessionIDForSend: Long
        val stackTraceInCaseOfProblems: StackSnapshot?
        val topic: String
      class ProtocolStateMachineImpl<R> : ProtocolStateMachine<R>
        Module Contents ProtocolStateMachineImpl(logic: ProtocolLogic<R>, scheduler: <ERROR CLASS>, loggerName: String)
        val logger: <ERROR CLASS>
        val logic: ProtocolLogic<R>
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, recvType: Class<T>): UntrustworthyData<T>
        val resultFuture: <ERROR CLASS><R>
        fun run(): R
        fun send(topic: String, destination: Party, sessionID: Long, payload: Any): Unit
        fun <T : Any> sendAndReceive(topic: String, destination: Party, sessionIDForSend: Long, sessionIDForReceive: Long, payload: Any, recvType: Class<T>): UntrustworthyData<T>
        lateinit var serviceHub: ServiceHubInternal
      class StackSnapshot : Throwable
        Module Contents StackSnapshot()
      class StateMachineManager
        Module Contents StateMachineManager(serviceHub: ServiceHubInternal, tokenizableServices: List<Any>, checkpointStorage: CheckpointStorage, executor: AffinityExecutor)
        inner class FiberScheduler
          Module Contents FiberScheduler()
        fun <T> add(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
        val allStateMachines: List<ProtocolLogic<*>>
        val changes: <ERROR CLASS><<ERROR CLASS><ProtocolLogic<*>, AddOrRemove, Long>>
        val checkpointStorage: CheckpointStorage
        val executor: AffinityExecutor
        fun <P : ProtocolLogic<T>, T> findStateMachines(protocolClass: Class<P>): List<<ERROR CLASS><P, <ERROR CLASS><T>>>
        val scheduler: FiberScheduler
        val serviceHub: ServiceHubInternal
        fun start(): Unit
    package com.r3corda.node.services.transactions
      Module Contents class InMemoryUniquenessProvider : UniquenessProvider
        Module Contents InMemoryUniquenessProvider()
        fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party): Unit
      abstract class NotaryService : AbstractNodeService
        Module Contents NotaryService(smm: StateMachineManager, net: MessagingService, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider, networkMapCache: NetworkMapCache)
        object Type : ServiceType
        abstract val logger: <ERROR CLASS>
        abstract val protocolFactory: Factory
        val smm: StateMachineManager
        val timestampChecker: TimestampChecker
        val uniquenessProvider: UniquenessProvider
      class SimpleNotaryService : NotaryService
        Module Contents SimpleNotaryService(smm: StateMachineManager, net: MessagingService, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider, networkMapCache: NetworkMapCache)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: DefaultFactory
      class ValidatingNotaryService : NotaryService
        Module Contents ValidatingNotaryService(smm: StateMachineManager, net: MessagingService, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider, networkMapCache: NetworkMapCache)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: Factory
    package com.r3corda.node.services.wallet
      Module Contents class CashBalanceAsMetricsObserver
        Module Contents CashBalanceAsMetricsObserver(serviceHubInternal: ServiceHubInternal)
        val serviceHubInternal: ServiceHubInternal
      class NodeWalletService : InMemoryWalletService
        Module Contents NodeWalletService(services: ServiceHub)
    package com.r3corda.node.servlets
      Module Contents class AttachmentDownloadServlet
        Module Contents AttachmentDownloadServlet()
        fun doGet(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
      class Config
        Module Contents Config(services: ServiceHub)
        val defaultObjectMapper: <ERROR CLASS>
        fun getContext(type: Class<*>): <ERROR CLASS>
        val services: ServiceHub
      class DataUploadServlet
        Module Contents DataUploadServlet()
        fun doPost(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
      class ResponseFilter
        Module Contents ResponseFilter()
        fun filter(requestContext: <ERROR CLASS>, responseContext: <ERROR CLASS>): Unit
    package com.r3corda.node.utilities
      Module Contents class ANSIProgressObserver
        Module Contents ANSIProgressObserver(smm: StateMachineManager)
        val smm: StateMachineManager
      object ANSIProgressRenderer
        Module Contents var progressTracker: ProgressTracker?
      enum class AddOrRemove
        Module Contents ADD
        REMOVE
      interface AffinityExecutor : Executor
        Module Contents class Gate : AffinityExecutor
          Module Contents Gate(alwaysQueue: Boolean = false)
          fun execute(command: Runnable): Unit
          val isOnThread: Boolean
          val taskQueueSize: Int
          fun waitAndRun(): Unit
        val SAME_THREAD: AffinityExecutor
        class ServiceAffinityExecutor : AffinityExecutor, ThreadPoolExecutor
          Module Contents ServiceAffinityExecutor(threadName: String, numThreads: Int)
          protected fun afterExecute(r: Runnable, t: Throwable?): Unit
          val isOnThread: Boolean
          val logger: <ERROR CLASS>
        open fun checkOnThread(): Unit
        open fun executeASAP(runnable: () -> Unit): Unit
        open fun <T> fetchFrom(fetcher: () -> T): T
        open fun flush(): Unit
        abstract val isOnThread: Boolean
      class FiberBox<out T>
        Module Contents FiberBox(content: T, lock: Lock = ReentrantLock())
        fun <R> read(body: T.() -> R): R
        fun <R> readWithDeadline(clock: Clock, deadline: Instant, body: T.() -> R): R
        fun <R> write(body: T.() -> R): R
      object JsonSupport
        Module Contents object CalendarDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): BusinessCalendar
        object LocalDateDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): LocalDate
        object LocalDateKeyDeserializer
          Module Contents fun deserializeKey(text: String, p1: <ERROR CLASS>): Any?
        object PartyDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): Party
        object PartySerializer
          Module Contents fun serialize(obj: Party, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        object PublicKeyDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): <ERROR CLASS>
        object PublicKeySerializer
          Module Contents fun serialize(obj: <ERROR CLASS>, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        class SecureHashDeserializer<T : SecureHash>
          Module Contents SecureHashDeserializer()
          fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): T
        object SecureHashSerializer
          Module Contents fun serialize(obj: SecureHash, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        class ServiceHubObjectMapper
          Module Contents ServiceHubObjectMapper(identities: IdentityService)
          val identities: IdentityService
        object ToStringSerializer
          Module Contents fun serialize(obj: Any, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        fun createDefaultMapper(identities: IdentityService): <ERROR CLASS>
      abstract class MutableClock : Clock
        Module Contents MutableClock()
        val mutationCount: Long
        val mutations: <ERROR CLASS><Long>
        protected fun notifyMutationObservers(): Unit
      java.time.Clock
        Module Contents fun Clock.awaitWithDeadline(deadline: Instant, future: Future<*> = SettableFuture<Any>()): Boolean
    package com.r3corda.protocols
      Module Contents abstract class AbstractStateReplacementProtocol<T>
        Module Contents AbstractStateReplacementProtocol()
        abstract class Acceptor<in T> : ProtocolLogic<Unit>
          Module Contents Acceptor(otherSide: Party, sessionIdForSend: Long, sessionIdForReceive: Long, progressTracker: ProgressTracker = tracker())
          object APPROVING : Step
          object REJECTING : Step
          object VERIFYING : Step
          open fun call(): Unit
          val otherSide: Party
          open val progressTracker: ProgressTracker
          val sessionIdForReceive: Long
          val sessionIdForSend: Long
          fun tracker(): ProgressTracker
        data class Handshake : PartyRequestMessage
          Module Contents Handshake(sessionIdForSend: Long, replyToParty: Party, sessionID: Long)
          val replyToParty: Party
          val sessionID: Long
          val sessionIdForSend: Long
        abstract class Instigator<out S : ContractState, T> : ProtocolLogic<StateAndRef<S>>
          Module Contents Instigator(originalState: StateAndRef<S>, modification: T, progressTracker: ProgressTracker = tracker())
          object NOTARY : Step
          object SIGNING : Step
          open fun call(): StateAndRef<S>
          val modification: T
          val originalState: StateAndRef<S>
          open val progressTracker: ProgressTracker
          fun tracker(): ProgressTracker
        interface Proposal<out T>
          Module Contents abstract val modification: T
          abstract val stateRef: StateRef
          abstract val stx: SignedTransaction
        data class Result
          Module Contents val error: StateReplacementRefused?
          fun noError(sig: WithKey): Result
          val sig: WithKey?
          fun withError(error: StateReplacementRefused): Result
      interface DirectRequestMessage : ServiceRequestMessage
        Module Contents open fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
        abstract val replyToRecipient: SingleMessageRecipient
      class FetchAttachmentsProtocol : FetchDataProtocol<Attachment, ByteArray>
        Module Contents FetchAttachmentsProtocol(requests: Set<SecureHash>, otherSide: Party)
        const val TOPIC: String
        protected fun convert(wire: ByteArray): Attachment
        protected fun load(txid: SecureHash): Attachment?
        protected fun maybeWriteToDisk(downloaded: List<Attachment>): Unit
        protected val topic: String
      abstract class FetchDataProtocol<T : NamedByHash, in W : Any> : ProtocolLogic<Result<T>>
        Module Contents FetchDataProtocol(requests: Set<SecureHash>, otherSide: Party)
        open class BadAnswer : Exception
          Module Contents BadAnswer()
        class DownloadedVsRequestedDataMismatch : BadAnswer
          Module Contents DownloadedVsRequestedDataMismatch(requested: SecureHash, got: SecureHash)
          val got: SecureHash
          val requested: SecureHash
        class HashNotFound : BadAnswer
          Module Contents HashNotFound(requested: SecureHash)
          val requested: SecureHash
        data class Request : PartyRequestMessage
          Module Contents Request(hashes: List<SecureHash>, replyToParty: Party, sessionID: Long)
          val hashes: List<SecureHash>
          val replyToParty: Party
          val sessionID: Long
        data class Result<out T : NamedByHash>
          Module Contents Result(fromDisk: List<T>, downloaded: List<T>)
          val downloaded: List<T>
          val fromDisk: List<T>
        open fun call(): Result<T>
        protected open fun convert(wire: W): T
        protected abstract fun load(txid: SecureHash): T?
        protected open fun maybeWriteToDisk(downloaded: List<T>): Unit
        protected val otherSide: Party
        protected val requests: Set<SecureHash>
      class FetchTransactionsProtocol : FetchDataProtocol<SignedTransaction, SignedTransaction>
        Module Contents FetchTransactionsProtocol(requests: Set<SecureHash>, otherSide: Party)
        const val TOPIC: String
        protected fun load(txid: SecureHash): SignedTransaction?
        protected val topic: String
      object NotaryChangeProtocol : AbstractStateReplacementProtocol<Party>
        Module Contents class Acceptor : Acceptor<Party>
          Module Contents Acceptor(otherSide: Party, sessionIdForSend: Long, sessionIdForReceive: Long, progressTracker: ProgressTracker = tracker())
          val progressTracker: ProgressTracker
          protected val topic: String
        class Instigator<T : ContractState> : Instigator<T, Party>
          Module Contents Instigator(originalState: StateAndRef<T>, newNotary: Party, progressTracker: ProgressTracker = tracker())
          protected val topic: String
        data class Proposal : Proposal<Party>
          Module Contents Proposal(stateRef: StateRef, modification: Party, stx: SignedTransaction)
          val modification: Party
          val stateRef: StateRef
          val stx: SignedTransaction
        val TOPIC: String
      sealed class NotaryError
        Module Contents class Conflict : NotaryError
          Module Contents Conflict(tx: WireTransaction, conflict: SignedData<Conflict>)
          val conflict: SignedData<Conflict>
          fun toString(): String
          val tx: WireTransaction
        class MoreThanOneTimestamp : NotaryError
          Module Contents MoreThanOneTimestamp()
        class NotForMe : NotaryError
          Module Contents NotForMe()
        class SignaturesMissing : NotaryError
          Module Contents SignaturesMissing(missingSigners: List<PublicKey>)
          val missingSigners: List<PublicKey>
        class TimestampInvalid : NotaryError
          Module Contents TimestampInvalid()
        class TransactionInvalid : NotaryError
          Module Contents TransactionInvalid()
      class NotaryException : Exception
        Module Contents NotaryException(error: NotaryError)
        val error: NotaryError
        fun toString(): String
      object NotaryProtocol
        Module Contents class Client : ProtocolLogic<LegallyIdentifiable>
          Module Contents Client(stx: SignedTransaction, progressTracker: ProgressTracker = Client.tracker())
          object REQUESTING : Step
          object VALIDATING : Step
          fun call(): LegallyIdentifiable
          lateinit var notaryParty: Party
          val progressTracker: ProgressTracker
          protected val topic: String
          fun tracker(): ProgressTracker
        object DefaultFactory : Factory
          Module Contents fun create(otherSide: Party, sendSessionID: Long, receiveSessionID: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        interface Factory
          Module Contents abstract fun create(otherSide: Party, sendSessionID: Long, receiveSessionID: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        data class Handshake : PartyRequestMessage
          Module Contents Handshake(replyToParty: Party, sendSessionID: Long, sessionID: Long)
          val replyToParty: Party
          val sendSessionID: Long
          val sessionID: Long
        data class Result
          Module Contents val error: NotaryError?
          fun noError(sig: LegallyIdentifiable): Result
          val sig: LegallyIdentifiable?
          fun withError(error: NotaryError): Result
        class Service : ProtocolLogic<Unit>
          Module Contents Service(otherSide: Party, sendSessionID: Long, receiveSessionID: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
          open fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit
          open fun call(): Unit
          val otherSide: Party
          val receiveSessionID: Long
          val sendSessionID: Long
          val timestampChecker: TimestampChecker
          protected open val topic: String
          val uniquenessProvider: UniquenessProvider
        data class SignRequest
          Module Contents SignRequest(tx: SignedTransaction, callerIdentity: Party)
          val callerIdentity: Party
          val tx: SignedTransaction
        val TOPIC: String
      interface PartyRequestMessage : ServiceRequestMessage
        Module Contents open fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
        abstract val replyToParty: Party
      open class RatesFixProtocol : ProtocolLogic<Unit>
        Module Contents RatesFixProtocol(tx: TransactionBuilder, oracle: Party, fixOf: FixOf, expectedRate: BigDecimal, rateTolerance: BigDecimal, timeOut: Duration, progressTracker: ProgressTracker = RatesFixProtocol.tracker(fixOf.name))
        class FixOutOfRange : Exception
          Module Contents FixOutOfRange(byAmount: BigDecimal)
          val byAmount: BigDecimal
        class QUERYING : Step
          Module Contents QUERYING(name: String)
          val name: String
        data class QueryRequest : PartyRequestMessage
          Module Contents QueryRequest(queries: List<FixOf>, replyToParty: Party, sessionID: Long, deadline: Instant)
          val deadline: Instant
          val queries: List<FixOf>
          val replyToParty: Party
          val sessionID: Long
        object SIGNING : Step
        data class SignRequest : PartyRequestMessage
          Module Contents SignRequest(tx: WireTransaction, replyToParty: Party, sessionID: Long)
          val replyToParty: Party
          val sessionID: Long
          val tx: WireTransaction
        val TOPIC: String
        object WORKING : Step
        protected open fun beforeSigning(fix: Fix): Unit
        open fun call(): Unit
        open val progressTracker: ProgressTracker
        protected open val topic: String
        fun tracker(fixName: String): ProgressTracker
        protected val tx: TransactionBuilder
      class ResolveTransactionsProtocol : ProtocolLogic<List<LedgerTransaction>>
        Module Contents ResolveTransactionsProtocol(stx: SignedTransaction, otherSide: Party)
        ResolveTransactionsProtocol(wtx: WireTransaction, otherSide: Party)
        ResolveTransactionsProtocol(txHashes: Set<SecureHash>, otherSide: Party)
        class ExcessivelyLargeTransactionGraph : Exception
          Module Contents ExcessivelyLargeTransactionGraph()
        fun call(): List<LedgerTransaction>
        protected val topic: String
      interface ServiceRequestMessage
        Module Contents abstract fun getReplyTo(networkMapCache: NetworkMapCache): MessageRecipients
        abstract val sessionID: Long
      class StateReplacementException : Exception
        Module Contents StateReplacementException(error: StateReplacementRefused)
        val error: StateReplacementRefused
      class StateReplacementRefused
        Module Contents StateReplacementRefused(identity: Party, state: StateRef, detail: String?)
        val detail: String?
        val identity: Party
        val state: StateRef
        fun toString(): String
      object TwoPartyDealProtocol
        Module Contents class Acceptor<T : DealState> : Secondary<T>
          Module Contents Acceptor(otherSide: Party, notary: Party, dealToBuy: T, sessionID: Long, progressTracker: ProgressTracker = Secondary.tracker())
          protected open fun assembleSharedTX(handshake: Handshake<T>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val dealToBuy: T
          val notary: Party
          open val otherSide: Party
          open val progressTracker: ProgressTracker
          open val sessionID: Long
          protected open fun validateHandshake(handshake: Handshake<T>): Handshake<T>
        val DEAL_TOPIC: String
        class DealMismatchException : Exception
          Module Contents DealMismatchException(expectedDeal: ContractState, actualDeal: ContractState)
          val actualDeal: ContractState
          val expectedDeal: ContractState
          fun toString(): String
        class DealRefMismatchException : Exception
          Module Contents DealRefMismatchException(expectedDeal: StateRef, actualDeal: StateRef)
          val actualDeal: StateRef
          val expectedDeal: StateRef
          fun toString(): String
        val FIX_INITIATE_TOPIC: String
        class Fixer : Secondary<StateRef>
          Module Contents Fixer(initiation: FixingSessionInitiation, progressTracker: ProgressTracker = Secondary.tracker())
          protected fun assembleSharedTX(handshake: Handshake<StateRef>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val initiation: FixingSessionInitiation
          val otherSide: Party
          val progressTracker: ProgressTracker
          val sessionID: Long
          protected fun validateHandshake(handshake: Handshake<StateRef>): Handshake<StateRef>
        class FixingRoleDecider : ProtocolLogic<Unit>
          Module Contents FixingRoleDecider(ref: StateRef, timeout: Duration, progressTracker: ProgressTracker = tracker())
          class LOADING : Step
            Module Contents LOADING()
          fun call(): Unit
          val progressTracker: ProgressTracker
          val ref: StateRef
          val timeout: Duration
          protected val topic: String
          fun tracker(): ProgressTracker
        data class FixingSessionInitiation
          Module Contents FixingSessionInitiation(sessionID: Long, party: Party, sender: Party, timeout: Duration)
          val party: Party
          val sender: Party
          val sessionID: Long
          val timeout: Duration
        class Floater : Primary<StateRef>
          Module Contents Floater(payload: StateRef, otherSessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherSessionID: Long
          val otherSide: Party
          val payload: StateRef
          val progressTracker: ProgressTracker
        data class Handshake<out T>
          Module Contents Handshake(payload: T, publicKey: PublicKey, sessionID: Long)
          val payload: T
          val publicKey: PublicKey
          val sessionID: Long
        class Instigator<out T : DealState> : Primary<T>
          Module Contents Instigator(otherSide: Party, notary: Party, payload: T, myKeyPair: KeyPair, otherSessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          open val myKeyPair: KeyPair
          val notary: Party
          open val notaryNode: NodeInfo
          open val otherSessionID: Long
          open val otherSide: Party
          open val payload: T
          open val progressTracker: ProgressTracker
        abstract class Primary<out U> : ProtocolLogic<SignedTransaction>
          Module Contents Primary(progressTracker: ProgressTracker = Primary.tracker())
          object AWAITING_PROPOSAL : Step
          object COPYING_TO_REGULATOR : Step
          object NOTARY : Step
          object RECORDING : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object VERIFYING : Step
          open fun call(): SignedTransaction
          fun getPartialTransaction(): UntrustworthyData<SignedTransaction>
          abstract val myKeyPair: KeyPair
          abstract val notaryNode: NodeInfo
          abstract val otherSessionID: Long
          abstract val otherSide: Party
          abstract val payload: U
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          protected open val topic: String
          fun tracker(): ProgressTracker
          fun verifyPartialTransaction(untrustedPartialTX: UntrustworthyData<SignedTransaction>): SignedTransaction
        abstract class Secondary<U> : ProtocolLogic<SignedTransaction>
          Module Contents Secondary(progressTracker: ProgressTracker = Secondary.tracker())
          object RECEIVING : Step
          object RECORDING : Step
          object SIGNING : Step
          object SWAPPING_SIGNATURES : Step
          object VERIFYING : Step
          protected abstract fun assembleSharedTX(handshake: Handshake<U>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          open fun call(): SignedTransaction
          abstract val otherSide: Party
          open val progressTracker: ProgressTracker
          abstract val sessionID: Long
          protected open val topic: String
          fun tracker(): ProgressTracker
          protected abstract fun validateHandshake(handshake: Handshake<U>): Handshake<U>
        class SignaturesFromPrimary
          Module Contents SignaturesFromPrimary(sellerSig: WithKey, notarySig: LegallyIdentifiable)
          val notarySig: LegallyIdentifiable
          val sellerSig: WithKey
      object TwoPartyTradeProtocol
        Module Contents class AssetMismatchException : Exception
          Module Contents AssetMismatchException(expectedTypeName: String, typeName: String)
          val expectedTypeName: String
          fun toString(): String
          val typeName: String
        class Buyer : ProtocolLogic<SignedTransaction>
          Module Contents Buyer(otherSide: Party, notary: Party, acceptablePrice: Amount<Currency>, typeToBuy: Class<out OwnableState>, sessionID: Long)
          object RECEIVING : Step
          object SIGNING : Step
          object SWAPPING_SIGNATURES : Step
          object VERIFYING : Step
          val acceptablePrice: Amount<Currency>
          open fun call(): SignedTransaction
          val notary: Party
          val otherSide: Party
          open val progressTracker: ProgressTracker
          val sessionID: Long
          protected open val topic: String
          val typeToBuy: Class<out OwnableState>
        class Seller : ProtocolLogic<SignedTransaction>
          Module Contents Seller(otherSide: Party, notaryNode: NodeInfo, assetToSell: StateAndRef<OwnableState>, price: Amount<Currency>, myKeyPair: KeyPair, buyerSessionID: Long, progressTracker: ProgressTracker = Seller.tracker())
          object AWAITING_PROPOSAL : Step
          object NOTARY : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object VERIFYING : Step
          val assetToSell: StateAndRef<OwnableState>
          val buyerSessionID: Long
          open fun call(): SignedTransaction
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherSide: Party
          val price: Amount<Currency>
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          protected open val topic: String
          fun tracker(): ProgressTracker
        class SellerTradeInfo
          Module Contents SellerTradeInfo(assetForSale: StateAndRef<OwnableState>, price: Amount<Currency>, sellerOwnerKey: PublicKey, sessionID: Long)
          val assetForSale: StateAndRef<OwnableState>
          val price: Amount<Currency>
          val sellerOwnerKey: PublicKey
          val sessionID: Long
        class SignaturesFromSeller
          Module Contents SignaturesFromSeller(sellerSig: WithKey, notarySig: LegallyIdentifiable)
          val notarySig: LegallyIdentifiable
          val sellerSig: WithKey
        val TOPIC: String
        class UnacceptablePriceException : Exception
          Module Contents UnacceptablePriceException(givenPrice: Amount<Currency>)
          val givenPrice: Amount<Currency>
      class ValidatingNotaryProtocol : Service
        Module Contents ValidatingNotaryProtocol(otherSide: Party, sessionIdForSend: Long, sessionIdForReceive: Long, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit