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>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
        Module Contents AbstractConserveAmount()
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, assetStates: List<StateAndRef<S>>, deriveState: (TransactionState<S>, Amount<Issued<T>>, PublicKey) -> TransactionState<S>, generateMoveCommand: () -> CommandData, 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 fun toString(): String
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
      abstract class AbstractIssue<in S : ContractState, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
        Module Contents AbstractIssue(sum: List<S>.() -> Amount<Issued<T>>, sumOrZero: List<S>.(Issued<T>) -> Amount<Issued<T>>)
        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: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
      abstract class AbstractJDBCHashMap<K : Any, V : Any, T : JDBCHashedTable> : MutableMap<K, V>, AbstractMap<K, V>
        Module Contents AbstractJDBCHashMap(table: T, loadOnInit: Boolean = false)
        protected abstract fun addKeyToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        protected abstract fun addValueToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        open fun clear(): Unit
        open fun containsKey(key: K): Boolean
        open fun containsValue(value: V): Boolean
        open val entries: MutableSet<MutableEntry<K, V>>
        open fun get(key: K): V?
        open fun isEmpty(): Boolean
        protected abstract fun keyFromRow(it: <ERROR CLASS>): K
        open val keys: MutableSet<K>
        val loadOnInit: Boolean
        protected val log: <ERROR CLASS>
        open fun put(key: K, value: V): V?
        open fun remove(key: K): V?
        open val size: Int
        val table: T
        protected abstract fun valueFromRow(it: <ERROR CLASS>): V
        open val values: MutableCollection<V>
      abstract class AbstractJDBCHashSet<K : Any, T : JDBCHashedTable> : MutableSet<K>, AbstractSet<K>
        Module Contents AbstractJDBCHashSet(table: T, loadOnInit: Boolean = false)
        open fun add(element: K): Boolean
        protected abstract fun addElementToInsert(it: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit
        open fun clear(): Unit
        open fun contains(element: K): Boolean
        protected abstract fun elementFromRow(it: <ERROR CLASS>): K
        protected val innerMap: AbstractJDBCHashMap<K, Unit, T>
        open fun isEmpty(): Boolean
        open fun iterator(): MutableIterator<K>
        open fun remove(element: K): Boolean
        open val size: Int
        protected val table: T
      abstract class AbstractNetworkMapService : NetworkMapService, AbstractNodeService
        Module Contents AbstractNetworkMapService(services: ServiceHubInternal)
        protected val _mapVersion: AtomicInteger
        fun getUnacknowledgedCount(subscriber: SingleMessageRecipient, mapVersion: Int): Int?
        val mapVersion: Int
        val maxSizeRegistrationRequestBytes: Int
        val maxUnacknowledgedUpdates: Int
        open val nodes: List<NodeInfo>
        fun notifySubscribers(wireReg: WireNodeRegistration, mapVersion: Int): 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
        protected abstract val registeredNodes: MutableMap<Party, NodeRegistrationInfo>
        protected fun setup(): Unit
        protected abstract val subscribers: ThreadBox<MutableMap<SingleMessageRecipient, LastAcknowledgeInfo>>
        fun unregisterNetworkHandlers(): Unit
      abstract class AbstractNode : SingletonSerializeAsToken
        Module Contents AbstractNode(configuration: NodeConfiguration, networkMapService: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, platformClock: Clock)
        class DatabaseConfigurationException : Exception
          Module Contents DatabaseConfigurationException(msg: String)
        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>
        open fun findMyLocation(): PhysicalLocation?
        inline fun <reified T : Any> findService(): <ERROR CLASS>
        protected open fun generateKeyPair(): KeyPair
        lateinit var identity: IdentityService
        var inNodeMonitorService: NodeMonitorService?
        var inNodeNetworkMapService: NetworkMapService?
        var inNodeNotaryService: NotaryService?
        val info: NodeInfo
        protected open fun initialiseDatabasePersistence(insideTransaction: () -> Unit): Unit
        protected open fun initialiseStorageService(dir: Path): <ERROR CLASS><TxWritableStorageService, CheckpointStorage>
        var isPreviousCheckpointsPresent: Boolean
        lateinit var keyManagement: KeyManagementService
        protected abstract val log: <ERROR CLASS>
        protected fun makeAttachmentStorage(dir: Path): NodeAttachmentService
        protected open fun makeIdentityService(): IdentityService
        protected open fun makeKeyManagementService(): KeyManagementService
        protected abstract fun makeMessagingService(): MessagingServiceInternal
        protected open fun makeMonitorService(): NodeMonitorService
        protected open fun makeNetworkMapService(): Unit
        protected open fun makeNotaryService(type: ServiceType): NotaryService
        protected abstract fun makeUniquenessProvider(): UniquenessProvider
        protected open fun makeVaultService(): VaultService
        lateinit var net: MessagingServiceInternal
        lateinit var netMapCache: NetworkMapCache
        val networkMapRegistrationFuture: <ERROR CLASS><Unit>
        var networkMapSeq: Long
        val networkMapService: SingleMessageRecipient?
        protected open fun noNetworkMapConfigured(): <ERROR CLASS><Unit>
        val platformClock: Clock
        protected val pluginRegistries: List<CordaPluginRegistry>
        lateinit var protocolLogicFactory: ProtocolLogicRefFactory
        protected val runOnStop: ArrayList<Runnable>
        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
        var uniquenessProvider: UniquenessProvider?
        lateinit var vault: VaultService
      abstract class AbstractNodeService : SingletonSerializeAsToken
        Module Contents AbstractNodeService(services: ServiceHubInternal)
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R, crossinline exceptionConsumer: (Message, Exception) -> Unit): MessageHandlerRegistration
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R): MessageHandlerRegistration
        protected inline fun <reified H : HandshakeMessage, R : Any> addProtocolHandler(topic: String, loggerName: String, crossinline protocolFactory: (H) -> ProtocolLogic<R>, crossinline onResultFuture: (<ERROR CLASS><R>, H) -> Unit): Unit
        protected inline fun <reified H : HandshakeMessage, R : Any> addProtocolHandler(topic: String, loggerName: String, crossinline protocolFactory: (H) -> ProtocolLogic<R>): Unit
        val logger: <ERROR CLASS>
        val net: MessagingServiceInternal
        val services: ServiceHubInternal
      abstract class AbstractStateReplacementProtocol<T>
        Module Contents AbstractStateReplacementProtocol()
        abstract class Acceptor<T> : ProtocolLogic<Unit>
          Module Contents Acceptor(otherSide: Party, progressTracker: ProgressTracker = tracker())
          object APPROVING : Step
          object REJECTING : Step
          object VERIFYING : Step
          open fun call(): Unit
          val otherSide: Party
          open val progressTracker: ProgressTracker
          fun tracker(): ProgressTracker
          abstract fun verifyProposal(maybeProposal: UntrustworthyData<Proposal<T>>): Proposal<T>
        data class Handshake : HandshakeMessage
          Module Contents Handshake(replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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
      class AggregatedList<A, E, K : Any> : TransformationList<A, E>
        Module Contents AggregatedList(list: ObservableList<out E>, toKey: (E) -> K, assemble: (K, ObservableList<E>) -> A)
        val assemble: (K, ObservableList<E>) -> A
        fun get(index: Int): A?
        fun getSourceIndex(index: Int): Int
        val size: Int
        protected fun sourceChanged(c: Change<out E>): Unit
        val toKey: (E) -> K
      class AllComposition<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
        Module Contents AllComposition(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
        val clauses: ArrayList<Clause<S, C, K>>
        fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
        fun toString(): String
        fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      interface AllPossibleRecipients : MessageRecipients
      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
      object AmountBindings
        Module Contents fun exchange(currency: ObservableValue<Currency>, exchangeRate: ObservableValue<ExchangeRate>): ObservableValue<<ERROR CLASS><Currency, (Amount<Currency>) -> Long>>
        fun <T> sum(amounts: ObservableList<Amount<T>>, token: T): <ERROR CLASS>
        fun sumAmountExchange(amounts: ObservableList<Amount<Currency>>, currency: ObservableValue<Currency>, exchangeRate: ObservableValue<ExchangeRate>): ObservableValue<Amount<Currency>>
      class AmountGenerator<T>
        Module Contents AmountGenerator(tokenGenerator: <ERROR CLASS><T>)
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Amount<T>
        val tokenGenerator: <ERROR CLASS><T>
      class AnyComposition<in S : ContractState, C : CommandData, in K : Any> : CompositeClause<S, C, K>
        Module Contents AnyComposition(vararg rawClauses: Clause<S, C, K>)
        val clauses: List<Clause<S, C, K>>
        fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
        fun toString(): String
        fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      data class AppContext
        Module Contents AppContext(attachments: List<SecureHash>)
        val attachments: List<SecureHash>
        val classLoader: ClassLoader
      abstract class ArtemisMessagingComponent : SingletonSerializeAsToken
        Module Contents ArtemisMessagingComponent(config: NodeSSLConfiguration)
        protected interface ArtemisAddress
          Module Contents abstract val hostAndPort: <ERROR CLASS>
          abstract val queueName: <ERROR CLASS>
        const val CLIENTS_PREFIX: String
        protected enum class ConnectionDirection
          Module Contents INBOUND
          OUTBOUND
        protected val NETWORK_MAP_ADDRESS: <ERROR CLASS>
        protected data class NetworkMapAddress : SingleMessageRecipient, ArtemisAddress
          Module Contents NetworkMapAddress(hostAndPort: <ERROR CLASS>)
          val hostAndPort: <ERROR CLASS>
          val queueName: <ERROR CLASS>
        data class NodeAddress : SingleMessageRecipient, ArtemisAddress
          Module Contents NodeAddress(identity: PublicKey, hostAndPort: <ERROR CLASS>)
          val hostAndPort: <ERROR CLASS>
          val identity: PublicKey
          val queueName: <ERROR CLASS>
          fun toString(): String
        const val PEERS_PREFIX: String
        const val RPC_REQUESTS_QUEUE: String
        fun checkStorePasswords(): Unit
        val config: NodeSSLConfiguration
        fun configureWithDevSSLCertificate(): Unit
        protected fun parseKeyFromQueueName(name: String): PublicKey
        protected fun tcpTransport(direction: ConnectionDirection, host: String, port: Int): <ERROR CLASS>
        fun toHostAndPort(target: MessageRecipients): <ERROR CLASS>
        protected fun toQueueName(target: MessageRecipients): <ERROR CLASS>
      class ArtemisMessagingServer : ArtemisMessagingComponent
        Module Contents ArtemisMessagingServer(config: NodeConfiguration, myHostPort: <ERROR CLASS>, networkMapCache: NetworkMapCache)
        fun bridgeToNetworkMapService(networkMapService: SingleMessageRecipient?): Unit
        val log: <ERROR CLASS>
        val myHostPort: <ERROR CLASS>
        val networkMapCache: NetworkMapCache
        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
      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 : HandshakeMessage
          Module Contents AutoOfferMessage(notary: Party, dealBeingOffered: DealState, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val dealBeingOffered: DealState
          val notary: Party
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
        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 : AbstractNodeService
          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
          fun tracker(): ProgressTracker
        val TOPIC: String
      abstract class BaseTransaction : NamedByHash
        Module Contents BaseTransaction(inputs: List<*>, outputs: List<TransactionState<ContractState>>, notary: Party?, mustSign: List<PublicKey>, type: TransactionType, timestamp: Timestamp?)
        protected fun checkInvariants(): Unit
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        open val inputs: List<*>
        val mustSign: List<PublicKey>
        val notary: Party?
        val outputs: List<TransactionState<ContractState>>
        val timestamp: Timestamp?
        val type: TransactionType
      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 BroadcastTransactionProtocol : ProtocolLogic<Unit>
        Module Contents BroadcastTransactionProtocol(notarisedTransaction: SignedTransaction, events: Set<ClientToServiceCommand>, participants: Set<Party>)
        data class NotifyTxRequestMessage : HandshakeMessage
          Module Contents NotifyTxRequestMessage(tx: SignedTransaction, events: Set<ClientToServiceCommand>, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val events: Set<ClientToServiceCommand>
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
          val tx: SignedTransaction
        val TOPIC: String
        fun call(): Unit
        val events: Set<ClientToServiceCommand>
        val notarisedTransaction: SignedTransaction
        val participants: Set<Party>
        protected val topic: String
      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, Commands, State>
        Module Contents Cash()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Commands, Currency>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Commands, Issued<Currency>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, Issued<Currency>>>
          class Issue : AbstractIssue<State, Commands, Currency>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
        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, encumbrance: Int? = null)
          val amount: Amount<Issued<Currency>>
          val contract: Cash
          val deposit: PartyAndReference
          val encumbrance: Int?
          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 conserveClause: AbstractConserveAmount<State, Commands, Currency>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Currency>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): 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
        fun verify(tx: TransactionForContract): Unit
      class CashBalanceAsMetricsObserver
        Module Contents CashBalanceAsMetricsObserver(serviceHubInternal: ServiceHubInternal)
        val serviceHubInternal: ServiceHubInternal
      class CertificateSigner
        Module Contents CertificateSigner(config: NodeConfiguration, certService: CertificateSigningService)
        fun buildKeyStore(): Unit
        val certService: CertificateSigningService
        val config: NodeConfiguration
        val log: <ERROR CLASS>
        val pollInterval: Duration
      interface CertificateSigningService
        Module Contents abstract fun retrieveCertificates(requestId: String): Array<Certificate>?
        abstract fun submitRequest(request: <ERROR CLASS>): String
      data class Checkpoint
        Module Contents Checkpoint(serialisedFiber: SerializedBytes<ProtocolStateMachineImpl<*>>, request: ProtocolIORequest?, receivedPayload: Any?)
        var fiberCreated: Boolean
        val receivedPayload: Any?
        val request: ProtocolIORequest?
        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
      class ChosenList<E> : ObservableListBase<E>
        Module Contents ChosenList(chosenListObservable: ObservableValue<out ObservableList<out E>>)
        fun get(index: Int): E
        val size: Int
      object CityDatabase
        Module Contents operator fun get(name: String): PhysicalLocation?
      abstract class Clause<in S : ContractState, C : CommandData, in K : Any>
        Module Contents Clause()
        open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
        val log: <ERROR CLASS>
        open val requiredCommands: Set<Class<out CommandData>>
        abstract fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      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, tradeWithIdentities: List<Path>, uploadRates: Boolean, defaultLegalName: String, autoSetup: Boolean)
          val apiAddress: <ERROR CLASS>
          val autoSetup: Boolean
          val defaultLegalName: String
          val dir: 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
        class UploadRates : CliParams
          Module Contents UploadRates(apiAddress: <ERROR CLASS>)
          val apiAddress: <ERROR CLASS>
        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 networkMapNetAddr: <ERROR CLASS>
        val nonOptions: <ERROR CLASS>
        val parser: <ERROR CLASS>
        val roleArg: <ERROR CLASS>
      data class ClientRPCRequestMessage
        Module Contents ClientRPCRequestMessage(args: SerializedBytes<Array<Any>>, replyToAddress: String, observationsToAddress: String?, methodName: String)
        const val METHOD_NAME: String
        const val OBSERVATIONS_TO: String
        const val REPLY_TO: String
        val args: SerializedBytes<Array<Any>>
        val methodName: String
        val observationsToAddress: String?
        val replyToAddress: String
      sealed class ClientToServiceCommand
        Module Contents class ExitCash : ClientToServiceCommand
          Module Contents ExitCash(amount: Amount<Currency>, issueRef: OpaqueBytes, id: UUID = UUID.randomUUID())
          val amount: Amount<Currency>
          val issueRef: OpaqueBytes
        class IssueCash : ClientToServiceCommand
          Module Contents IssueCash(amount: Amount<Currency>, issueRef: OpaqueBytes, recipient: Party, notary: Party, id: UUID = UUID.randomUUID())
          val amount: Amount<Currency>
          val issueRef: OpaqueBytes
          val notary: Party
          val recipient: Party
        class PayCash : ClientToServiceCommand
          Module Contents PayCash(amount: Amount<Issued<Currency>>, recipient: Party, id: UUID = UUID.randomUUID())
          val amount: Amount<Issued<Currency>>
          val recipient: Party
        val id: UUID
      data class ClientToServiceCommandMessage : DirectRequestMessage
        Module Contents ClientToServiceCommandMessage(sessionID: Long, replyToRecipient: SingleMessageRecipient, command: ClientToServiceCommand)
        val command: ClientToServiceCommand
        val replyToRecipient: SingleMessageRecipient
        val sessionID: Long
      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 CommandDataGenerator
        Module Contents CommandDataGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): CommandData
      class CommandGenerator
        Module Contents CommandGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Command
      class CommercialPaper : Contract
        Module Contents CommercialPaper()
        interface Clauses
          Module Contents class Group : GroupClauseVerifier<State, Commands, Issued<Terms>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, Issued<Terms>>>
          class Issue : AbstractIssue<State, Commands, Terms>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms>?): Set<Commands>
          class Move : Clause<State, Commands, Issued<Terms>>
            Module Contents Move()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms>?): Set<Commands>
          class Redeem : Clause<State, Commands, Issued<Terms>>
            Module Contents Redeem()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms>?): Set<Commands>
        interface Commands : CommandData
          Module Contents data class Issue : IssueCommand, Commands
            Module Contents Issue(nonce: Long = random63BitValue())
            val nonce: Long
          data class Move : Move, Commands
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
          class Redeem : TypeOnlyCommandData, Commands
            Module Contents Redeem()
        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
        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>, vault: List<StateAndRef<State>>): Unit
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      class CommercialPaperLegacy : Contract
        Module Contents CommercialPaperLegacy()
        interface Commands : CommandData
          Module Contents class Issue : TypeOnlyCommandData, Commands
            Module Contents Issue()
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
          class Redeem : TypeOnlyCommandData, Commands
            Module Contents Redeem()
        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: <ERROR CLASS>
          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
        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>, vault: Vault): Unit
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      data class Commodity
        Module Contents Commodity(commodityCode: String, displayName: String, defaultFractionDigits: Int = 0)
        val commodityCode: String
        val defaultFractionDigits: Int
        val displayName: String
        fun getInstance(commodityCode: String): Commodity?
      class CommodityContract : OnLedgerAsset<Commodity, Commands, State>
        Module Contents CommodityContract()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Commands, Commodity>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Commands, Issued<Commodity>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, Issued<Commodity>>>
          class Issue : AbstractIssue<State, Commands, Commodity>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
        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 conserveClause: AbstractConserveAmount<State, Commands, Commodity>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Commodity>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): 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
        fun verify(tx: TransactionForContract): Unit
      abstract class CompositeClause<in S : ContractState, C : CommandData, in K : Any> : Clause<S, C, K>
        Module Contents CompositeClause()
        abstract val clauses: List<Clause<S, C, K>>
        open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
        abstract fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
      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
        open val encumbrance: Int?
        abstract val participants: List<PublicKey>
      class ContractStateGenerator
        Module Contents ContractStateGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): ContractState
      class ContractStateModel
        Module Contents ContractStateModel()
        val cashStates: ObservableList<StateAndRef<State>>
        val cashStatesModification: <ERROR CLASS><StatesModification<State>>
        val contractStatesDiff: <ERROR CLASS><Diff<ContractState>>
      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 CordaRPCClient : Closeable, ArtemisMessagingComponent
        Module Contents CordaRPCClient(host: <ERROR CLASS>, certificatesPath: Path)
        fun close(): Unit
        val host: <ERROR CLASS>
        var myID: Int
        fun proxy(timeout: Duration? = null, minVersion: Int = 0): CordaRPCOps
        fun start(): Unit
      interface CordaRPCOps : RPCOps
      class CubicSplineInterpolator : Interpolator
        Module Contents CubicSplineInterpolator(xs: DoubleArray, ys: DoubleArray)
        fun create(xs: DoubleArray, ys: DoubleArray): CubicSplineInterpolator
        fun interpolate(x: Double): Double
      class CurrencyGenerator
        Module Contents CurrencyGenerator()
        val currencies: <ERROR CLASS>
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Currency
      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)
          class TransactionRejectedError : Exception
            Module Contents TransactionRejectedError(msg: String)
          val logger: <ERROR CLASS>
          fun notify(net: MessagingService, myIdentity: Party, recipient: NodeInfo, transaction: SignedTransaction): Unit
          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: List<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
      data class DeregisterRequest : DirectRequestMessage
        Module Contents DeregisterRequest(replyToRecipient: SingleMessageRecipient, sessionID: Long)
        val replyToRecipient: SingleMessageRecipient
        val sessionID: Long
      data class DeregisterResponse
        Module Contents DeregisterResponse(success: Boolean)
        val success: Boolean
      interface DeserializeAsKotlinObjectDef
      open class DigitalSignature : OpaqueBytes
        Module Contents DigitalSignature(bits: ByteArray)
        class LegallyIdentifiable : WithKey
          Module Contents LegallyIdentifiable(signer: Party, bits: ByteArray)
          val signer: Party
        open class WithKey : DigitalSignature
          Module Contents WithKey(by: PublicKey, bits: ByteArray)
          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 DriverDSL : DriverDSLInternalInterface
        Module Contents DriverDSL(portAllocation: PortAllocation, debugPortAllocation: PortAllocation, baseDirectory: String, isDebug: Boolean)
        class State
          Module Contents State()
          val clients: LinkedList<NodeMessagingClient>
          var localServer: ArtemisMessagingServer?
          val registeredProcesses: LinkedList<Process>
        val baseDirectory: String
        val debugPortAllocation: PortAllocation
        val isDebug: Boolean
        val name: Array<String>
        val networkMapCache: InMemoryNetworkMapCache
        fun <A> pickA(array: Array<A>): A
        val portAllocation: PortAllocation
        fun registerProcess(process: Process): Unit
        fun shutdown(): Unit
        fun start(): Unit
        fun startClient(providedName: String, serverAddress: <ERROR CLASS>): Future<NodeMessagingClient>
        fun startLocalServer(): Future<ArtemisMessagingServer>
        fun startNode(providedName: String?, advertisedServices: Set<ServiceType>): Future<NodeInfo>
        fun waitForAllNodesToFinish(): Unit
      interface DriverDSLExposedInterface
        Module Contents abstract val networkMapCache: NetworkMapCache
        abstract fun startClient(providedName: String, serverAddress: <ERROR CLASS>): Future<NodeMessagingClient>
        abstract fun startLocalServer(): Future<ArtemisMessagingServer>
        abstract fun startNode(providedName: String? = null, advertisedServices: Set<ServiceType> = setOf()): Future<NodeInfo>
        abstract fun waitForAllNodesToFinish(): Unit
      interface DriverDSLInternalInterface : DriverDSLExposedInterface
        Module Contents abstract fun shutdown(): Unit
        abstract fun start(): Unit
      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 move(prior: StateAndRef<SingleOwnerState>, newOwner: PublicKey): <ERROR CLASS>
        fun move(priors: List<StateAndRef<SingleOwnerState>>, newOwner: PublicKey): TransactionBuilder
        fun verify(tx: TransactionForContract): 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
      data class DummyState : ContractState
        Module Contents DummyState(magicNumber: Int = 0)
        val contract: DummyContract
        val magicNumber: Int
        val participants: List<PublicKey>
      class DurationGenerator
        Module Contents DurationGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Duration
      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
      data class ErrorOr<out A>
        Module Contents ErrorOr(value: A)
        fun <B> bind(function: (A) -> ErrorOr<B>): ErrorOr<Nothing>
        inline fun <T> catch(body: () -> T): ErrorOr<T>
        fun <B, C> combine(other: ErrorOr<B>, function: (A, B) -> C): ErrorOr<C>
        val error: Throwable?
        fun getOrThrow(): A
        fun <B> map(function: (A) -> B): <ERROR CLASS>
        fun <T> match(onValue: (A) -> T, onError: (Throwable) -> T): T
        fun of(t: Throwable): ErrorOr<Nothing>
        val value: A?
      open class Event
        Module Contents Event(date: LocalDate)
        val date: LocalDate
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
      class EventGenerator
        Module Contents EventGenerator(parties: List<Party>, notary: Party)
        val amountGenerator: <ERROR CLASS>
        val amountIssuedGenerator: <ERROR CLASS>
        val cashStateGenerator: <ERROR CLASS>
        val clientToServiceCommandGenerator: <ERROR CLASS>
        val consumedGenerator: Generator<Set<StateRef>>
        val currencies: <ERROR CLASS>
        val currencyGenerator: <ERROR CLASS>
        val exitCashGenerator: <ERROR CLASS>
        val issueCashGenerator: <ERROR CLASS>
        val issueRefGenerator: Generator<OpaqueBytes>
        val issuerGenerator: Generator<PartyAndReference>
        val moveCashGenerator: <ERROR CLASS>
        val notary: Party
        val outputStateGenerator: Generator<OutputState>
        val parties: List<Party>
        val partyGenerator: Generator<Party>
        val producedGenerator: Generator<Set<StateAndRef<ContractState>>>
        val publicKeyGenerator: <ERROR CLASS>
        val serviceToClientEventGenerator: Generator<ServiceToClientEvent>
      interface ExchangeRate
        Module Contents abstract fun rate(from: Currency, to: Currency): Double
      class ExchangeRateModel
        Module Contents ExchangeRateModel()
        val exchangeRate: ObservableValue<ExchangeRate>
      class ExitGenerator
        Module Contents ExitGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Exit
      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 : HandshakeMessage
          Module Contents ExitMessage(exitCode: Int, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val exitCode: Int
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
        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 : HandshakeMessage
          Module Contents Request(hashes: List<SecureHash>, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val hashes: List<SecureHash>
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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
      class FinalityProtocol : ProtocolLogic<Unit>
        Module Contents FinalityProtocol(transaction: SignedTransaction, events: Set<ClientToServiceCommand>, participants: Set<Party>, progressTracker: ProgressTracker = tracker())
        object BROADCASTING : Step
        object NOTARISING : Step
        fun call(): Unit
        val events: Set<ClientToServiceCommand>
        val participants: Set<Party>
        val progressTracker: ProgressTracker
        protected val topic: String
        fun tracker(): ProgressTracker
        val transaction: SignedTransaction
      class FirstComposition<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
        Module Contents FirstComposition(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
        val clauses: ArrayList<Clause<S, C, K>>
        val firstClause: Clause<S, C, K>
        val logger: <ERROR CLASS>
        fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
        fun toString(): String
        fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      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?
        abstract val oracleType: ServiceType
      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 : AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
      class FlattenedList<A> : TransformationList<A, ObservableValue<out A>>
        Module Contents FlattenedList(sourceList: ObservableList<out ObservableValue<out A>>)
        class WrappedObservableValue<A>
          Module Contents WrappedObservableValue(observableValue: ObservableValue<A>)
          val observableValue: ObservableValue<A>
        fun get(index: Int): A
        fun getSourceIndex(index: Int): Int
        val indexMap: HashMap<WrappedObservableValue<out A>, <ERROR CLASS><Int, ChangeListener<A>>>
        val size: Int
        protected fun sourceChanged(c: Change<out ObservableValue<out A>>): Unit
        val sourceList: ObservableList<out ObservableValue<out A>>
      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 certificateSigningService: <ERROR CLASS>
        val clock: Clock
        fun createNode(): Node
        val dataSourceProperties: Properties
        val devMode: Boolean
        val emailAddress: String
        val exportJMXto: String
        val extraAdvertisedServiceIds: String
        val hostNotaryServiceLocally: Boolean
        val keyStorePassword: String
        val messagingServerAddress: <ERROR CLASS>?
        val myLegalName: String
        val nearestCity: String
        val networkMapAddress: <ERROR CLASS>?
        val trustStorePassword: String
        val useHTTPS: Boolean
        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 GatheredTransactionData
        Module Contents abstract val allEvents: ObservableList<out ServiceToClientEvent>
        abstract val fiberId: ObservableValue<Long?>
        abstract val lastUpdate: ObservableValue<Instant>
        abstract val protocolStatus: ObservableValue<ProtocolStatus?>
        abstract val stateMachineStatus: ObservableValue<StateMachineStatus?>
        abstract val status: ObservableValue<TransactionCreateStatus?>
        abstract val transaction: ObservableValue<LedgerTransaction?>
        abstract val uuid: ObservableValue<UUID?>
      class GatheredTransactionDataModel
        Module Contents GatheredTransactionDataModel()
        val gatheredTransactionDataList: ObservableList<out GatheredTransactionData>
      data class GatheredTransactionDataWritable : GatheredTransactionData
        Module Contents GatheredTransactionDataWritable(fiberId: SimpleObjectProperty<Long?> = SimpleObjectProperty(null), uuid: SimpleObjectProperty<UUID?> = SimpleObjectProperty(null), stateMachineStatus: SimpleObjectProperty<StateMachineStatus?> = SimpleObjectProperty(null), protocolStatus: SimpleObjectProperty<ProtocolStatus?> = SimpleObjectProperty(null), transaction: SimpleObjectProperty<LedgerTransaction?> = SimpleObjectProperty(null), status: SimpleObjectProperty<TransactionCreateStatus?> = SimpleObjectProperty(null), lastUpdate: SimpleObjectProperty<Instant>, allEvents: ObservableList<ServiceToClientEvent> = FXCollections.observableArrayList())
        val allEvents: ObservableList<ServiceToClientEvent>
        val fiberId: SimpleObjectProperty<Long?>
        val lastUpdate: SimpleObjectProperty<Instant>
        val protocolStatus: SimpleObjectProperty<ProtocolStatus?>
        val stateMachineStatus: SimpleObjectProperty<StateMachineStatus?>
        val status: SimpleObjectProperty<TransactionCreateStatus?>
        val transaction: SimpleObjectProperty<LedgerTransaction?>
        val uuid: SimpleObjectProperty<UUID?>
      class Generator<out A>
        Module Contents Generator(generate: (Random) -> ErrorOr<A>)
        fun <B> bind(function: (A) -> Generator<B>): Generator<Nothing>
        fun <A> choice(generators: List<Generator<A>>): Generator<Nothing>
        fun <B, R> combine(other1: Generator<B>, function: (A, B) -> R): Generator<R>
        fun <B, C, R> combine(other1: Generator<B>, other2: Generator<C>, function: (A, B, C) -> R): Generator<R>
        fun <B, C, D, R> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, function: (A, B, C, D) -> R): Generator<R>
        fun <B, C, D, E, R> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, other4: Generator<E>, function: (A, B, C, D, E) -> R): Generator<R>
        fun <A> fail(error: Exception): Generator<A>
        fun <A> frequency(vararg generators: <ERROR CLASS><Double, Generator<A>>): Generator<A>
        val generate: (Random) -> ErrorOr<A>
        fun <A> impure(valueClosure: () -> A): Generator<A>
        fun <B> map(function: (A) -> B): Generator<B>
        fun <B> product(other: Generator<(A) -> B>): Generator<B>
        fun <A> pure(value: A): Generator<A>
        fun <A> sequence(generators: List<Generator<A>>): Generator<List<A>>
        fun <A> success(generate: (Random) -> A): Generator<A>
      abstract class GroupClauseVerifier<S : ContractState, C : CommandData, K : Any> : Clause<ContractState, C, Unit>
        Module Contents GroupClauseVerifier(clause: Clause<S, C, K>)
        val clause: Clause<S, C, K>
        open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
        abstract fun groupStates(tx: TransactionForContract): List<InOutGroup<S, K>>
        open fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
      class HTTPCertificateSigningService : CertificateSigningService
        Module Contents HTTPCertificateSigningService(server: <ERROR CLASS>)
        val clientVersion: String
        fun retrieveCertificates(requestId: String): Array<Certificate>?
        val server: <ERROR CLASS>
        fun submitRequest(request: <ERROR CLASS>): String
      interface HandshakeMessage : PartyRequestMessage
        Module Contents abstract val receiveSessionID: Long
        abstract val sendSessionID: Long
        open val sessionID: Long
      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
        Rates
        SetupNodeA
        SetupNodeB
        Trade
      class IRSSimulation : Simulation
        Module Contents IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)
        fun iterate(): <ERROR CLASS>?
        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
      open class InMemoryNetworkMapCache : SingletonSerializeAsToken, NetworkMapCache
        Module Contents InMemoryNetworkMapCache()
        open fun addMapService(net: MessagingService, networkMapAddress: SingleMessageRecipient, 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 mapServiceRegistered: <ERROR CLASS><Unit>
        open val networkMapNodes: List<NodeInfo>
        open val notaryNodes: List<NodeInfo>
        open val partyNodes: List<NodeInfo>
        fun processUpdatePush(req: Update): Unit
        protected var registeredNodes: MutableMap<Party, NodeInfo>
        open val regulators: List<NodeInfo>
        open fun removeNode(node: NodeInfo): Unit
        open fun runWithoutMapService(): Unit
      class InMemoryNetworkMapService : AbstractNetworkMapService
        Module Contents InMemoryNetworkMapService(services: ServiceHubInternal)
        protected val registeredNodes: MutableMap<Party, NodeRegistrationInfo>
        protected val subscribers: <ERROR CLASS>
      class InMemoryUniquenessProvider : UniquenessProvider
        Module Contents InMemoryUniquenessProvider()
        fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party): Unit
      open class InMemoryVaultService : SingletonSerializeAsToken, VaultService
        Module Contents InMemoryVaultService(services: ServiceHub)
        protected class InnerState
          Module Contents InnerState()
          var vault: Vault
        open val currentVault: Vault
        open val linearHeads: Map<UniqueIdentifier, StateAndRef<LinearState>>
        protected open val log: <ERROR CLASS>
        protected val mutex: ThreadBox<InnerState>
        open fun notifyAll(txns: Iterable<WireTransaction>): Vault
        protected val services: ServiceHub
        open val updates: <ERROR CLASS><Update>
      class InstantGenerator
        Module Contents InstantGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Instant
      class InsufficientBalanceException : Exception
        Module Contents InsufficientBalanceException(amountMissing: Amount<*>)
        val amountMissing: Amount<*>
        fun toString(): String
      class InterestRateSwap : Contract
        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 Clauses
          Module Contents abstract class AbstractIRSClause : Clause<State, Commands, UniqueIdentifier>
            Module Contents AbstractIRSClause()
            fun checkLegAmounts(legs: List<CommonLeg>): Unit
            fun checkLegDates(legs: List<CommonLeg>): Unit
            fun checkRates(legs: List<CommonLeg>): Boolean
            fun checkSchedules(legs: List<CommonLeg>): Boolean
            fun getFloatingLegPaymentsDifferences(payments1: Map<LocalDate, Event>, payments2: Map<LocalDate, Event>): List<<ERROR CLASS><LocalDate, <ERROR CLASS><FloatingRatePaymentEvent, FloatingRatePaymentEvent>>>
          class Agree : AbstractIRSClause
            Module Contents Agree()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Fix : AbstractIRSClause
            Module Contents Fix()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Group : GroupClauseVerifier<State, Commands, UniqueIdentifier>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, UniqueIdentifier>>
          class Mature : AbstractIRSClause
            Module Contents Mature()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Pay : AbstractIRSClause
            Module Contents Pay()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Timestamped : Clause<ContractState, Commands, Unit>
            Module Contents Timestamped()
            fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Unit?): Set<Commands>
        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
        object OracleType : ServiceType
        data class State : FixableDealState, SchedulableState
          Module Contents State(fixedLeg: FixedLeg, floatingLeg: FloatingLeg, calculation: Calculation, common: Common, linearId: UniqueIdentifier = UniqueIdentifier(common.tradeID))
          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
          val linearId: UniqueIdentifier
          fun nextFixingOf(): FixOf?
          fun nextScheduledActivity(thisStateRef: StateRef, protocolLogicRefFactory: ProtocolLogicRefFactory): ScheduledActivity?
          val oracleType: ServiceType
          val participants: List<PublicKey>
          val parties: List<Party>
          fun prettyPrint(): <ERROR CLASS>
          val ref: String
          fun withPublicKey(before: Party, after: PublicKey): DealState
        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>
        fun verify(tx: TransactionForContract): Unit
      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
      class IssueGenerator
        Module Contents IssueGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Issue
      data class Issued<out P>
        Module Contents Issued(issuer: PartyAndReference, product: P)
        val issuer: PartyAndReference
        val product: P
        fun toString(): String
      class IssuedGenerator<T>
        Module Contents IssuedGenerator(productGenerator: <ERROR CLASS><T>)
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Issued<T>
        val productGenerator: <ERROR CLASS><T>
      class JDBCHashMap<K : Any, V : Any> : AbstractJDBCHashMap<K, V, BlobMapTable>
        Module Contents JDBCHashMap(tableName: String, loadOnInit: Boolean = false)
        class BlobMapTable : JDBCHashedTable
          Module Contents BlobMapTable(tableName: String)
          val key: <ERROR CLASS>
          val value: <ERROR CLASS>
        protected fun addKeyToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        protected fun addValueToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        protected fun keyFromRow(it: <ERROR CLASS>): K
        protected fun valueFromRow(it: <ERROR CLASS>): V
      class JDBCHashSet<K : Any> : AbstractJDBCHashSet<K, BlobSetTable>
        Module Contents JDBCHashSet(tableName: String, loadOnInit: Boolean = false)
        class BlobSetTable : JDBCHashedTable
          Module Contents BlobSetTable(tableName: String)
          val key: <ERROR CLASS>
        protected fun addElementToInsert(it: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit
        protected fun elementFromRow(it: <ERROR CLASS>): K
      open class JDBCHashedTable
        Module Contents JDBCHashedTable(tableName: String)
        val keyHash: <ERROR CLASS>
        val seqNo: <ERROR CLASS>
      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
      data class LastAcknowledgeInfo
        Module Contents LastAcknowledgeInfo(mapVersion: Int)
        val mapVersion: Int
      class LedgerTransaction : BaseTransaction
        Module Contents LedgerTransaction(inputs: List<StateAndRef<*>>, outputs: List<TransactionState<ContractState>>, commands: List<AuthenticatedObject<CommandData>>, attachments: List<Attachment>, id: SecureHash, notary: Party?, signers: List<PublicKey>, timestamp: Timestamp?, type: TransactionType)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        val id: SecureHash
        val inputs: List<StateAndRef<*>>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun toTransactionForContract(): TransactionForContract
        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 class ClauseVerifier<S : LinearState> : Clause<ContractState, CommandData, Unit>
          Module Contents ClauseVerifier(stateClass: Class<S>)
          val stateClass: Class<S>
          fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<CommandData>>, groupingKey: Unit?): Set<CommandData>
        abstract fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        abstract val linearId: UniqueIdentifier
      object LogHelper
        Module Contents fun reset(vararg names: String): Unit
        fun reset(vararg classes: KClass<*>): <ERROR CLASS>
        fun setLevel(vararg loggerNames: String): Unit
        fun setLevel(vararg classes: KClass<*>): <ERROR CLASS>
      data class MarshalledObservation
        Module Contents MarshalledObservation(forHandle: Int, what: <ERROR CLASS><out <ERROR CLASS>>)
        val forHandle: Int
        val what: <ERROR CLASS><out <ERROR CLASS>>
      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>
      object Models
        Module Contents fun <M : Any> get(klass: KClass<M>, origin: KClass<*>): M
        inline fun <reified M : Any> get(origin: KClass<*>): M
        fun <M : Any> initModel(klass: KClass<M>): <ERROR CLASS>
      class MonitoringService : SingletonSerializeAsToken
        Module Contents MonitoringService(metrics: <ERROR CLASS>)
        val metrics: <ERROR CLASS>
      interface MoveCommand : CommandData
        Module Contents abstract val contractHash: SecureHash?
      class MoveGenerator
        Module Contents MoveGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Move
      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
      interface NamedByHash
        Module Contents abstract val id: SecureHash
      open class NetClause<C : CommandData, P> : Clause<ContractState, C, Unit>
        Module Contents NetClause()
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
        fun verifyNetCommand(inputs: List<State<P>>, outputs: List<State<P>>, command: AuthenticatedObject<NetCommand>, netState: NetState<P>): Unit
      interface NetCommand : CommandData
        Module Contents abstract val type: NetType
      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, prevNodeInfo: NodeInfo?, type: MapChangeType)
          val node: NodeInfo
          val prevNodeInfo: NodeInfo?
          val type: MapChangeType
        enum class MapChangeType
          Module Contents Added
          Modified
          Removed
        abstract fun addMapService(net: MessagingService, networkMapAddress: SingleMessageRecipient, 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 mapServiceRegistered: <ERROR CLASS><Unit>
        abstract val networkMapNodes: List<NodeInfo>
        abstract val notaryNodes: List<NodeInfo>
        abstract val partyNodes: List<NodeInfo>
        abstract val regulators: List<NodeInfo>
        abstract fun removeNode(node: NodeInfo): Unit
        abstract fun runWithoutMapService(): 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, mapVersion: Int, replyTo: MessageRecipients)
          val mapVersion: Int
          val replyTo: MessageRecipients
          val wireReg: WireNodeRegistration
        data class UpdateAcknowledge
          Module Contents UpdateAcknowledge(mapVersion: Int, replyTo: MessageRecipients)
          val mapVersion: Int
          val replyTo: MessageRecipients
        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>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
        Module Contents NoZeroSizedOutputs()
        open fun toString(): String
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
      class Node : AbstractNode
        Module Contents Node(p2pAddr: <ERROR CLASS>, webServerAddr: <ERROR CLASS>, configuration: NodeConfiguration, networkMapAddress: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, clock: Clock = NodeClock(), messagingServerAddr: <ERROR CLASS>? = null)
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingServiceInternal
        protected fun makeUniquenessProvider(): PersistentUniquenessProvider
        var messageBroker: ArtemisMessagingServer?
        val messagingServerAddr: <ERROR CLASS>?
        val p2pAddr: <ERROR CLASS>
        fun run(): Unit
        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 : NodeSSLConfiguration
        Module Contents abstract val basedir: Path
        abstract val certificateSigningService: <ERROR CLASS>
        open val certificatesPath: Path
        open val dataSourceProperties: Properties
        abstract val devMode: Boolean
        abstract val emailAddress: String
        abstract val exportJMXto: String
        fun loadConfig(baseDirectoryPath: Path, configFileOverride: Path? = null, allowMissingConfig: Boolean = false, configOverrides: Map<String, Any?> = emptyMap()): <ERROR CLASS>
        val log: <ERROR CLASS>
        abstract val myLegalName: String
        abstract val nearestCity: String
      class NodeConfigurationFromConfig : NodeConfiguration
        Module Contents NodeConfigurationFromConfig(config: <ERROR CLASS> = ConfigFactory.load())
        val basedir: Path
        val certificateSigningService: <ERROR CLASS>
        val config: <ERROR CLASS>
        val dataSourceProperties: Properties
        val devMode: Boolean
        val emailAddress: String
        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 NodeMessagingClient : ArtemisMessagingComponent, MessagingServiceInternal
        Module Contents NodeMessagingClient(config: NodeConfiguration, serverHostPort: <ERROR CLASS>, myIdentity: PublicKey?, executor: AffinityExecutor, persistentInbox: Boolean = true, rpcOps: CordaRPCOps? = null)
        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 executor: AffinityExecutor
        val log: <ERROR CLASS>
        fun makeNetworkMapAddress(hostAndPort: <ERROR CLASS>): SingleMessageRecipient
        val myAddress: SingleMessageRecipient
        val myIdentity: PublicKey?
        val persistentInbox: Boolean
        fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        fun run(): Unit
        fun send(message: Message, target: MessageRecipients): Unit
        val serverHostPort: <ERROR CLASS>
        fun start(): Unit
        fun stop(): Unit
      class NodeMonitorClient
        Module Contents NodeMonitorClient(net: MessagingService, node: NodeInfo, outEvents: <ERROR CLASS><ClientToServiceCommand>, inEvents: <ERROR CLASS><ServiceToClientEvent>, snapshot: <ERROR CLASS><StateSnapshotMessage>)
        val inEvents: <ERROR CLASS><ServiceToClientEvent>
        val net: MessagingService
        val node: NodeInfo
        val outEvents: <ERROR CLASS><ClientToServiceCommand>
        fun register(): <ERROR CLASS><Boolean>
        val snapshot: <ERROR CLASS><StateSnapshotMessage>
      class NodeMonitorModel
        Module Contents NodeMonitorModel()
        val clientToService: <ERROR CLASS><ClientToServiceCommand>
        fun register(messagingService: MessagingService, monitorNodeInfo: NodeInfo): Unit
        val serviceToClient: <ERROR CLASS><ServiceToClientEvent>
        val snapshot: <ERROR CLASS><StateSnapshotMessage>
      class NodeMonitorService : AbstractNodeService
        Module Contents NodeMonitorService(services: ServiceHubInternal, smm: StateMachineManager)
        val DEREGISTER_TOPIC: String
        val IN_EVENT_TOPIC: String
        class InputStateRefResolveFailed : Exception
          Module Contents InputStateRefResolveFailed(stateRefs: List<StateRef>)
        val OUT_EVENT_TOPIC: String
        val REGISTER_TOPIC: String
        data class RegisteredListener
          Module Contents RegisteredListener(recipients: MessageRecipients, sessionID: Long)
          val recipients: MessageRecipients
          val sessionID: Long
        val STATE_TOPIC: String
        val listeners: MutableSet<RegisteredListener>
        val logger: <ERROR CLASS>
        fun processDeregisterRequest(req: DeregisterRequest): Unit
        fun processRegisterRequest(req: RegisterRequest): Unit
        val smm: StateMachineManager
      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
      data class NodeRegistrationInfo
        Module Contents NodeRegistrationInfo(reg: NodeRegistration, mapVersion: Int)
        val mapVersion: Int
        val reg: NodeRegistration
      interface NodeSSLConfiguration
        Module Contents abstract val certificatesPath: Path
        abstract val keyStorePassword: String
        open val keyStorePath: Path
        abstract val trustStorePassword: String
        open val trustStorePath: Path
      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 NodeVaultService : SingletonSerializeAsToken, VaultService
        Module Contents NodeVaultService(services: ServiceHub)
        val currentVault: Vault
        val linearHeads: Map<UniqueIdentifier, StateAndRef<LinearState>>
        val log: <ERROR CLASS>
        protected val mutex: ReentrantLock
        fun notifyAll(txns: Iterable<WireTransaction>): Vault
        val updates: <ERROR CLASS><Update>
      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)
      object NotaryChangeProtocol : AbstractStateReplacementProtocol<Party>
        Module Contents class Acceptor : Acceptor<Party>
          Module Contents Acceptor(otherSide: Party, progressTracker: ProgressTracker = tracker())
          val progressTracker: ProgressTracker
          protected val topic: String
          fun verifyProposal(maybeProposal: UntrustworthyData<Proposal<Party>>): Proposal<Party>
        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 SignaturesMissing : NotaryError
          Module Contents SignaturesMissing(missingSigners: Set<PublicKey>)
          val missingSigners: Set<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, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        interface Factory
          Module Contents abstract fun create(otherSide: Party, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        data class Handshake : HandshakeMessage
          Module Contents Handshake(replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
          open fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit
          open fun call(): Unit
          val otherSide: Party
          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(services: ServiceHubInternal, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        object Type : ServiceType
        abstract val logger: <ERROR CLASS>
        abstract val protocolFactory: Factory
        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> : Contract
        Module Contents Obligation()
        interface Clauses
          Module Contents class ConserveAmount<P> : AbstractConserveAmount<State<P>, Commands, Terms<P>>
            Module Contents ConserveAmount()
          class Group<P> : GroupClauseVerifier<State<P>, Commands, Issued<Terms<P>>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State<P>, Issued<Terms<P>>>>
          class Issue<P> : AbstractIssue<State<P>, Commands, Terms<P>>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
          class Net<C : CommandData, P> : NetClause<C, P>
            Module Contents Net()
            val lifecycleClause: VerifyLifecycle<ContractState, C, Unit, P>
            fun toString(): String
            fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
          class SetLifecycle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
            Module Contents SetLifecycle()
            val requiredCommands: Set<Class<out CommandData>>
            fun toString(): String
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms<P>>?): Set<Commands>
          class Settle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
            Module Contents Settle()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms<P>>?): Set<Commands>
          class VerifyLifecycle<S : ContractState, C : CommandData, T : Any, P> : Clause<S, C, T>
            Module Contents VerifyLifecycle()
            fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: T?): Set<C>
        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 : NetCommand, 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
        fun generateCloseOutNetting(tx: TransactionBuilder, signer: PublicKey, vararg states: State<P>): Unit
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<Terms<P>>>, 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
        fun verify(tx: TransactionForContract): Unit
      abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : Contract
        Module Contents OnLedgerAsset()
        abstract val conserveClause: AbstractConserveAmount<S, C, T>
        abstract fun deriveState(txState: TransactionState<S>, amount: Amount<Issued<T>>, owner: PublicKey): TransactionState<S>
        abstract fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): Collection<AuthenticatedObject<C>>
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, 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
        fun open(): ByteArrayInputStream
        val size: Int
        open fun toString(): String
      class OptionalConfig<out T>
        Module Contents OptionalConfig(conf: <ERROR CLASS>, lambda: () -> T)
        val conf: <ERROR CLASS>
        operator fun getValue(receiver: Any, metadata: KProperty<*>): T
        val lambda: () -> T
      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>
      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
      class PartyAndReferenceGenerator
        Module Contents PartyAndReferenceGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): PartyAndReference
      class PartyGenerator
        Module Contents PartyGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Party
      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>
        val updates: <ERROR CLASS><SignedTransaction>
      open class PercentageRatioUnit : RatioUnit
        Module Contents PercentageRatioUnit(percentageAsString: String)
        open fun toString(): <ERROR CLASS>
      class PersistentKeyManagementService : SingletonSerializeAsToken, KeyManagementService
        Module Contents PersistentKeyManagementService(initialKeys: Set<KeyPair>)
        fun freshKey(): KeyPair
        val keys: Map<PublicKey, PrivateKey>
      class PersistentNetworkMapService : AbstractNetworkMapService
        Module Contents PersistentNetworkMapService(services: ServiceHubInternal)
        protected val registeredNodes: MutableMap<Party, NodeRegistrationInfo>
        protected val subscribers: ThreadBox<JDBCHashMap<SingleMessageRecipient, LastAcknowledgeInfo>>
      class PersistentUniquenessProvider : UniquenessProvider, SingletonSerializeAsToken
        Module Contents PersistentUniquenessProvider()
        fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party): Unit
        val committedStates: <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>
      sealed class PortAllocation
        Module Contents class Incremental : PortAllocation
          Module Contents Incremental(portCounter: Int)
          fun nextPort(): Int
        class RandomFree : PortAllocation
          Module Contents RandomFree()
          fun nextPort(): Int
        fun nextHostAndPort(): <ERROR CLASS>
        abstract fun nextPort(): Int
      class PrivateKeyGenerator
        Module Contents PrivateKeyGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): PrivateKey
      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
      interface ProtocolIORequest
        Module Contents abstract val stackTraceInCaseOfProblems: StackSnapshot
        abstract val topic: 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(otherParty: Party): UntrustworthyData<T>
        fun <T : Any> receive(otherParty: Party, receiveType: Class<T>): UntrustworthyData<T>
        fun registerSession(receivedHandshake: HandshakeMessage): Unit
        fun send(otherParty: Party, payload: Any): Unit
        inline fun <reified T : Any> sendAndReceive(otherParty: Party, payload: Any): UntrustworthyData<T>
        fun <T : Any> sendAndReceive(otherParty: Party, payload: Any, receiveType: Class<T>): UntrustworthyData<T>
        val serviceHub: ServiceHub
        fun <R> subProtocol(subLogic: ProtocolLogic<R>, inheritParentSessions: Boolean = false): 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 val machineId: Long
        abstract fun <T : Any> receive(topic: String, sessionIDForReceive: Long, receiveType: Class<T>): UntrustworthyData<T>
        abstract val resultFuture: <ERROR CLASS><R>
        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, receiveType: 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>
        val machineId: Long
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, receiveType: 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, receiveType: Class<T>): UntrustworthyData<T>
        lateinit var serviceHub: ServiceHubInternal
      data class ProtocolStatus
        Module Contents ProtocolStatus(status: String)
        val status: String
      class PublicKeyGenerator
        Module Contents PublicKeyGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): PublicKey
      abstract class RPCDispatcher
        Module Contents RPCDispatcher(target: Any)
        fun dispatch(msg: ClientRPCRequestMessage): Unit
        abstract fun send(bits: SerializedBytes<*>, toAddress: String): Unit
        fun start(rpcConsumer: <ERROR CLASS>, rpcNotificationConsumer: <ERROR CLASS>?, onExecutor: AffinityExecutor): Unit
        val target: Any
      open class RPCException : RuntimeException
        Module Contents RPCException(msg: String)
        RPCException(msg: String, cause: Throwable?)
        class DeadlineExceeded : RPCException
          Module Contents DeadlineExceeded(rpcName: String)
      interface RPCOps
        Module Contents abstract val protocolVersion: Int
      @Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables
        Module Contents RPCReturnsObservables()
      @Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion
        Module Contents RPCSinceVersion(version: Int)
        val version: Int
      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, 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 : HandshakeMessage
          Module Contents QueryRequest(queries: List<FixOf>, deadline: Instant, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val deadline: Instant
          val queries: List<FixOf>
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
        object SIGNING : Step
        data class SignRequest : HandshakeMessage
          Module Contents SignRequest(tx: WireTransaction, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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?
        abstract val updates: <ERROR CLASS><SignedTransaction>
      data class ReceiveOnly<T> : ReceiveRequest<T>
        Module Contents ReceiveOnly(topic: String, receiveType: Class<T>, receiveSessionID: Long)
        val receiveSessionID: Long
        val receiveType: Class<T>
        val stackTraceInCaseOfProblems: StackSnapshot
        val topic: String
      interface ReceiveRequest<T> : ProtocolIORequest
        Module Contents abstract val receiveSessionID: Long
        open val receiveTopicSession: TopicSession
        abstract val receiveType: Class<T>
      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
      data class RegisterRequest : DirectRequestMessage
        Module Contents RegisterRequest(replyToRecipient: SingleMessageRecipient, sessionID: Long)
        val replyToRecipient: SingleMessageRecipient
        val sessionID: Long
      data class RegisterResponse
        Module Contents RegisterResponse(success: Boolean)
        val success: Boolean
      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
        var transactionCountLimit: Int
      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)
        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
        open fun toString(): <ERROR CLASS>
      class SecureHashGenerator
        Module Contents SecureHashGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): SecureHash
      data class SendAndReceive<T> : SendRequest, ReceiveRequest<T>
        Module Contents SendAndReceive(topic: String, destination: Party, payload: Any, sendSessionID: Long, receiveType: Class<T>, receiveSessionID: Long)
        val destination: Party
        val payload: Any
        val receiveSessionID: Long
        val receiveType: Class<T>
        val sendSessionID: Long
        val stackTraceInCaseOfProblems: StackSnapshot
        val topic: String
      data class SendOnly : SendRequest
        Module Contents SendOnly(destination: Party, topic: String, payload: Any, sendSessionID: Long)
        val destination: Party
        val payload: Any
        val sendSessionID: Long
        val stackTraceInCaseOfProblems: StackSnapshot
        val topic: String
      interface SendRequest : ProtocolIORequest
        Module Contents abstract val destination: Party
        abstract val payload: Any
        abstract val sendSessionID: Long
      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
      class ServerRPCOps : CordaRPCOps
        Module Contents ServerRPCOps(services: ServiceHubInternal)
        val protocolVersion: Int
      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 vaultService: VaultService
      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
      sealed class ServiceToClientEvent
        Module Contents class OutputState : ServiceToClientEvent
          Module Contents OutputState(time: Instant, consumed: Set<StateRef>, produced: Set<StateAndRef<ContractState>>)
          val consumed: Set<StateRef>
          val produced: Set<StateAndRef<ContractState>>
          fun toString(): String
        class Progress : ServiceToClientEvent
          Module Contents Progress(time: Instant, fiberId: Long, message: String)
          val fiberId: Long
          val message: String
          fun toString(): String
        class StateMachine : ServiceToClientEvent
          Module Contents StateMachine(time: Instant, fiberId: Long, label: String, addOrRemove: AddOrRemove)
          val addOrRemove: AddOrRemove
          val fiberId: Long
          val label: String
          fun toString(): String
        class Transaction : ServiceToClientEvent
          Module Contents Transaction(time: Instant, transaction: LedgerTransaction)
          fun toString(): String
          val transaction: LedgerTransaction
        class TransactionBuild : ServiceToClientEvent
          Module Contents TransactionBuild(time: Instant, id: UUID, state: TransactionBuildResult)
          val id: UUID
          val state: TransactionBuildResult
          fun toString(): String
        val time: Instant
      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>)
        class SignaturesMissingException : NamedByHash, SignatureException
          Module Contents SignaturesMissingException(missing: Set<PublicKey>, descriptions: List<String>, id: SecureHash)
          val descriptions: List<String>
          val id: SecureHash
          val missing: Set<PublicKey>
          fun toString(): String
        fun checkSignaturesAreValid(): Unit
        val id: SecureHash
        operator fun plus(sig: WithKey): SignedTransaction
        operator fun plus(sigList: Collection<WithKey>): SignedTransaction
        val sigs: List<WithKey>
        fun toLedgerTransaction(services: ServiceHub): LedgerTransaction
        val tx: WireTransaction
        val txBits: SerializedBytes<WireTransaction>
        fun verifySignatures(vararg allowedToBeMissing: PublicKey): WireTransaction
        fun withAdditionalSignature(sig: WithKey): SignedTransaction
        fun withAdditionalSignatures(sigList: Iterable<WithKey>): SignedTransaction
      class SignedTransactionGenerator
        Module Contents SignedTransactionGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): SignedTransaction
      class SimpleNotaryService : NotaryService
        Module Contents SimpleNotaryService(services: ServiceHubInternal, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: DefaultFactory
      abstract class Simulation
        Module Contents Simulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)
        inner class BankFactory
          Module Contents BankFactory()
          var counter: Int
          fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
          fun createAll(): List<SimulatedNode>
        object NetworkMapNodeFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        object NotaryNodeFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        object RatesOracleFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        object RegulatorFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        open class SimulatedNode
          Module Contents SimulatedNode(config: NodeConfiguration, mockNet: <ERROR CLASS>, networkMapAddress: SingleMessageRecipient?, 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(): <ERROR CLASS>?
        val network: <ERROR CLASS>
        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 SingleMessageRecipient : MessageRecipients
      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>): ProtocolStateMachine<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
      sealed class StateMachineStatus
        Module Contents class Added : StateMachineStatus
          Module Contents Added(stateMachineName: String)
        class Removed : StateMachineStatus
          Module Contents Removed(stateMachineName: String)
        val stateMachineName: String
        open fun toString(): String
      data class StateRef
        Module Contents StateRef(txhash: SecureHash, index: Int)
        val index: Int
        fun toString(): String
        val txhash: SecureHash
      class StateRefGenerator
        Module Contents StateRefGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): StateRef
      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
      data class StateSnapshotMessage
        Module Contents StateSnapshotMessage(contractStates: Collection<StateAndRef<ContractState>>, protocolStates: Collection<String>)
        val contractStates: Collection<StateAndRef<ContractState>>
        val protocolStates: Collection<String>
      sealed class StatesModification<out T : ContractState>
        Module Contents class Diff<out T : ContractState> : StatesModification<T>
          Module Contents Diff(added: Collection<StateAndRef<T>>, removed: Collection<StateRef>)
          val added: Collection<StateAndRef<T>>
          val removed: Collection<StateRef>
        class Reset<out T : ContractState> : StatesModification<T>
          Module Contents Reset(states: Collection<StateAndRef<T>>)
          val states: Collection<StateAndRef<T>>
      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 ThreadBox<out T>
        Module Contents ThreadBox(content: T, lock: ReentrantLock = ReentrantLock())
        inline fun <R> alreadyLocked(body: T.() -> R): R
        fun checkNotLocked(): <ERROR CLASS>
        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
      data class Timestamp
        Module Contents Timestamp(time: Instant, tolerance: Duration)
        Timestamp(after: Instant?, before: Instant?)
        val after: Instant?
        val before: Instant?
        val midpoint: Instant
      class TimestampChecker
        Module Contents TimestampChecker(clock: Clock = Clock.systemUTC(), tolerance: Duration = 30.seconds)
        val clock: Clock
        fun isValid(timestampCommand: Timestamp): Boolean
        val tolerance: Duration
      class TimestampGenerator
        Module Contents TimestampGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Timestamp
      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>
      sealed class TrackedDelegate<M : Any>
        Module Contents class EventSinkDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents EventSinkDelegate(klass: KClass<M>, eventSinkProperty: (M) -> <ERROR CLASS><T>)
          val eventSinkProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class EventStreamDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents EventStreamDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)
          val eventStreamProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class ObjectPropertyDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObjectPropertyDelegate(klass: KClass<M>, objectPropertyProperty: (M) -> ObjectProperty<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObjectProperty<T>
          val objectPropertyProperty: (M) -> ObjectProperty<T>
        class ObservableDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObservableDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)
          val eventStreamProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class ObservableListDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObservableListDelegate(klass: KClass<M>, observableListProperty: (M) -> ObservableList<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<T>
          val observableListProperty: (M) -> ObservableList<T>
        class ObservableListReadOnlyDelegate<M : Any, out T> : TrackedDelegate<M>
          Module Contents ObservableListReadOnlyDelegate(klass: KClass<M>, observableListReadOnlyProperty: (M) -> ObservableList<out T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<out T>
          val observableListReadOnlyProperty: (M) -> ObservableList<out T>
        class ObservableValueDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObservableValueDelegate(klass: KClass<M>, observableValueProperty: (M) -> ObservableValue<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableValue<T>
          val observableValueProperty: (M) -> ObservableValue<T>
        class ObserverDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObserverDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)
          val eventStreamProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class WritableValueDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents WritableValueDelegate(klass: KClass<M>, writableValueProperty: (M) -> WritableValue<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): WritableValue<T>
          val writableValueProperty: (M) -> WritableValue<T>
        val klass: KClass<M>
      class TradeSimulation : Simulation
        Module Contents TradeSimulation(runAsync: Boolean, latencyInjector: <ERROR CLASS>?)
        protected fun startMainSimulation(): <ERROR CLASS><Unit>
      sealed class TransactionBuildResult
        Module Contents class Failed : TransactionBuildResult
          Module Contents Failed(message: String?)
          val message: String?
          fun toString(): String
        class ProtocolStarted : TransactionBuildResult
          Module Contents ProtocolStarted(fiberId: Long, transaction: LedgerTransaction?, message: String?)
          val fiberId: Long
          val message: String?
          fun toString(): String
          val transaction: LedgerTransaction?
      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(), timestamp: Timestamp? = null)
        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 addOutputState(state: TransactionState<*>): Int
        fun addOutputState(state: ContractState, notary: Party): Int
        fun addOutputState(state: ContractState): Int
        fun addSignatureUnchecked(sig: WithKey): TransactionBuilder
        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>
        var notary: Party?
        fun outputStates(): List<TransactionState<*>>
        protected val outputs: MutableList<TransactionState<ContractState>>
        fun setTime(time: Instant, timeTolerance: Duration): Unit
        fun setTime(newTimestamp: Timestamp): Unit
        fun signWith(key: KeyPair): TransactionBuilder
        protected val signers: MutableSet<PublicKey>
        val time: Timestamp?
        protected var timestamp: Timestamp?
        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
      sealed class TransactionCreateStatus
        Module Contents class Failed : TransactionCreateStatus
          Module Contents Failed(message: String?)
        class Started : TransactionCreateStatus
          Module Contents Started(message: String?)
        val message: String?
        open fun toString(): String
      data class TransactionForContract
        Module Contents TransactionForContract(inputs: List<ContractState>, outputs: List<ContractState>, attachments: List<Attachment>, commands: List<AuthenticatedObject<CommandData>>, origHash: SecureHash, inputNotary: Party? = null, timestamp: Timestamp? = 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 <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: Timestamp?
      class TransactionGraphSearch : Callable<List<WireTransaction>>
        Module Contents TransactionGraphSearch(transactions: ReadOnlyTransactionStorage, startPoints: List<WireTransaction>)
        class Query
          Module Contents Query(withCommandOfType: Class<out CommandData>? = null, followInputsOfType: Class<out ContractState>? = null)
          val followInputsOfType: Class<out ContractState>?
          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>
      class TransactionStateGenerator<T : ContractState>
        Module Contents TransactionStateGenerator(stateGenerator: <ERROR CLASS><T>)
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): TransactionState<T>
        val stateGenerator: <ERROR CLASS><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?)
          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)
            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
        enum class Direction
          Module Contents INPUT
          OUTPUT
        class InvalidNotaryChange : TransactionVerificationException
          Module Contents InvalidNotaryChange(tx: LedgerTransaction)
        class MoreThanOneNotary : TransactionVerificationException
          Module Contents MoreThanOneNotary(tx: LedgerTransaction)
        class NotaryChangeInWrongTransactionType : TransactionVerificationException
          Module Contents NotaryChangeInWrongTransactionType(tx: LedgerTransaction, outputNotary: Party)
          val outputNotary: Party
          fun toString(): String
        class SignersMissing : TransactionVerificationException
          Module Contents SignersMissing(tx: LedgerTransaction, missing: List<PublicKey>)
          val missing: List<PublicKey>
          fun toString(): String
        class TransactionMissingEncumbranceException : TransactionVerificationException
          Module Contents TransactionMissingEncumbranceException(tx: LedgerTransaction, missing: Int, inOut: Direction)
          val inOut: Direction
          val message: String?
          val missing: Int
        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(otherParty: Party, notary: Party, dealToBuy: T, progressTracker: ProgressTracker = Secondary.tracker())
          protected open fun assembleSharedTX(handshake: Handshake<T>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val dealToBuy: T
          val notary: Party
          open val otherParty: Party
          open val progressTracker: ProgressTracker
          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(otherParty: Party, oracleType: ServiceType, progressTracker: ProgressTracker = Secondary.tracker())
          protected fun assembleSharedTX(handshake: Handshake<StateRef>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val oracleType: ServiceType
          val otherParty: Party
          val progressTracker: ProgressTracker
          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 : HandshakeMessage
          Module Contents FixingSessionInitiation(timeout: Duration, oracleType: ServiceType, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val oracleType: ServiceType
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
          val timeout: Duration
        class Floater : Primary<StateRef>
          Module Contents Floater(otherParty: Party, payload: StateRef, progressTracker: ProgressTracker = Primary.tracker())
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherParty: Party
          val payload: StateRef
          val progressTracker: ProgressTracker
        data class Handshake<out T>
          Module Contents Handshake(payload: T, publicKey: PublicKey)
          val payload: T
          val publicKey: PublicKey
        class Instigator<out T : DealState> : Primary<T>
          Module Contents Instigator(otherParty: Party, notary: Party, payload: T, myKeyPair: KeyPair, progressTracker: ProgressTracker = Primary.tracker())
          open val myKeyPair: KeyPair
          val notary: Party
          open val notaryNode: NodeInfo
          open val otherParty: 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 otherParty: 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 otherParty: Party
          open val progressTracker: ProgressTracker
          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(otherParty: Party, notary: Party, acceptablePrice: Amount<Currency>, typeToBuy: Class<out OwnableState>)
          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 otherParty: Party
          open val progressTracker: ProgressTracker
          protected open val topic: String
          val typeToBuy: Class<out OwnableState>
        class Seller : ProtocolLogic<SignedTransaction>
          Module Contents Seller(otherParty: Party, notaryNode: NodeInfo, assetToSell: StateAndRef<OwnableState>, price: Amount<Currency>, myKeyPair: KeyPair, 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>
          open fun call(): SignedTransaction
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherParty: 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)
          val assetForSale: StateAndRef<OwnableState>
          val price: Amount<Currency>
          val sellerOwnerKey: PublicKey
        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>
      data class UniqueIdentifier
        Module Contents UniqueIdentifier(externalId: String? = null, id: UUID = UUID.randomUUID())
        val externalId: String?
        val id: UUID
        fun toString(): String
      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> unwrap(validator: (T) -> R): R
        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 : HandshakeMessage
          Module Contents UpdateBusinessDayMessage(date: LocalDate, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val date: LocalDate
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
      class ValidatingNotaryProtocol : Service
        Module Contents ValidatingNotaryProtocol(otherSide: Party, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit
      class ValidatingNotaryService : NotaryService
        Module Contents ValidatingNotaryService(services: ServiceHubInternal, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: Factory
      class Vault
        Module Contents Vault(states: Iterable<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>>
          fun toString(): String
        val states: Iterable<StateAndRef<ContractState>>
        inline fun <reified T : ContractState> statesOfType(): List<StateAndRef<T>>
      interface VaultService
        Module Contents abstract val currentVault: Vault
        abstract val linearHeads: Map<UniqueIdentifier, StateAndRef<LinearState>>
        open fun <T : LinearState> linearHeadsOfType_(stateType: Class<T>): Map<UniqueIdentifier, StateAndRef<T>>
        open fun notify(tx: WireTransaction): Vault
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Vault
        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
      class WireTransaction : BaseTransaction
        Module Contents WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<TransactionState<ContractState>>, commands: List<Command>, notary: Party?, signers: List<PublicKey>, type: TransactionType, timestamp: Timestamp?)
        val attachments: List<SecureHash>
        val commands: List<Command>
        fun deserialize(bits: SerializedBytes<WireTransaction>, kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun <T : ContractState> outRef(state: ContractState): StateAndRef<T>
        val serialized: SerializedBytes<WireTransaction>
        fun toLedgerTransaction(services: ServiceHub): LedgerTransaction
        fun toString(): String
      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
      class WiredTransactionGenerator
        Module Contents WiredTransactionGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): WireTransaction
      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 CORDA_CLIENT_CA: String
        val CORDA_CLIENT_CA_PRIVATE_KEY: String
        val CORDA_INTERMEDIATE_CA: String
        val CORDA_INTERMEDIATE_CA_PRIVATE_KEY: String
        val CORDA_ROOT_CA: String
        val CORDA_ROOT_CA_PRIVATE_KEY: String
        val ECDSA_CURVE: String
        val KEYSTORE_TYPE: String
        val KEY_GENERATION_ALGORITHM: String
        val SIGNATURE_ALGORITHM: String
        fun KeyStore.addOrReplaceCertificate(alias: String, cert: Certificate): Unit
        fun KeyStore.addOrReplaceKey(alias: String, key: Key, password: CharArray, chain: Array<Certificate>): Unit
        fun createCAKeyStoreAndTrustStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, trustStoreFilePath: Path, trustStorePassword: String): KeyStore
        fun createCertificateSigningRequest(myLegalName: String, nearestCity: String, email: String, keyPair: KeyPair): <ERROR CLASS>
        fun createIntermediateCert(domain: String, certificateAuthority: CACertAndKey): CACertAndKey
        fun createKeystoreForSSL(keyStoreFilePath: Path, storePassword: String, keyPassword: String, caKeyStore: KeyStore, caKeyPassword: String): KeyStore
        fun createSelfSignedCACert(myLegalName: 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 getX509Name(myLegalName: String, nearestCity: String, email: 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 loadOrCreateKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String, keyGenerator: () -> CACertAndKey): KeyPair
        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 operator fun Path.div(other: String): Path
        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<*> = GuavaSettableFuture.create<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>
      java.util.concurrent.Future
        Module Contents infix fun <F, T> Future<F>.map(mapper: (F) -> T): Future<T>
      javafx.beans.value.ObservableValue
        Module Contents fun <A, B> ObservableValue<out A>.bind(function: (A) -> ObservableValue<out B>): ObservableValue<out B>
        fun <A, B> ObservableValue<out A>.map(function: (A) -> B): ObservableValue<B>
      javafx.collections.ObservableList
        Module Contents fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<out A>
        fun <A> ObservableList<out ObservableValue<out A>>.flatten(): ObservableList<out A>
        fun <A, B> ObservableList<out A>.fold(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>
        fun <A, B> ObservableList<out A>.map(function: (A) -> B): ObservableList<B>
      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.Function1
        Module Contents fun <A, R> (A) -> R.lift(arg0: ObservableValue<A>): ObservableValue<R>
      kotlin.Function2
        Module Contents fun <A, B, R> (A, B) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>): ObservableValue<R>
      kotlin.Function3
        Module Contents fun <A, B, C, R> (A, B, C) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>, arg2: ObservableValue<C>): ObservableValue<R>
      kotlin.Function4
        Module Contents fun <A, B, C, D, R> (A, B, C, D) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>, arg2: ObservableValue<C>, arg3: ObservableValue<D>): ObservableValue<R>
      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.Throwable
        Module Contents val Throwable.rootCause: Throwable
      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 inline fun <reified T : ContractState> Iterable<StateAndRef<ContractState>>.filterStatesOfType(): List<StateAndRef<T>>
        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.List
        Module Contents fun <T> List<T>.indexOfOrThrow(item: T): Int
    package com.r3corda.client
      Module Contents class CordaRPCClient : Closeable, ArtemisMessagingComponent
        Module Contents CordaRPCClient(host: <ERROR CLASS>, certificatesPath: Path)
        fun close(): Unit
        val host: <ERROR CLASS>
        var myID: Int
        fun proxy(timeout: Duration? = null, minVersion: Int = 0): CordaRPCOps
        fun start(): Unit
      class NodeMonitorClient
        Module Contents NodeMonitorClient(net: MessagingService, node: NodeInfo, outEvents: <ERROR CLASS><ClientToServiceCommand>, inEvents: <ERROR CLASS><ServiceToClientEvent>, snapshot: <ERROR CLASS><StateSnapshotMessage>)
        val inEvents: <ERROR CLASS><ServiceToClientEvent>
        val net: MessagingService
        val node: NodeInfo
        val outEvents: <ERROR CLASS><ClientToServiceCommand>
        fun register(): <ERROR CLASS><Boolean>
        val snapshot: <ERROR CLASS><StateSnapshotMessage>
    package com.r3corda.client.fxutils
      Module Contents class AggregatedList<A, E, K : Any> : TransformationList<A, E>
        Module Contents AggregatedList(list: ObservableList<out E>, toKey: (E) -> K, assemble: (K, ObservableList<E>) -> A)
        val assemble: (K, ObservableList<E>) -> A
        fun get(index: Int): A?
        fun getSourceIndex(index: Int): Int
        val size: Int
        protected fun sourceChanged(c: Change<out E>): Unit
        val toKey: (E) -> K
      object AmountBindings
        Module Contents fun exchange(currency: ObservableValue<Currency>, exchangeRate: ObservableValue<ExchangeRate>): ObservableValue<<ERROR CLASS><Currency, (Amount<Currency>) -> Long>>
        fun <T> sum(amounts: ObservableList<Amount<T>>, token: T): <ERROR CLASS>
        fun sumAmountExchange(amounts: ObservableList<Amount<Currency>>, currency: ObservableValue<Currency>, exchangeRate: ObservableValue<ExchangeRate>): ObservableValue<Amount<Currency>>
      class ChosenList<E> : ObservableListBase<E>
        Module Contents ChosenList(chosenListObservable: ObservableValue<out ObservableList<out E>>)
        fun get(index: Int): E
        val size: Int
      class FlattenedList<A> : TransformationList<A, ObservableValue<out A>>
        Module Contents FlattenedList(sourceList: ObservableList<out ObservableValue<out A>>)
        class WrappedObservableValue<A>
          Module Contents WrappedObservableValue(observableValue: ObservableValue<A>)
          val observableValue: ObservableValue<A>
        fun get(index: Int): A
        fun getSourceIndex(index: Int): Int
        val indexMap: HashMap<WrappedObservableValue<out A>, <ERROR CLASS><Int, ChangeListener<A>>>
        val size: Int
        protected fun sourceChanged(c: Change<out ObservableValue<out A>>): Unit
        val sourceList: ObservableList<out ObservableValue<out A>>
      fun <A, B, C> <ERROR CLASS><A>.foldToObservableList(initialAccumulator: C, folderFun: (A, C, ObservableList<B>) -> C): ObservableList<B>
      fun <A, B> <ERROR CLASS><A>.foldToObservableValue(initial: B, folderFun: (A, B) -> B): ObservableValue<B>
      javafx.beans.value.ObservableValue
        Module Contents fun <A, B> ObservableValue<out A>.bind(function: (A) -> ObservableValue<out B>): ObservableValue<out B>
        fun <A, B> ObservableValue<out A>.map(function: (A) -> B): ObservableValue<B>
      javafx.collections.ObservableList
        Module Contents fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<out A>
        fun <A> ObservableList<out ObservableValue<out A>>.flatten(): ObservableList<out A>
        fun <A, B> ObservableList<out A>.fold(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>
        fun <A, B> ObservableList<out A>.map(function: (A) -> B): ObservableList<B>
      kotlin.Function1
        Module Contents fun <A, R> (A) -> R.lift(arg0: ObservableValue<A>): ObservableValue<R>
      kotlin.Function2
        Module Contents fun <A, B, R> (A, B) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>): ObservableValue<R>
      kotlin.Function3
        Module Contents fun <A, B, C, R> (A, B, C) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>, arg2: ObservableValue<C>): ObservableValue<R>
      kotlin.Function4
        Module Contents fun <A, B, C, D, R> (A, B, C, D) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>, arg2: ObservableValue<C>, arg3: ObservableValue<D>): ObservableValue<R>
      fun <A> A.lift(): ObservableValue<A>
    package com.r3corda.client.mock
      Module Contents class EventGenerator
        Module Contents EventGenerator(parties: List<Party>, notary: Party)
        val amountGenerator: <ERROR CLASS>
        val amountIssuedGenerator: <ERROR CLASS>
        val cashStateGenerator: <ERROR CLASS>
        val clientToServiceCommandGenerator: <ERROR CLASS>
        val consumedGenerator: Generator<Set<StateRef>>
        val currencies: <ERROR CLASS>
        val currencyGenerator: <ERROR CLASS>
        val exitCashGenerator: <ERROR CLASS>
        val issueCashGenerator: <ERROR CLASS>
        val issueRefGenerator: Generator<OpaqueBytes>
        val issuerGenerator: Generator<PartyAndReference>
        val moveCashGenerator: <ERROR CLASS>
        val notary: Party
        val outputStateGenerator: Generator<OutputState>
        val parties: List<Party>
        val partyGenerator: Generator<Party>
        val producedGenerator: Generator<Set<StateAndRef<ContractState>>>
        val publicKeyGenerator: <ERROR CLASS>
        val serviceToClientEventGenerator: Generator<ServiceToClientEvent>
      class Generator<out A>
        Module Contents Generator(generate: (Random) -> ErrorOr<A>)
        fun <B> bind(function: (A) -> Generator<B>): Generator<Nothing>
        fun <A> choice(generators: List<Generator<A>>): Generator<Nothing>
        fun <B, R> combine(other1: Generator<B>, function: (A, B) -> R): Generator<R>
        fun <B, C, R> combine(other1: Generator<B>, other2: Generator<C>, function: (A, B, C) -> R): Generator<R>
        fun <B, C, D, R> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, function: (A, B, C, D) -> R): Generator<R>
        fun <B, C, D, E, R> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, other4: Generator<E>, function: (A, B, C, D, E) -> R): Generator<R>
        fun <A> fail(error: Exception): Generator<A>
        fun <A> frequency(vararg generators: <ERROR CLASS><Double, Generator<A>>): Generator<A>
        val generate: (Random) -> ErrorOr<A>
        fun <A> impure(valueClosure: () -> A): Generator<A>
        fun <B> map(function: (A) -> B): Generator<B>
        fun <B> product(other: Generator<(A) -> B>): Generator<B>
        fun <A> pure(value: A): Generator<A>
        fun <A> sequence(generators: List<Generator<A>>): Generator<List<A>>
        fun <A> success(generate: (Random) -> A): Generator<A>
      fun Generator.Companion.double(): Generator<Double>
      fun Generator.Companion.doubleRange(from: Double, to: Double): Generator<Double>
      fun <A> Generator<A>.generateOrFail(random: Random, numberOfTries: Int = 1): A
      fun Generator.Companion.int(): Generator<Int>
      fun Generator.Companion.intRange(from: Int, to: Int): Generator<Int>
      fun <A> Generator.Companion.oneOf(list: List<A>): Generator<A>
      fun <A> Generator.Companion.pickOne(list: List<A>): Generator<A>
      fun <A> Generator.Companion.replicate(number: Int, generator: Generator<A>): Generator<List<A>>
      fun <A> Generator.Companion.replicatePoisson(meanSize: Double, generator: Generator<A>): Generator<List<A>>
      fun <A> Generator.Companion.sampleBernoulli(maxRatio: Double = 1.0, vararg collection: A): <ERROR CLASS>
      fun <A> Generator.Companion.sampleBernoulli(collection: Collection<A>, maxRatio: Double = 1.0): Generator<List<A>>
    package com.r3corda.client.model
      Module Contents class ContractStateModel
        Module Contents ContractStateModel()
        val cashStates: ObservableList<StateAndRef<State>>
        val cashStatesModification: <ERROR CLASS><StatesModification<State>>
        val contractStatesDiff: <ERROR CLASS><Diff<ContractState>>
      interface ExchangeRate
        Module Contents abstract fun rate(from: Currency, to: Currency): Double
      class ExchangeRateModel
        Module Contents ExchangeRateModel()
        val exchangeRate: ObservableValue<ExchangeRate>
      interface GatheredTransactionData
        Module Contents abstract val allEvents: ObservableList<out ServiceToClientEvent>
        abstract val fiberId: ObservableValue<Long?>
        abstract val lastUpdate: ObservableValue<Instant>
        abstract val protocolStatus: ObservableValue<ProtocolStatus?>
        abstract val stateMachineStatus: ObservableValue<StateMachineStatus?>
        abstract val status: ObservableValue<TransactionCreateStatus?>
        abstract val transaction: ObservableValue<LedgerTransaction?>
        abstract val uuid: ObservableValue<UUID?>
      class GatheredTransactionDataModel
        Module Contents GatheredTransactionDataModel()
        val gatheredTransactionDataList: ObservableList<out GatheredTransactionData>
      data class GatheredTransactionDataWritable : GatheredTransactionData
        Module Contents GatheredTransactionDataWritable(fiberId: SimpleObjectProperty<Long?> = SimpleObjectProperty(null), uuid: SimpleObjectProperty<UUID?> = SimpleObjectProperty(null), stateMachineStatus: SimpleObjectProperty<StateMachineStatus?> = SimpleObjectProperty(null), protocolStatus: SimpleObjectProperty<ProtocolStatus?> = SimpleObjectProperty(null), transaction: SimpleObjectProperty<LedgerTransaction?> = SimpleObjectProperty(null), status: SimpleObjectProperty<TransactionCreateStatus?> = SimpleObjectProperty(null), lastUpdate: SimpleObjectProperty<Instant>, allEvents: ObservableList<ServiceToClientEvent> = FXCollections.observableArrayList())
        val allEvents: ObservableList<ServiceToClientEvent>
        val fiberId: SimpleObjectProperty<Long?>
        val lastUpdate: SimpleObjectProperty<Instant>
        val protocolStatus: SimpleObjectProperty<ProtocolStatus?>
        val stateMachineStatus: SimpleObjectProperty<StateMachineStatus?>
        val status: SimpleObjectProperty<TransactionCreateStatus?>
        val transaction: SimpleObjectProperty<LedgerTransaction?>
        val uuid: SimpleObjectProperty<UUID?>
      object Models
        Module Contents fun <M : Any> get(klass: KClass<M>, origin: KClass<*>): M
        inline fun <reified M : Any> get(origin: KClass<*>): M
        fun <M : Any> initModel(klass: KClass<M>): <ERROR CLASS>
      class NodeMonitorModel
        Module Contents NodeMonitorModel()
        val clientToService: <ERROR CLASS><ClientToServiceCommand>
        fun register(messagingService: MessagingService, monitorNodeInfo: NodeInfo): Unit
        val serviceToClient: <ERROR CLASS><ServiceToClientEvent>
        val snapshot: <ERROR CLASS><StateSnapshotMessage>
      data class ProtocolStatus
        Module Contents ProtocolStatus(status: String)
        val status: String
      sealed class StateMachineStatus
        Module Contents class Added : StateMachineStatus
          Module Contents Added(stateMachineName: String)
        class Removed : StateMachineStatus
          Module Contents Removed(stateMachineName: String)
        val stateMachineName: String
        open fun toString(): String
      sealed class StatesModification<out T : ContractState>
        Module Contents class Diff<out T : ContractState> : StatesModification<T>
          Module Contents Diff(added: Collection<StateAndRef<T>>, removed: Collection<StateRef>)
          val added: Collection<StateAndRef<T>>
          val removed: Collection<StateRef>
        class Reset<out T : ContractState> : StatesModification<T>
          Module Contents Reset(states: Collection<StateAndRef<T>>)
          val states: Collection<StateAndRef<T>>
      sealed class TrackedDelegate<M : Any>
        Module Contents class EventSinkDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents EventSinkDelegate(klass: KClass<M>, eventSinkProperty: (M) -> <ERROR CLASS><T>)
          val eventSinkProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class EventStreamDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents EventStreamDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)
          val eventStreamProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class ObjectPropertyDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObjectPropertyDelegate(klass: KClass<M>, objectPropertyProperty: (M) -> ObjectProperty<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObjectProperty<T>
          val objectPropertyProperty: (M) -> ObjectProperty<T>
        class ObservableDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObservableDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)
          val eventStreamProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class ObservableListDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObservableListDelegate(klass: KClass<M>, observableListProperty: (M) -> ObservableList<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<T>
          val observableListProperty: (M) -> ObservableList<T>
        class ObservableListReadOnlyDelegate<M : Any, out T> : TrackedDelegate<M>
          Module Contents ObservableListReadOnlyDelegate(klass: KClass<M>, observableListReadOnlyProperty: (M) -> ObservableList<out T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<out T>
          val observableListReadOnlyProperty: (M) -> ObservableList<out T>
        class ObservableValueDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObservableValueDelegate(klass: KClass<M>, observableValueProperty: (M) -> ObservableValue<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableValue<T>
          val observableValueProperty: (M) -> ObservableValue<T>
        class ObserverDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents ObserverDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)
          val eventStreamProperty: (M) -> <ERROR CLASS><T>
          operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>
        class WritableValueDelegate<M : Any, T> : TrackedDelegate<M>
          Module Contents WritableValueDelegate(klass: KClass<M>, writableValueProperty: (M) -> WritableValue<T>)
          operator fun getValue(thisRef: Any, property: KProperty<*>): WritableValue<T>
          val writableValueProperty: (M) -> WritableValue<T>
        val klass: KClass<M>
      sealed class TransactionCreateStatus
        Module Contents class Failed : TransactionCreateStatus
          Module Contents Failed(message: String?)
        class Started : TransactionCreateStatus
          Module Contents Started(message: String?)
        val message: String?
        open fun toString(): String
      inline fun <reified M : Any, T> eventSink(noinline sinkProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>
      inline fun <reified M : Any, T> eventStream(noinline streamProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>
      fun ExchangeRate.exchangeAmount(amount: Amount<Currency>, to: Currency): Amount<Currency>
      fun ExchangeRate.exchangeDouble(amount: Amount<Currency>, to: Currency): Double
      inline fun <reified M : Any, T> objectProperty(noinline objectProperty: (M) -> ObjectProperty<T>): ObjectPropertyDelegate<M, T>
      inline fun <reified M : Any, T> observable(noinline observableProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>
      inline fun <reified M : Any, T> observableList(noinline observableListProperty: (M) -> ObservableList<T>): ObservableListDelegate<M, T>
      inline fun <reified M : Any, T> observableListReadOnly(noinline observableListProperty: (M) -> ObservableList<out T>): ObservableListReadOnlyDelegate<M, T>
      inline fun <reified M : Any, T> observableValue(noinline observableValueProperty: (M) -> ObservableValue<T>): ObservableValueDelegate<M, T>
      inline fun <reified M : Any, T> observer(noinline observerProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>
      inline fun <reified M : Any, T> writableValue(noinline writableValueProperty: (M) -> WritableValue<T>): WritableValueDelegate<M, T>
    package com.r3corda.contracts
      Module Contents val CP_LEGACY_PROGRAM_ID: CommercialPaperLegacy
      val CP_PROGRAM_ID: CommercialPaper
      class CommercialPaper : Contract
        Module Contents CommercialPaper()
        interface Clauses
          Module Contents class Group : GroupClauseVerifier<State, Commands, Issued<Terms>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, Issued<Terms>>>
          class Issue : AbstractIssue<State, Commands, Terms>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms>?): Set<Commands>
          class Move : Clause<State, Commands, Issued<Terms>>
            Module Contents Move()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms>?): Set<Commands>
          class Redeem : Clause<State, Commands, Issued<Terms>>
            Module Contents Redeem()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms>?): Set<Commands>
        interface Commands : CommandData
          Module Contents data class Issue : IssueCommand, Commands
            Module Contents Issue(nonce: Long = random63BitValue())
            val nonce: Long
          data class Move : Move, Commands
            Module Contents Move(contractHash: SecureHash? = null)
            val contractHash: SecureHash?
          class Redeem : TypeOnlyCommandData, Commands
            Module Contents Redeem()
        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
        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>, vault: List<StateAndRef<State>>): Unit
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForContract): Unit
      class CommercialPaperLegacy : Contract
        Module Contents CommercialPaperLegacy()
        interface Commands : CommandData
          Module Contents class Issue : TypeOnlyCommandData, Commands
            Module Contents Issue()
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
          class Redeem : TypeOnlyCommandData, Commands
            Module Contents Redeem()
        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: <ERROR CLASS>
          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
        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>, vault: Vault): Unit
        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 : Contract
        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 Clauses
          Module Contents abstract class AbstractIRSClause : Clause<State, Commands, UniqueIdentifier>
            Module Contents AbstractIRSClause()
            fun checkLegAmounts(legs: List<CommonLeg>): Unit
            fun checkLegDates(legs: List<CommonLeg>): Unit
            fun checkRates(legs: List<CommonLeg>): Boolean
            fun checkSchedules(legs: List<CommonLeg>): Boolean
            fun getFloatingLegPaymentsDifferences(payments1: Map<LocalDate, Event>, payments2: Map<LocalDate, Event>): List<<ERROR CLASS><LocalDate, <ERROR CLASS><FloatingRatePaymentEvent, FloatingRatePaymentEvent>>>
          class Agree : AbstractIRSClause
            Module Contents Agree()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Fix : AbstractIRSClause
            Module Contents Fix()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Group : GroupClauseVerifier<State, Commands, UniqueIdentifier>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, UniqueIdentifier>>
          class Mature : AbstractIRSClause
            Module Contents Mature()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Pay : AbstractIRSClause
            Module Contents Pay()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State>, outputs: List<State>, commands: List<AuthenticatedObject<Commands>>, groupingKey: UniqueIdentifier?): Set<Commands>
          class Timestamped : Clause<ContractState, Commands, Unit>
            Module Contents Timestamped()
            fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Unit?): Set<Commands>
        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
        object OracleType : ServiceType
        data class State : FixableDealState, SchedulableState
          Module Contents State(fixedLeg: FixedLeg, floatingLeg: FloatingLeg, calculation: Calculation, common: Common, linearId: UniqueIdentifier = UniqueIdentifier(common.tradeID))
          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
          val linearId: UniqueIdentifier
          fun nextFixingOf(): FixOf?
          fun nextScheduledActivity(thisStateRef: StateRef, protocolLogicRefFactory: ProtocolLogicRefFactory): ScheduledActivity?
          val oracleType: ServiceType
          val participants: List<PublicKey>
          val parties: List<Party>
          fun prettyPrint(): <ERROR CLASS>
          val ref: String
          fun withPublicKey(before: Party, after: PublicKey): DealState
        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>
        fun verify(tx: TransactionForContract): Unit
      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, Commands, State>
        Module Contents Cash()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Commands, Currency>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Commands, Issued<Currency>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, Issued<Currency>>>
          class Issue : AbstractIssue<State, Commands, Currency>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
        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, encumbrance: Int? = null)
          val amount: Amount<Issued<Currency>>
          val contract: Cash
          val deposit: PartyAndReference
          val encumbrance: Int?
          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 conserveClause: AbstractConserveAmount<State, Commands, Currency>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Currency>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): 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
        fun verify(tx: TransactionForContract): Unit
      class CommodityContract : OnLedgerAsset<Commodity, Commands, State>
        Module Contents CommodityContract()
        interface Clauses
          Module Contents class ConserveAmount : AbstractConserveAmount<State, Commands, Commodity>
            Module Contents ConserveAmount()
          class Group : GroupClauseVerifier<State, Commands, Issued<Commodity>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State, Issued<Commodity>>>
          class Issue : AbstractIssue<State, Commands, Commodity>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
        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 conserveClause: AbstractConserveAmount<State, Commands, Commodity>
        fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Commodity>>, owner: PublicKey): TransactionState<State>
        fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): 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
        fun verify(tx: TransactionForContract): Unit
      val DUMMY_CASH_ISSUER: <ERROR CLASS>
      val DUMMY_CASH_ISSUER_KEY: <ERROR CLASS>
      val DUMMY_OBLIGATION_ISSUER: <ERROR CLASS>
      val DUMMY_OBLIGATION_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> : Contract
        Module Contents Obligation()
        interface Clauses
          Module Contents class ConserveAmount<P> : AbstractConserveAmount<State<P>, Commands, Terms<P>>
            Module Contents ConserveAmount()
          class Group<P> : GroupClauseVerifier<State<P>, Commands, Issued<Terms<P>>>
            Module Contents Group()
            fun groupStates(tx: TransactionForContract): List<InOutGroup<State<P>, Issued<Terms<P>>>>
          class Issue<P> : AbstractIssue<State<P>, Commands, Terms<P>>
            Module Contents Issue()
            val requiredCommands: Set<Class<out CommandData>>
          class Net<C : CommandData, P> : NetClause<C, P>
            Module Contents Net()
            val lifecycleClause: VerifyLifecycle<ContractState, C, Unit, P>
            fun toString(): String
            fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
          class SetLifecycle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
            Module Contents SetLifecycle()
            val requiredCommands: Set<Class<out CommandData>>
            fun toString(): String
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms<P>>?): Set<Commands>
          class Settle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
            Module Contents Settle()
            val requiredCommands: Set<Class<out CommandData>>
            fun verify(tx: TransactionForContract, inputs: List<State<P>>, outputs: List<State<P>>, commands: List<AuthenticatedObject<Commands>>, groupingKey: Issued<Terms<P>>?): Set<Commands>
          class VerifyLifecycle<S : ContractState, C : CommandData, T : Any, P> : Clause<S, C, T>
            Module Contents VerifyLifecycle()
            fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: T?): Set<C>
        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 : NetCommand, 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
        fun generateCloseOutNetting(tx: TransactionBuilder, signer: PublicKey, vararg states: State<P>): Unit
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<Terms<P>>>, 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
        fun verify(tx: TransactionForContract): Unit
      abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : Contract
        Module Contents OnLedgerAsset()
        abstract val conserveClause: AbstractConserveAmount<S, C, T>
        abstract fun deriveState(txState: TransactionState<S>, amount: Amount<Issued<T>>, owner: PublicKey): TransactionState<S>
        abstract fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): Collection<AuthenticatedObject<C>>
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, 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 Vault.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>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
        Module Contents AbstractConserveAmount()
        fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, assetStates: List<StateAndRef<S>>, deriveState: (TransactionState<S>, Amount<Issued<T>>, PublicKey) -> TransactionState<S>, generateMoveCommand: () -> CommandData, 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 fun toString(): String
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
      abstract class AbstractIssue<in S : ContractState, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
        Module Contents AbstractIssue(sum: List<S>.() -> Amount<Issued<T>>, sumOrZero: List<S>.(Issued<T>) -> Amount<Issued<T>>)
        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: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
      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<C : CommandData, P> : Clause<ContractState, C, Unit>
        Module Contents NetClause()
        open val requiredCommands: Set<Class<out CommandData>>
        open fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
        fun verifyNetCommand(inputs: List<State<P>>, outputs: List<State<P>>, command: AuthenticatedObject<NetCommand>, netState: NetState<P>): Unit
      interface NetState<P>
        Module Contents abstract val template: Terms<P>
      open class NoZeroSizedOutputs<in S : FungibleAsset<T>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
        Module Contents NoZeroSizedOutputs()
        open fun toString(): String
        open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
    package com.r3corda.contracts.testing
      Module Contents class CommandDataGenerator
        Module Contents CommandDataGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): CommandData
      class CommandGenerator
        Module Contents CommandGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Command
      class ContractStateGenerator
        Module Contents ContractStateGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): ContractState
      class ExitGenerator
        Module Contents ExitGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Exit
      class IssueGenerator
        Module Contents IssueGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Issue
      class MoveGenerator
        Module Contents MoveGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Move
      class SignedTransactionGenerator
        Module Contents SignedTransactionGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): SignedTransaction
      class WiredTransactionGenerator
        Module Contents WiredTransactionGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): WireTransaction
      fun ServiceHub.fillWithSomeTestCash(howMuch: Amount<Currency>, outputNotary: Party = DUMMY_NOTARY, atLeastThisManyStates: Int = 3, atMostThisManyStates: Int = 10, rng: Random = Random(), ref: OpaqueBytes = OpaqueBytes(ByteArray(1, { 1 })), ownedBy: PublicKey? = null): Vault
    package com.r3corda.core
      Module Contents data class ErrorOr<out A>
        Module Contents ErrorOr(value: A)
        fun <B> bind(function: (A) -> ErrorOr<B>): ErrorOr<Nothing>
        inline fun <T> catch(body: () -> T): ErrorOr<T>
        fun <B, C> combine(other: ErrorOr<B>, function: (A, B) -> C): ErrorOr<C>
        val error: Throwable?
        fun getOrThrow(): A
        fun <B> map(function: (A) -> B): <ERROR CLASS>
        fun <T> match(onValue: (A) -> T, onError: (Throwable) -> T): T
        fun of(t: Throwable): ErrorOr<Nothing>
        val value: A?
      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
        fun checkNotLocked(): <ERROR CLASS>
        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 <T> <ERROR CLASS><T>.bufferUntilSubscribed(): <ERROR CLASS><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 operator fun Path.div(other: String): Path
        fun <R> Path.use(block: (InputStream) -> R): R
      java.time.temporal.Temporal
        Module Contents infix fun Temporal.until(endExclusive: Temporal): Duration
      java.util.concurrent.Future
        Module Contents infix fun <F, T> Future<F>.map(mapper: (F) -> T): Future<T>
      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.Throwable
        Module Contents val Throwable.rootCause: Throwable
      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
      sealed class ClientToServiceCommand
        Module Contents class ExitCash : ClientToServiceCommand
          Module Contents ExitCash(amount: Amount<Currency>, issueRef: OpaqueBytes, id: UUID = UUID.randomUUID())
          val amount: Amount<Currency>
          val issueRef: OpaqueBytes
        class IssueCash : ClientToServiceCommand
          Module Contents IssueCash(amount: Amount<Currency>, issueRef: OpaqueBytes, recipient: Party, notary: Party, id: UUID = UUID.randomUUID())
          val amount: Amount<Currency>
          val issueRef: OpaqueBytes
          val notary: Party
          val recipient: Party
        class PayCash : ClientToServiceCommand
          Module Contents PayCash(amount: Amount<Issued<Currency>>, recipient: Party, id: UUID = UUID.randomUUID())
          val amount: Amount<Issued<Currency>>
          val recipient: Party
        val id: UUID
      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(commodityCode: String, displayName: String, defaultFractionDigits: Int = 0)
        val commodityCode: String
        val defaultFractionDigits: Int
        val displayName: String
        fun getInstance(commodityCode: String): Commodity?
      interface Contract
        Module Contents abstract val legalContractReference: SecureHash
        abstract fun verify(tx: TransactionForContract): Unit
      interface ContractState
        Module Contents abstract val contract: Contract
        open val encumbrance: Int?
        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: List<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 move(prior: StateAndRef<SingleOwnerState>, newOwner: PublicKey): <ERROR CLASS>
        fun move(priors: List<StateAndRef<SingleOwnerState>>, newOwner: PublicKey): TransactionBuilder
        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?
        abstract val oracleType: ServiceType
      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
      interface LinearState : ContractState
        Module Contents class ClauseVerifier<S : LinearState> : Clause<ContractState, CommandData, Unit>
          Module Contents ClauseVerifier(stateClass: Class<S>)
          val stateClass: Class<S>
          fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<CommandData>>, groupingKey: Unit?): Set<CommandData>
        abstract fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        abstract val linearId: UniqueIdentifier
      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
      interface NetCommand : CommandData
        Module Contents abstract val type: NetType
      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 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 Timestamp
        Module Contents Timestamp(time: Instant, tolerance: Duration)
        Timestamp(after: Instant?, before: Instant?)
        val after: Instant?
        val before: Instant?
        val midpoint: Instant
      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, timestamp: Timestamp? = 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 <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: Timestamp?
      class TransactionGraphSearch : Callable<List<WireTransaction>>
        Module Contents TransactionGraphSearch(transactions: ReadOnlyTransactionStorage, startPoints: List<WireTransaction>)
        class Query
          Module Contents Query(withCommandOfType: Class<out CommandData>? = null, followInputsOfType: Class<out ContractState>? = null)
          val followInputsOfType: Class<out ContractState>?
          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?)
          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)
            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
        enum class Direction
          Module Contents INPUT
          OUTPUT
        class InvalidNotaryChange : TransactionVerificationException
          Module Contents InvalidNotaryChange(tx: LedgerTransaction)
        class MoreThanOneNotary : TransactionVerificationException
          Module Contents MoreThanOneNotary(tx: LedgerTransaction)
        class NotaryChangeInWrongTransactionType : TransactionVerificationException
          Module Contents NotaryChangeInWrongTransactionType(tx: LedgerTransaction, outputNotary: Party)
          val outputNotary: Party
          fun toString(): String
        class SignersMissing : TransactionVerificationException
          Module Contents SignersMissing(tx: LedgerTransaction, missing: List<PublicKey>)
          val missing: List<PublicKey>
          fun toString(): String
        class TransactionMissingEncumbranceException : TransactionVerificationException
          Module Contents TransactionMissingEncumbranceException(tx: LedgerTransaction, missing: Int, inOut: Direction)
          val inOut: Direction
          val message: String?
          val missing: Int
        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 UniqueIdentifier
        Module Contents UniqueIdentifier(externalId: String? = null, id: UUID = UUID.randomUUID())
        val externalId: String?
        val id: UUID
        fun toString(): String
      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 inline fun <reified T : ContractState> Iterable<StateAndRef<ContractState>>.filterStatesOfType(): List<StateAndRef<T>>
        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>
      inline fun <R> requireThat(body: Requirements.() -> R): R
      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 class AllComposition<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
        Module Contents AllComposition(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
        val clauses: ArrayList<Clause<S, C, K>>
        fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
        fun toString(): String
        fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      class AnyComposition<in S : ContractState, C : CommandData, in K : Any> : CompositeClause<S, C, K>
        Module Contents AnyComposition(vararg rawClauses: Clause<S, C, K>)
        val clauses: List<Clause<S, C, K>>
        fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
        fun toString(): String
        fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      abstract class Clause<in S : ContractState, C : CommandData, in K : Any>
        Module Contents Clause()
        open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
        val log: <ERROR CLASS>
        open val requiredCommands: Set<Class<out CommandData>>
        abstract fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      abstract class CompositeClause<in S : ContractState, C : CommandData, in K : Any> : Clause<S, C, K>
        Module Contents CompositeClause()
        abstract val clauses: List<Clause<S, C, K>>
        open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
        abstract fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
      class FirstComposition<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
        Module Contents FirstComposition(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
        val clauses: ArrayList<Clause<S, C, K>>
        val firstClause: Clause<S, C, K>
        val logger: <ERROR CLASS>
        fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
        fun toString(): String
        fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
      abstract class GroupClauseVerifier<S : ContractState, C : CommandData, K : Any> : Clause<ContractState, C, Unit>
        Module Contents GroupClauseVerifier(clause: Clause<S, C, K>)
        val clause: Clause<S, C, K>
        open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
        abstract fun groupStates(tx: TransactionForContract): List<InOutGroup<S, K>>
        open fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
      fun <C : CommandData> Clause<*, C, *>.matches(commands: List<AuthenticatedObject<C>>): Boolean
      fun <C : CommandData> verifyClause(tx: TransactionForContract, clause: Clause<ContractState, C, Unit>, commands: List<AuthenticatedObject<C>>): 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)
          val signer: Party
        open class WithKey : DigitalSignature
          Module Contents WithKey(by: PublicKey, bits: ByteArray)
          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)
        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
        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 CORDA_CLIENT_CA: String
        val CORDA_CLIENT_CA_PRIVATE_KEY: String
        val CORDA_INTERMEDIATE_CA: String
        val CORDA_INTERMEDIATE_CA_PRIVATE_KEY: String
        val CORDA_ROOT_CA: String
        val CORDA_ROOT_CA_PRIVATE_KEY: String
        val ECDSA_CURVE: String
        val KEYSTORE_TYPE: String
        val KEY_GENERATION_ALGORITHM: String
        val SIGNATURE_ALGORITHM: String
        fun KeyStore.addOrReplaceCertificate(alias: String, cert: Certificate): Unit
        fun KeyStore.addOrReplaceKey(alias: String, key: Key, password: CharArray, chain: Array<Certificate>): Unit
        fun createCAKeyStoreAndTrustStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, trustStoreFilePath: Path, trustStorePassword: String): KeyStore
        fun createCertificateSigningRequest(myLegalName: String, nearestCity: String, email: String, keyPair: KeyPair): <ERROR CLASS>
        fun createIntermediateCert(domain: String, certificateAuthority: CACertAndKey): CACertAndKey
        fun createKeystoreForSSL(keyStoreFilePath: Path, storePassword: String, keyPassword: String, caKeyStore: KeyStore, caKeyPassword: String): KeyStore
        fun createSelfSignedCACert(myLegalName: 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 getX509Name(myLegalName: String, nearestCity: String, email: 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 loadOrCreateKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String, keyGenerator: () -> CACertAndKey): KeyPair
        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 vaultService: VaultService
      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, prevNodeInfo: NodeInfo?, type: MapChangeType)
          val node: NodeInfo
          val prevNodeInfo: NodeInfo?
          val type: MapChangeType
        enum class MapChangeType
          Module Contents Added
          Modified
          Removed
        abstract fun addMapService(net: MessagingService, networkMapAddress: SingleMessageRecipient, 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 mapServiceRegistered: <ERROR CLASS><Unit>
        abstract val networkMapNodes: List<NodeInfo>
        abstract val notaryNodes: List<NodeInfo>
        abstract val partyNodes: List<NodeInfo>
        abstract val regulators: List<NodeInfo>
        abstract fun removeNode(node: NodeInfo): Unit
        abstract fun runWithoutMapService(): Unit
      interface ReadOnlyTransactionStorage
        Module Contents abstract fun getTransaction(id: SecureHash): SignedTransaction?
        abstract val updates: <ERROR CLASS><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: Timestamp): 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 Vault
        Module Contents Vault(states: Iterable<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>>
          fun toString(): String
        val states: Iterable<StateAndRef<ContractState>>
        inline fun <reified T : ContractState> statesOfType(): List<StateAndRef<T>>
      interface VaultService
        Module Contents abstract val currentVault: Vault
        abstract val linearHeads: Map<UniqueIdentifier, StateAndRef<LinearState>>
        open fun <T : LinearState> linearHeadsOfType_(stateType: Class<T>): Map<UniqueIdentifier, StateAndRef<T>>
        open fun notify(tx: WireTransaction): Vault
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Vault
        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> VaultService.linearHeadsOfType(): <ERROR CLASS>
    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(otherParty: Party): UntrustworthyData<T>
        fun <T : Any> receive(otherParty: Party, receiveType: Class<T>): UntrustworthyData<T>
        fun registerSession(receivedHandshake: HandshakeMessage): Unit
        fun send(otherParty: Party, payload: Any): Unit
        inline fun <reified T : Any> sendAndReceive(otherParty: Party, payload: Any): UntrustworthyData<T>
        fun <T : Any> sendAndReceive(otherParty: Party, payload: Any, receiveType: Class<T>): UntrustworthyData<T>
        val serviceHub: ServiceHub
        fun <R> subProtocol(subLogic: ProtocolLogic<R>, inheritParentSessions: Boolean = false): 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 val machineId: Long
        abstract fun <T : Any> receive(topic: String, sessionIDForReceive: Long, receiveType: Class<T>): UntrustworthyData<T>
        abstract val resultFuture: <ERROR CLASS><R>
        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, receiveType: 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
        fun open(): ByteArrayInputStream
        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 class AmountGenerator<T>
        Module Contents AmountGenerator(tokenGenerator: <ERROR CLASS><T>)
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Amount<T>
        val tokenGenerator: <ERROR CLASS><T>
      class CurrencyGenerator
        Module Contents CurrencyGenerator()
        val currencies: <ERROR CLASS>
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Currency
      class DurationGenerator
        Module Contents DurationGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Duration
      open class InMemoryVaultService : SingletonSerializeAsToken, VaultService
        Module Contents InMemoryVaultService(services: ServiceHub)
        protected class InnerState
          Module Contents InnerState()
          var vault: Vault
        open val currentVault: Vault
        open val linearHeads: Map<UniqueIdentifier, StateAndRef<LinearState>>
        protected open val log: <ERROR CLASS>
        protected val mutex: ThreadBox<InnerState>
        open fun notifyAll(txns: Iterable<WireTransaction>): Vault
        protected val services: ServiceHub
        open val updates: <ERROR CLASS><Update>
      class InstantGenerator
        Module Contents InstantGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Instant
      class IssuedGenerator<T>
        Module Contents IssuedGenerator(productGenerator: <ERROR CLASS><T>)
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Issued<T>
        val productGenerator: <ERROR CLASS><T>
      class PartyAndReferenceGenerator
        Module Contents PartyAndReferenceGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): PartyAndReference
      class PartyGenerator
        Module Contents PartyGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Party
      class PrivateKeyGenerator
        Module Contents PrivateKeyGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): PrivateKey
      class PublicKeyGenerator
        Module Contents PublicKeyGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): PublicKey
      class SecureHashGenerator
        Module Contents SecureHashGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): SecureHash
      class StateRefGenerator
        Module Contents StateRefGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): StateRef
      class TimestampGenerator
        Module Contents TimestampGenerator()
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): Timestamp
      class TransactionStateGenerator<T : ContractState>
        Module Contents TransactionStateGenerator(stateGenerator: <ERROR CLASS><T>)
        fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>): TransactionState<T>
        val stateGenerator: <ERROR CLASS><T>
      fun <A> <ERROR CLASS><A>.generateList(random: <ERROR CLASS>, status: <ERROR CLASS>): List<A>
    package com.r3corda.core.transactions
      Module Contents abstract class BaseTransaction : NamedByHash
        Module Contents BaseTransaction(inputs: List<*>, outputs: List<TransactionState<ContractState>>, notary: Party?, mustSign: List<PublicKey>, type: TransactionType, timestamp: Timestamp?)
        protected fun checkInvariants(): Unit
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        open val inputs: List<*>
        val mustSign: List<PublicKey>
        val notary: Party?
        val outputs: List<TransactionState<ContractState>>
        val timestamp: Timestamp?
        val type: TransactionType
      class LedgerTransaction : BaseTransaction
        Module Contents LedgerTransaction(inputs: List<StateAndRef<*>>, outputs: List<TransactionState<ContractState>>, commands: List<AuthenticatedObject<CommandData>>, attachments: List<Attachment>, id: SecureHash, notary: Party?, signers: List<PublicKey>, timestamp: Timestamp?, type: TransactionType)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        val id: SecureHash
        val inputs: List<StateAndRef<*>>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun toTransactionForContract(): TransactionForContract
        fun verify(): Unit
      data class SignedTransaction : NamedByHash
        Module Contents SignedTransaction(txBits: SerializedBytes<WireTransaction>, sigs: List<WithKey>)
        class SignaturesMissingException : NamedByHash, SignatureException
          Module Contents SignaturesMissingException(missing: Set<PublicKey>, descriptions: List<String>, id: SecureHash)
          val descriptions: List<String>
          val id: SecureHash
          val missing: Set<PublicKey>
          fun toString(): String
        fun checkSignaturesAreValid(): Unit
        val id: SecureHash
        operator fun plus(sig: WithKey): SignedTransaction
        operator fun plus(sigList: Collection<WithKey>): SignedTransaction
        val sigs: List<WithKey>
        fun toLedgerTransaction(services: ServiceHub): LedgerTransaction
        val tx: WireTransaction
        val txBits: SerializedBytes<WireTransaction>
        fun verifySignatures(vararg allowedToBeMissing: PublicKey): WireTransaction
        fun withAdditionalSignature(sig: WithKey): SignedTransaction
        fun withAdditionalSignatures(sigList: Iterable<WithKey>): SignedTransaction
      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(), timestamp: Timestamp? = null)
        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 addOutputState(state: TransactionState<*>): Int
        fun addOutputState(state: ContractState, notary: Party): Int
        fun addOutputState(state: ContractState): Int
        fun addSignatureUnchecked(sig: WithKey): TransactionBuilder
        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>
        var notary: Party?
        fun outputStates(): List<TransactionState<*>>
        protected val outputs: MutableList<TransactionState<ContractState>>
        fun setTime(time: Instant, timeTolerance: Duration): Unit
        fun setTime(newTimestamp: Timestamp): Unit
        fun signWith(key: KeyPair): TransactionBuilder
        protected val signers: MutableSet<PublicKey>
        val time: Timestamp?
        protected var timestamp: Timestamp?
        fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction
        fun toWireTransaction(): WireTransaction
        protected val type: TransactionType
        fun withItems(vararg items: Any): TransactionBuilder
      class WireTransaction : BaseTransaction
        Module Contents WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<TransactionState<ContractState>>, commands: List<Command>, notary: Party?, signers: List<PublicKey>, type: TransactionType, timestamp: Timestamp?)
        val attachments: List<SecureHash>
        val commands: List<Command>
        fun deserialize(bits: SerializedBytes<WireTransaction>, kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
        fun equals(other: Any?): Boolean
        fun hashCode(): Int
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun <T : ContractState> outRef(state: ContractState): StateAndRef<T>
        val serialized: SerializedBytes<WireTransaction>
        fun toLedgerTransaction(services: ServiceHub): LedgerTransaction
        fun toString(): String
    package com.r3corda.core.utilities
      Module Contents 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
      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
      object LogHelper
        Module Contents fun reset(vararg names: String): Unit
        fun reset(vararg classes: KClass<*>): <ERROR CLASS>
        fun setLevel(vararg loggerNames: String): Unit
        fun setLevel(vararg classes: KClass<*>): <ERROR CLASS>
      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
      val TEST_TX_TIME: Instant
      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> unwrap(validator: (T) -> R): R
        inline fun <R> validate(validator: (T) -> R): R
      inline fun <ERROR CLASS>.debug(msg: () -> String): Unit
      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, tradeWithIdentities: List<Path>, uploadRates: Boolean, defaultLegalName: String, autoSetup: Boolean)
          val apiAddress: <ERROR CLASS>
          val autoSetup: Boolean
          val defaultLegalName: String
          val dir: 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
        class UploadRates : CliParams
          Module Contents UploadRates(apiAddress: <ERROR CLASS>)
          val apiAddress: <ERROR CLASS>
        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 networkMapNetAddr: <ERROR CLASS>
        val nonOptions: <ERROR CLASS>
        val parser: <ERROR CLASS>
        val roleArg: <ERROR CLASS>
      val DEFAULT_BASE_DIRECTORY: 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
        Rates
        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 runUploadRates(cliParams: UploadRates): <ERROR CLASS>
    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>
      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.demos.protocols
      Module Contents object AutoOfferProtocol
        Module Contents data class AutoOfferMessage : HandshakeMessage
          Module Contents AutoOfferMessage(notary: Party, dealBeingOffered: DealState, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val dealBeingOffered: DealState
          val notary: Party
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
        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 : AbstractNodeService
          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
          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 : HandshakeMessage
          Module Contents ExitMessage(exitCode: Int, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val exitCode: Int
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
        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 : HandshakeMessage
          Module Contents UpdateBusinessDayMessage(date: LocalDate, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val date: LocalDate
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
    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>
      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.driver
      Module Contents class DriverDSL : DriverDSLInternalInterface
        Module Contents DriverDSL(portAllocation: PortAllocation, debugPortAllocation: PortAllocation, baseDirectory: String, isDebug: Boolean)
        class State
          Module Contents State()
          val clients: LinkedList<NodeMessagingClient>
          var localServer: ArtemisMessagingServer?
          val registeredProcesses: LinkedList<Process>
        val baseDirectory: String
        val debugPortAllocation: PortAllocation
        val isDebug: Boolean
        val name: Array<String>
        val networkMapCache: InMemoryNetworkMapCache
        fun <A> pickA(array: Array<A>): A
        val portAllocation: PortAllocation
        fun registerProcess(process: Process): Unit
        fun shutdown(): Unit
        fun start(): Unit
        fun startClient(providedName: String, serverAddress: <ERROR CLASS>): Future<NodeMessagingClient>
        fun startLocalServer(): Future<ArtemisMessagingServer>
        fun startNode(providedName: String?, advertisedServices: Set<ServiceType>): Future<NodeInfo>
        fun waitForAllNodesToFinish(): Unit
      interface DriverDSLExposedInterface
        Module Contents abstract val networkMapCache: NetworkMapCache
        abstract fun startClient(providedName: String, serverAddress: <ERROR CLASS>): Future<NodeMessagingClient>
        abstract fun startLocalServer(): Future<ArtemisMessagingServer>
        abstract fun startNode(providedName: String? = null, advertisedServices: Set<ServiceType> = setOf()): Future<NodeInfo>
        abstract fun waitForAllNodesToFinish(): Unit
      interface DriverDSLInternalInterface : DriverDSLExposedInterface
        Module Contents abstract fun shutdown(): Unit
        abstract fun start(): Unit
      sealed class PortAllocation
        Module Contents class Incremental : PortAllocation
          Module Contents Incremental(portCounter: Int)
          fun nextPort(): Int
        class RandomFree : PortAllocation
          Module Contents RandomFree()
          fun nextPort(): Int
        fun nextHostAndPort(): <ERROR CLASS>
        abstract fun nextPort(): Int
      fun addressMustBeBound(hostAndPort: <ERROR CLASS>): Unit
      fun addressMustNotBeBound(hostAndPort: <ERROR CLASS>): Unit
      fun <A> driver(baseDirectory: String = "build/${getTimestampAsDirectoryName()}", portAllocation: PortAllocation = PortAllocation.Incremental(10000), debugPortAllocation: PortAllocation = PortAllocation.Incremental(5005), isDebug: Boolean = false, dsl: DriverDSLExposedInterface.() -> A): A
      fun <DI : DriverDSLExposedInterface, D : DriverDSLInternalInterface, A> genericDriver(driverDsl: D, coerce: (D) -> DI, dsl: DI.() -> A): A
      fun <A> poll(pollName: String, pollIntervalMs: Long = 500, warnCount: Int = 120, f: () -> A?): A
      fun DriverDSLExposedInterface.startClient(localServer: ArtemisMessagingServer): Future<NodeMessagingClient>
      fun DriverDSLExposedInterface.startClient(remoteNodeInfo: NodeInfo, providedName: String? = null): Future<NodeMessagingClient>
      fun writeConfig(path: Path, filename: String, config: <ERROR CLASS>): Unit
    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(configuration: NodeConfiguration, networkMapService: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, platformClock: Clock)
        class DatabaseConfigurationException : Exception
          Module Contents DatabaseConfigurationException(msg: String)
        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>
        open fun findMyLocation(): PhysicalLocation?
        inline fun <reified T : Any> findService(): <ERROR CLASS>
        protected open fun generateKeyPair(): KeyPair
        lateinit var identity: IdentityService
        var inNodeMonitorService: NodeMonitorService?
        var inNodeNetworkMapService: NetworkMapService?
        var inNodeNotaryService: NotaryService?
        val info: NodeInfo
        protected open fun initialiseDatabasePersistence(insideTransaction: () -> Unit): Unit
        protected open fun initialiseStorageService(dir: Path): <ERROR CLASS><TxWritableStorageService, CheckpointStorage>
        var isPreviousCheckpointsPresent: Boolean
        lateinit var keyManagement: KeyManagementService
        protected abstract val log: <ERROR CLASS>
        protected fun makeAttachmentStorage(dir: Path): NodeAttachmentService
        protected open fun makeIdentityService(): IdentityService
        protected open fun makeKeyManagementService(): KeyManagementService
        protected abstract fun makeMessagingService(): MessagingServiceInternal
        protected open fun makeMonitorService(): NodeMonitorService
        protected open fun makeNetworkMapService(): Unit
        protected open fun makeNotaryService(type: ServiceType): NotaryService
        protected abstract fun makeUniquenessProvider(): UniquenessProvider
        protected open fun makeVaultService(): VaultService
        lateinit var net: MessagingServiceInternal
        lateinit var netMapCache: NetworkMapCache
        val networkMapRegistrationFuture: <ERROR CLASS><Unit>
        var networkMapSeq: Long
        val networkMapService: SingleMessageRecipient?
        protected open fun noNetworkMapConfigured(): <ERROR CLASS><Unit>
        val platformClock: Clock
        protected val pluginRegistries: List<CordaPluginRegistry>
        lateinit var protocolLogicFactory: ProtocolLogicRefFactory
        protected val runOnStop: ArrayList<Runnable>
        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
        var uniquenessProvider: UniquenessProvider?
        lateinit var vault: VaultService
      class ConfigurationException : Exception
        Module Contents ConfigurationException(message: String)
      class Node : AbstractNode
        Module Contents Node(p2pAddr: <ERROR CLASS>, webServerAddr: <ERROR CLASS>, configuration: NodeConfiguration, networkMapAddress: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, clock: Clock = NodeClock(), messagingServerAddr: <ERROR CLASS>? = null)
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingServiceInternal
        protected fun makeUniquenessProvider(): PersistentUniquenessProvider
        var messageBroker: ArtemisMessagingServer?
        val messagingServerAddr: <ERROR CLASS>?
        val p2pAddr: <ERROR CLASS>
        fun run(): Unit
        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 ServerRPCOps : CordaRPCOps
        Module Contents ServerRPCOps(services: ServiceHubInternal)
        val protocolVersion: Int
    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)
    package com.r3corda.node.services.api
      Module Contents abstract class AbstractNodeService : SingletonSerializeAsToken
        Module Contents AbstractNodeService(services: ServiceHubInternal)
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R, crossinline exceptionConsumer: (Message, Exception) -> Unit): MessageHandlerRegistration
        protected inline fun <reified Q : ServiceRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R): MessageHandlerRegistration
        protected inline fun <reified H : HandshakeMessage, R : Any> addProtocolHandler(topic: String, loggerName: String, crossinline protocolFactory: (H) -> ProtocolLogic<R>, crossinline onResultFuture: (<ERROR CLASS><R>, H) -> Unit): Unit
        protected inline fun <reified H : HandshakeMessage, R : Any> addProtocolHandler(topic: String, loggerName: String, crossinline protocolFactory: (H) -> ProtocolLogic<R>): Unit
        val logger: <ERROR CLASS>
        val net: MessagingServiceInternal
        val services: ServiceHubInternal
      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: ProtocolIORequest?, receivedPayload: Any?)
        var fiberCreated: Boolean
        val receivedPayload: Any?
        val request: ProtocolIORequest?
        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 : AbstractNodeService
          Module Contents Service(services: ServiceHubInternal)
    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 certificateSigningService: <ERROR CLASS>
        val clock: Clock
        fun createNode(): Node
        val dataSourceProperties: Properties
        val devMode: Boolean
        val emailAddress: String
        val exportJMXto: String
        val extraAdvertisedServiceIds: String
        val hostNotaryServiceLocally: Boolean
        val keyStorePassword: String
        val messagingServerAddress: <ERROR CLASS>?
        val myLegalName: String
        val nearestCity: String
        val networkMapAddress: <ERROR CLASS>?
        val trustStorePassword: String
        val useHTTPS: Boolean
        val webAddress: <ERROR CLASS>
      interface NodeConfiguration : NodeSSLConfiguration
        Module Contents abstract val basedir: Path
        abstract val certificateSigningService: <ERROR CLASS>
        open val certificatesPath: Path
        open val dataSourceProperties: Properties
        abstract val devMode: Boolean
        abstract val emailAddress: String
        abstract val exportJMXto: String
        fun loadConfig(baseDirectoryPath: Path, configFileOverride: Path? = null, allowMissingConfig: Boolean = false, configOverrides: Map<String, Any?> = emptyMap()): <ERROR CLASS>
        val log: <ERROR CLASS>
        abstract val myLegalName: String
        abstract val nearestCity: String
      class NodeConfigurationFromConfig : NodeConfiguration
        Module Contents NodeConfigurationFromConfig(config: <ERROR CLASS> = ConfigFactory.load())
        val basedir: Path
        val certificateSigningService: <ERROR CLASS>
        val config: <ERROR CLASS>
        val dataSourceProperties: Properties
        val devMode: Boolean
        val emailAddress: String
        val exportJMXto: String
        val keyStorePassword: String
        val myLegalName: String
        val nearestCity: String
        val trustStorePassword: String
      interface NodeSSLConfiguration
        Module Contents abstract val certificatesPath: Path
        abstract val keyStorePassword: String
        open val keyStorePath: Path
        abstract val trustStorePassword: String
        open val trustStorePath: Path
      class OptionalConfig<out T>
        Module Contents OptionalConfig(conf: <ERROR CLASS>, lambda: () -> T)
        val conf: <ERROR CLASS>
        operator fun getValue(receiver: Any, metadata: KProperty<*>): T
        val lambda: () -> T
      fun <T> <ERROR CLASS>.getOrElse(lambda: () -> T): OptionalConfig<T>
      fun <ERROR CLASS>.getProperties(path: String): Properties
      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>
      class PersistentKeyManagementService : SingletonSerializeAsToken, KeyManagementService
        Module Contents PersistentKeyManagementService(initialKeys: Set<KeyPair>)
        fun freshKey(): KeyPair
        val keys: Map<PublicKey, PrivateKey>
    package com.r3corda.node.services.messaging
      Module Contents abstract class ArtemisMessagingComponent : SingletonSerializeAsToken
        Module Contents ArtemisMessagingComponent(config: NodeSSLConfiguration)
        protected interface ArtemisAddress
          Module Contents abstract val hostAndPort: <ERROR CLASS>
          abstract val queueName: <ERROR CLASS>
        const val CLIENTS_PREFIX: String
        protected enum class ConnectionDirection
          Module Contents INBOUND
          OUTBOUND
        protected val NETWORK_MAP_ADDRESS: <ERROR CLASS>
        protected data class NetworkMapAddress : SingleMessageRecipient, ArtemisAddress
          Module Contents NetworkMapAddress(hostAndPort: <ERROR CLASS>)
          val hostAndPort: <ERROR CLASS>
          val queueName: <ERROR CLASS>
        data class NodeAddress : SingleMessageRecipient, ArtemisAddress
          Module Contents NodeAddress(identity: PublicKey, hostAndPort: <ERROR CLASS>)
          val hostAndPort: <ERROR CLASS>
          val identity: PublicKey
          val queueName: <ERROR CLASS>
          fun toString(): String
        const val PEERS_PREFIX: String
        const val RPC_REQUESTS_QUEUE: String
        fun checkStorePasswords(): Unit
        val config: NodeSSLConfiguration
        fun configureWithDevSSLCertificate(): Unit
        protected fun parseKeyFromQueueName(name: String): PublicKey
        protected fun tcpTransport(direction: ConnectionDirection, host: String, port: Int): <ERROR CLASS>
        fun toHostAndPort(target: MessageRecipients): <ERROR CLASS>
        protected fun toQueueName(target: MessageRecipients): <ERROR CLASS>
      class ArtemisMessagingServer : ArtemisMessagingComponent
        Module Contents ArtemisMessagingServer(config: NodeConfiguration, myHostPort: <ERROR CLASS>, networkMapCache: NetworkMapCache)
        fun bridgeToNetworkMapService(networkMapService: SingleMessageRecipient?): Unit
        val log: <ERROR CLASS>
        val myHostPort: <ERROR CLASS>
        val networkMapCache: NetworkMapCache
        fun start(): Unit
        fun stop(): Unit
      data class ClientRPCRequestMessage
        Module Contents ClientRPCRequestMessage(args: SerializedBytes<Array<Any>>, replyToAddress: String, observationsToAddress: String?, methodName: String)
        const val METHOD_NAME: String
        const val OBSERVATIONS_TO: String
        const val REPLY_TO: String
        val args: SerializedBytes<Array<Any>>
        val methodName: String
        val observationsToAddress: String?
        val replyToAddress: String
      interface CordaRPCOps : RPCOps
      data class MarshalledObservation
        Module Contents MarshalledObservation(forHandle: Int, what: <ERROR CLASS><out <ERROR CLASS>>)
        val forHandle: Int
        val what: <ERROR CLASS><out <ERROR CLASS>>
      class NodeMessagingClient : ArtemisMessagingComponent, MessagingServiceInternal
        Module Contents NodeMessagingClient(config: NodeConfiguration, serverHostPort: <ERROR CLASS>, myIdentity: PublicKey?, executor: AffinityExecutor, persistentInbox: Boolean = true, rpcOps: CordaRPCOps? = null)
        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 executor: AffinityExecutor
        val log: <ERROR CLASS>
        fun makeNetworkMapAddress(hostAndPort: <ERROR CLASS>): SingleMessageRecipient
        val myAddress: SingleMessageRecipient
        val myIdentity: PublicKey?
        val persistentInbox: Boolean
        fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        fun run(): Unit
        fun send(message: Message, target: MessageRecipients): Unit
        val serverHostPort: <ERROR CLASS>
        fun start(): Unit
        fun stop(): Unit
      abstract class RPCDispatcher
        Module Contents RPCDispatcher(target: Any)
        fun dispatch(msg: ClientRPCRequestMessage): Unit
        abstract fun send(bits: SerializedBytes<*>, toAddress: String): Unit
        fun start(rpcConsumer: <ERROR CLASS>, rpcNotificationConsumer: <ERROR CLASS>?, onExecutor: AffinityExecutor): Unit
        val target: Any
      open class RPCException : RuntimeException
        Module Contents RPCException(msg: String)
        RPCException(msg: String, cause: Throwable?)
        class DeadlineExceeded : RPCException
          Module Contents DeadlineExceeded(rpcName: String)
      interface RPCOps
        Module Contents abstract val protocolVersion: Int
      @Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables
        Module Contents RPCReturnsObservables()
      @Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion
        Module Contents RPCSinceVersion(version: Int)
        val version: Int
      fun createRPCKryo(observableSerializer: <ERROR CLASS><<ERROR CLASS><Any>>? = null): <ERROR CLASS>
      val rpcLog: <ERROR CLASS>
      fun <ERROR CLASS>.toRPCRequestMessage(): ClientRPCRequestMessage
    package com.r3corda.node.services.monitor
      Module Contents data class ClientToServiceCommandMessage : DirectRequestMessage
        Module Contents ClientToServiceCommandMessage(sessionID: Long, replyToRecipient: SingleMessageRecipient, command: ClientToServiceCommand)
        val command: ClientToServiceCommand
        val replyToRecipient: SingleMessageRecipient
        val sessionID: Long
      data class DeregisterRequest : DirectRequestMessage
        Module Contents DeregisterRequest(replyToRecipient: SingleMessageRecipient, sessionID: Long)
        val replyToRecipient: SingleMessageRecipient
        val sessionID: Long
      data class DeregisterResponse
        Module Contents DeregisterResponse(success: Boolean)
        val success: Boolean
      class NodeMonitorService : AbstractNodeService
        Module Contents NodeMonitorService(services: ServiceHubInternal, smm: StateMachineManager)
        val DEREGISTER_TOPIC: String
        val IN_EVENT_TOPIC: String
        class InputStateRefResolveFailed : Exception
          Module Contents InputStateRefResolveFailed(stateRefs: List<StateRef>)
        val OUT_EVENT_TOPIC: String
        val REGISTER_TOPIC: String
        data class RegisteredListener
          Module Contents RegisteredListener(recipients: MessageRecipients, sessionID: Long)
          val recipients: MessageRecipients
          val sessionID: Long
        val STATE_TOPIC: String
        val listeners: MutableSet<RegisteredListener>
        val logger: <ERROR CLASS>
        fun processDeregisterRequest(req: DeregisterRequest): Unit
        fun processRegisterRequest(req: RegisterRequest): Unit
        val smm: StateMachineManager
      data class RegisterRequest : DirectRequestMessage
        Module Contents RegisterRequest(replyToRecipient: SingleMessageRecipient, sessionID: Long)
        val replyToRecipient: SingleMessageRecipient
        val sessionID: Long
      data class RegisterResponse
        Module Contents RegisterResponse(success: Boolean)
        val success: Boolean
      sealed class ServiceToClientEvent
        Module Contents class OutputState : ServiceToClientEvent
          Module Contents OutputState(time: Instant, consumed: Set<StateRef>, produced: Set<StateAndRef<ContractState>>)
          val consumed: Set<StateRef>
          val produced: Set<StateAndRef<ContractState>>
          fun toString(): String
        class Progress : ServiceToClientEvent
          Module Contents Progress(time: Instant, fiberId: Long, message: String)
          val fiberId: Long
          val message: String
          fun toString(): String
        class StateMachine : ServiceToClientEvent
          Module Contents StateMachine(time: Instant, fiberId: Long, label: String, addOrRemove: AddOrRemove)
          val addOrRemove: AddOrRemove
          val fiberId: Long
          val label: String
          fun toString(): String
        class Transaction : ServiceToClientEvent
          Module Contents Transaction(time: Instant, transaction: LedgerTransaction)
          fun toString(): String
          val transaction: LedgerTransaction
        class TransactionBuild : ServiceToClientEvent
          Module Contents TransactionBuild(time: Instant, id: UUID, state: TransactionBuildResult)
          val id: UUID
          val state: TransactionBuildResult
          fun toString(): String
        val time: Instant
      data class StateSnapshotMessage
        Module Contents StateSnapshotMessage(contractStates: Collection<StateAndRef<ContractState>>, protocolStates: Collection<String>)
        val contractStates: Collection<StateAndRef<ContractState>>
        val protocolStates: Collection<String>
      sealed class TransactionBuildResult
        Module Contents class Failed : TransactionBuildResult
          Module Contents Failed(message: String?)
          val message: String?
          fun toString(): String
        class ProtocolStarted : TransactionBuildResult
          Module Contents ProtocolStarted(fiberId: Long, transaction: LedgerTransaction?, message: String?)
          val fiberId: Long
          val message: String?
          fun toString(): String
          val transaction: LedgerTransaction?
    package com.r3corda.node.services.network
      Module Contents abstract class AbstractNetworkMapService : NetworkMapService, AbstractNodeService
        Module Contents AbstractNetworkMapService(services: ServiceHubInternal)
        protected val _mapVersion: AtomicInteger
        fun getUnacknowledgedCount(subscriber: SingleMessageRecipient, mapVersion: Int): Int?
        val mapVersion: Int
        val maxSizeRegistrationRequestBytes: Int
        val maxUnacknowledgedUpdates: Int
        open val nodes: List<NodeInfo>
        fun notifySubscribers(wireReg: WireNodeRegistration, mapVersion: Int): 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
        protected abstract val registeredNodes: MutableMap<Party, NodeRegistrationInfo>
        protected fun setup(): Unit
        protected abstract val subscribers: ThreadBox<MutableMap<SingleMessageRecipient, LastAcknowledgeInfo>>
        fun unregisterNetworkHandlers(): Unit
      open class InMemoryNetworkMapCache : SingletonSerializeAsToken, NetworkMapCache
        Module Contents InMemoryNetworkMapCache()
        open fun addMapService(net: MessagingService, networkMapAddress: SingleMessageRecipient, 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 mapServiceRegistered: <ERROR CLASS><Unit>
        open val networkMapNodes: List<NodeInfo>
        open val notaryNodes: List<NodeInfo>
        open val partyNodes: List<NodeInfo>
        fun processUpdatePush(req: Update): Unit
        protected var registeredNodes: MutableMap<Party, NodeInfo>
        open val regulators: List<NodeInfo>
        open fun removeNode(node: NodeInfo): Unit
        open fun runWithoutMapService(): Unit
      class InMemoryNetworkMapService : AbstractNetworkMapService
        Module Contents InMemoryNetworkMapService(services: ServiceHubInternal)
        protected val registeredNodes: MutableMap<Party, NodeRegistrationInfo>
        protected val subscribers: <ERROR CLASS>
      data class LastAcknowledgeInfo
        Module Contents LastAcknowledgeInfo(mapVersion: Int)
        val mapVersion: Int
      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, mapVersion: Int, replyTo: MessageRecipients)
          val mapVersion: Int
          val replyTo: MessageRecipients
          val wireReg: WireNodeRegistration
        data class UpdateAcknowledge
          Module Contents UpdateAcknowledge(mapVersion: Int, replyTo: MessageRecipients)
          val mapVersion: Int
          val replyTo: MessageRecipients
        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
      data class NodeRegistrationInfo
        Module Contents NodeRegistrationInfo(reg: NodeRegistration, mapVersion: Int)
        val mapVersion: Int
        val reg: NodeRegistration
      class PersistentNetworkMapService : AbstractNetworkMapService
        Module Contents PersistentNetworkMapService(services: ServiceHubInternal)
        protected val registeredNodes: MutableMap<Party, NodeRegistrationInfo>
        protected val subscribers: ThreadBox<JDBCHashMap<SingleMessageRecipient, LastAcknowledgeInfo>>
      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)
          class TransactionRejectedError : Exception
            Module Contents TransactionRejectedError(msg: String)
          val logger: <ERROR CLASS>
          fun notify(net: MessagingService, myIdentity: Party, recipient: NodeInfo, transaction: SignedTransaction): Unit
          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>
        val updates: <ERROR CLASS><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 interface ProtocolIORequest
        Module Contents abstract val stackTraceInCaseOfProblems: StackSnapshot
        abstract 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>
        val machineId: Long
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, receiveType: 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, receiveType: Class<T>): UntrustworthyData<T>
        lateinit var serviceHub: ServiceHubInternal
      data class ReceiveOnly<T> : ReceiveRequest<T>
        Module Contents ReceiveOnly(topic: String, receiveType: Class<T>, receiveSessionID: Long)
        val receiveSessionID: Long
        val receiveType: Class<T>
        val stackTraceInCaseOfProblems: StackSnapshot
        val topic: String
      interface ReceiveRequest<T> : ProtocolIORequest
        Module Contents abstract val receiveSessionID: Long
        open val receiveTopicSession: TopicSession
        abstract val receiveType: Class<T>
      data class SendAndReceive<T> : SendRequest, ReceiveRequest<T>
        Module Contents SendAndReceive(topic: String, destination: Party, payload: Any, sendSessionID: Long, receiveType: Class<T>, receiveSessionID: Long)
        val destination: Party
        val payload: Any
        val receiveSessionID: Long
        val receiveType: Class<T>
        val sendSessionID: Long
        val stackTraceInCaseOfProblems: StackSnapshot
        val topic: String
      data class SendOnly : SendRequest
        Module Contents SendOnly(destination: Party, topic: String, payload: Any, sendSessionID: Long)
        val destination: Party
        val payload: Any
        val sendSessionID: Long
        val stackTraceInCaseOfProblems: StackSnapshot
        val topic: String
      interface SendRequest : ProtocolIORequest
        Module Contents abstract val destination: Party
        abstract val payload: Any
        abstract val sendSessionID: Long
      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>): ProtocolStateMachine<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(services: ServiceHubInternal, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        object Type : ServiceType
        abstract val logger: <ERROR CLASS>
        abstract val protocolFactory: Factory
        val timestampChecker: TimestampChecker
        val uniquenessProvider: UniquenessProvider
      class PersistentUniquenessProvider : UniquenessProvider, SingletonSerializeAsToken
        Module Contents PersistentUniquenessProvider()
        fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party): Unit
        val committedStates: <ERROR CLASS>
      class SimpleNotaryService : NotaryService
        Module Contents SimpleNotaryService(services: ServiceHubInternal, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: DefaultFactory
      class ValidatingNotaryService : NotaryService
        Module Contents ValidatingNotaryService(services: ServiceHubInternal, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        object Type : ServiceType
        val logger: <ERROR CLASS>
        val protocolFactory: Factory
    package com.r3corda.node.services.vault
      Module Contents class CashBalanceAsMetricsObserver
        Module Contents CashBalanceAsMetricsObserver(serviceHubInternal: ServiceHubInternal)
        val serviceHubInternal: ServiceHubInternal
      class NodeVaultService : SingletonSerializeAsToken, VaultService
        Module Contents NodeVaultService(services: ServiceHub)
        val currentVault: Vault
        val linearHeads: Map<UniqueIdentifier, StateAndRef<LinearState>>
        val log: <ERROR CLASS>
        protected val mutex: ReentrantLock
        fun notifyAll(txns: Iterable<WireTransaction>): Vault
        val updates: <ERROR CLASS><Update>
    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?
      abstract class AbstractJDBCHashMap<K : Any, V : Any, T : JDBCHashedTable> : MutableMap<K, V>, AbstractMap<K, V>
        Module Contents AbstractJDBCHashMap(table: T, loadOnInit: Boolean = false)
        protected abstract fun addKeyToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        protected abstract fun addValueToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        open fun clear(): Unit
        open fun containsKey(key: K): Boolean
        open fun containsValue(value: V): Boolean
        open val entries: MutableSet<MutableEntry<K, V>>
        open fun get(key: K): V?
        open fun isEmpty(): Boolean
        protected abstract fun keyFromRow(it: <ERROR CLASS>): K
        open val keys: MutableSet<K>
        val loadOnInit: Boolean
        protected val log: <ERROR CLASS>
        open fun put(key: K, value: V): V?
        open fun remove(key: K): V?
        open val size: Int
        val table: T
        protected abstract fun valueFromRow(it: <ERROR CLASS>): V
        open val values: MutableCollection<V>
      abstract class AbstractJDBCHashSet<K : Any, T : JDBCHashedTable> : MutableSet<K>, AbstractSet<K>
        Module Contents AbstractJDBCHashSet(table: T, loadOnInit: Boolean = false)
        open fun add(element: K): Boolean
        protected abstract fun addElementToInsert(it: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit
        open fun clear(): Unit
        open fun contains(element: K): Boolean
        protected abstract fun elementFromRow(it: <ERROR CLASS>): K
        protected val innerMap: AbstractJDBCHashMap<K, Unit, T>
        open fun isEmpty(): Boolean
        open fun iterator(): MutableIterator<K>
        open fun remove(element: K): Boolean
        open val size: Int
        protected val table: T
      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
      class JDBCHashMap<K : Any, V : Any> : AbstractJDBCHashMap<K, V, BlobMapTable>
        Module Contents JDBCHashMap(tableName: String, loadOnInit: Boolean = false)
        class BlobMapTable : JDBCHashedTable
          Module Contents BlobMapTable(tableName: String)
          val key: <ERROR CLASS>
          val value: <ERROR CLASS>
        protected fun addKeyToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        protected fun addValueToInsert(it: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
        protected fun keyFromRow(it: <ERROR CLASS>): K
        protected fun valueFromRow(it: <ERROR CLASS>): V
      class JDBCHashSet<K : Any> : AbstractJDBCHashSet<K, BlobSetTable>
        Module Contents JDBCHashSet(tableName: String, loadOnInit: Boolean = false)
        class BlobSetTable : JDBCHashedTable
          Module Contents BlobSetTable(tableName: String)
          val key: <ERROR CLASS>
        protected fun addElementToInsert(it: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit
        protected fun elementFromRow(it: <ERROR CLASS>): K
      open class JDBCHashedTable
        Module Contents JDBCHashedTable(tableName: String)
        val keyHash: <ERROR CLASS>
        val seqNo: <ERROR CLASS>
      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
      fun configureDatabase(props: Properties): <ERROR CLASS><Closeable, <ERROR CLASS>>
      fun <T> databaseTransaction(statement: <ERROR CLASS>.() -> T): T
      fun <T : Any> deserializeFromBlob(blob: Blob): T
      java.time.Clock
        Module Contents fun Clock.awaitWithDeadline(deadline: Instant, future: Future<*> = GuavaSettableFuture.create<Any>()): Boolean
      fun <T : Any> serializeToBlob(value: T, finalizables: MutableList<() -> Unit>): Blob
    package com.r3corda.node.utilities.certsigning
      Module Contents class CertificateSigner
        Module Contents CertificateSigner(config: NodeConfiguration, certService: CertificateSigningService)
        fun buildKeyStore(): Unit
        val certService: CertificateSigningService
        val config: NodeConfiguration
        val log: <ERROR CLASS>
        val pollInterval: Duration
      interface CertificateSigningService
        Module Contents abstract fun retrieveCertificates(requestId: String): Array<Certificate>?
        abstract fun submitRequest(request: <ERROR CLASS>): String
      class HTTPCertificateSigningService : CertificateSigningService
        Module Contents HTTPCertificateSigningService(server: <ERROR CLASS>)
        val clientVersion: String
        fun retrieveCertificates(requestId: String): Array<Certificate>?
        val server: <ERROR CLASS>
        fun submitRequest(request: <ERROR CLASS>): String
      object ParamsSpec
        Module Contents val baseDirectoryArg: <ERROR CLASS>
        val configFileArg: <ERROR CLASS>
        val parser: <ERROR CLASS>
      fun main(args: Array<String>): Unit
    package com.r3corda.protocols
      Module Contents abstract class AbstractStateReplacementProtocol<T>
        Module Contents AbstractStateReplacementProtocol()
        abstract class Acceptor<T> : ProtocolLogic<Unit>
          Module Contents Acceptor(otherSide: Party, progressTracker: ProgressTracker = tracker())
          object APPROVING : Step
          object REJECTING : Step
          object VERIFYING : Step
          open fun call(): Unit
          val otherSide: Party
          open val progressTracker: ProgressTracker
          fun tracker(): ProgressTracker
          abstract fun verifyProposal(maybeProposal: UntrustworthyData<Proposal<T>>): Proposal<T>
        data class Handshake : HandshakeMessage
          Module Contents Handshake(replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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
      class BroadcastTransactionProtocol : ProtocolLogic<Unit>
        Module Contents BroadcastTransactionProtocol(notarisedTransaction: SignedTransaction, events: Set<ClientToServiceCommand>, participants: Set<Party>)
        data class NotifyTxRequestMessage : HandshakeMessage
          Module Contents NotifyTxRequestMessage(tx: SignedTransaction, events: Set<ClientToServiceCommand>, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val events: Set<ClientToServiceCommand>
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
          val tx: SignedTransaction
        val TOPIC: String
        fun call(): Unit
        val events: Set<ClientToServiceCommand>
        val notarisedTransaction: SignedTransaction
        val participants: Set<Party>
        protected val topic: String
      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 : HandshakeMessage
          Module Contents Request(hashes: List<SecureHash>, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val hashes: List<SecureHash>
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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 FinalityProtocol : ProtocolLogic<Unit>
        Module Contents FinalityProtocol(transaction: SignedTransaction, events: Set<ClientToServiceCommand>, participants: Set<Party>, progressTracker: ProgressTracker = tracker())
        object BROADCASTING : Step
        object NOTARISING : Step
        fun call(): Unit
        val events: Set<ClientToServiceCommand>
        val participants: Set<Party>
        val progressTracker: ProgressTracker
        protected val topic: String
        fun tracker(): ProgressTracker
        val transaction: SignedTransaction
      interface HandshakeMessage : PartyRequestMessage
        Module Contents abstract val receiveSessionID: Long
        abstract val sendSessionID: Long
        open val sessionID: Long
      object NotaryChangeProtocol : AbstractStateReplacementProtocol<Party>
        Module Contents class Acceptor : Acceptor<Party>
          Module Contents Acceptor(otherSide: Party, progressTracker: ProgressTracker = tracker())
          val progressTracker: ProgressTracker
          protected val topic: String
          fun verifyProposal(maybeProposal: UntrustworthyData<Proposal<Party>>): Proposal<Party>
        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 SignaturesMissing : NotaryError
          Module Contents SignaturesMissing(missingSigners: Set<PublicKey>)
          val missingSigners: Set<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, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        interface Factory
          Module Contents abstract fun create(otherSide: Party, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider): Service
        data class Handshake : HandshakeMessage
          Module Contents Handshake(replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
          open fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit
          open fun call(): Unit
          val otherSide: Party
          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, 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 : HandshakeMessage
          Module Contents QueryRequest(queries: List<FixOf>, deadline: Instant, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val deadline: Instant
          val queries: List<FixOf>
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
        object SIGNING : Step
        data class SignRequest : HandshakeMessage
          Module Contents SignRequest(tx: WireTransaction, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: 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
        var transactionCountLimit: Int
      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(otherParty: Party, notary: Party, dealToBuy: T, progressTracker: ProgressTracker = Secondary.tracker())
          protected open fun assembleSharedTX(handshake: Handshake<T>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val dealToBuy: T
          val notary: Party
          open val otherParty: Party
          open val progressTracker: ProgressTracker
          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(otherParty: Party, oracleType: ServiceType, progressTracker: ProgressTracker = Secondary.tracker())
          protected fun assembleSharedTX(handshake: Handshake<StateRef>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val oracleType: ServiceType
          val otherParty: Party
          val progressTracker: ProgressTracker
          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 : HandshakeMessage
          Module Contents FixingSessionInitiation(timeout: Duration, oracleType: ServiceType, replyToParty: Party, sendSessionID: Long = random63BitValue(), receiveSessionID: Long = random63BitValue())
          val oracleType: ServiceType
          val receiveSessionID: Long
          val replyToParty: Party
          val sendSessionID: Long
          val timeout: Duration
        class Floater : Primary<StateRef>
          Module Contents Floater(otherParty: Party, payload: StateRef, progressTracker: ProgressTracker = Primary.tracker())
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherParty: Party
          val payload: StateRef
          val progressTracker: ProgressTracker
        data class Handshake<out T>
          Module Contents Handshake(payload: T, publicKey: PublicKey)
          val payload: T
          val publicKey: PublicKey
        class Instigator<out T : DealState> : Primary<T>
          Module Contents Instigator(otherParty: Party, notary: Party, payload: T, myKeyPair: KeyPair, progressTracker: ProgressTracker = Primary.tracker())
          open val myKeyPair: KeyPair
          val notary: Party
          open val notaryNode: NodeInfo
          open val otherParty: 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 otherParty: 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 otherParty: Party
          open val progressTracker: ProgressTracker
          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(otherParty: Party, notary: Party, acceptablePrice: Amount<Currency>, typeToBuy: Class<out OwnableState>)
          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 otherParty: Party
          open val progressTracker: ProgressTracker
          protected open val topic: String
          val typeToBuy: Class<out OwnableState>
        class Seller : ProtocolLogic<SignedTransaction>
          Module Contents Seller(otherParty: Party, notaryNode: NodeInfo, assetToSell: StateAndRef<OwnableState>, price: Amount<Currency>, myKeyPair: KeyPair, 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>
          open fun call(): SignedTransaction
          val myKeyPair: KeyPair
          val notaryNode: NodeInfo
          val otherParty: 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)
          val assetForSale: StateAndRef<OwnableState>
          val price: Amount<Currency>
          val sellerOwnerKey: PublicKey
        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, timestampChecker: TimestampChecker, uniquenessProvider: UniquenessProvider)
        fun beforeCommit(stx: SignedTransaction, reqIdentity: Party): Unit
    package com.r3corda.simulation
      Module Contents class IRSSimulation : Simulation
        Module Contents IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)
        fun iterate(): <ERROR CLASS>?
        val om: <ERROR CLASS>
        protected fun startMainSimulation(): <ERROR CLASS><Unit>
      abstract class Simulation
        Module Contents Simulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)
        inner class BankFactory
          Module Contents BankFactory()
          var counter: Int
          fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
          fun createAll(): List<SimulatedNode>
        object NetworkMapNodeFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        object NotaryNodeFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        object RatesOracleFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        object RegulatorFactory
          Module Contents fun create(config: NodeConfiguration, network: <ERROR CLASS>, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set<ServiceType>, id: Int, keyPair: KeyPair?): <ERROR CLASS>
        open class SimulatedNode
          Module Contents SimulatedNode(config: NodeConfiguration, mockNet: <ERROR CLASS>, networkMapAddress: SingleMessageRecipient?, 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(): <ERROR CLASS>?
        val network: <ERROR CLASS>
        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 TradeSimulation : Simulation
        Module Contents TradeSimulation(runAsync: Boolean, latencyInjector: <ERROR CLASS>?)
        protected fun startMainSimulation(): <ERROR CLASS><Unit>