Module Contents alltypes
      Module Contents 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, 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
      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, 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
      abstract class AbstractNode
        Module Contents AbstractNode(dir: Path, configuration: NodeConfiguration, initialNetworkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, platformClock: Clock)
        val PRIVATE_KEY_FILE_NAME: String
        val PUBLIC_IDENTITY_FILE_NAME: String
        protected val _servicesThatAcceptUploads: ArrayList<AcceptsFileUpload>
        val advertisedServices: Set<ServiceType>
        lateinit var api: APIServer
        val configuration: NodeConfiguration
        protected open fun constructStorageService(attachments: NodeAttachmentService, keypair: KeyPair, identity: Party): StorageServiceImpl
        val dir: Path
        protected open fun findMyLocation(): PhysicalLocation?
        lateinit var identity: IdentityService
        var inNodeNetworkMapService: NetworkMapService?
        var inNodeTimestampingService: NodeTimestamperService?
        val info: NodeInfo
        val initialNetworkMapAddress: NodeInfo?
        protected open fun initialiseStorageService(dir: Path): StorageService
        lateinit var interestRatesService: Service
        lateinit var keyManagement: E2ETestKeyManagementService
        protected abstract val log: <ERROR CLASS>
        protected open fun makeIdentityService(): IdentityService
        protected open fun makeInterestRatesOracleService(): Unit
        protected abstract fun makeMessagingService(): MessagingService
        protected open fun makeNetworkMapService(): Unit
        protected open fun makeTimestampingService(): Unit
        lateinit var net: MessagingService
        var networkMapSeq: Long
        val networkMapServiceCallTimeout: Duration
        val platformClock: Clock
        protected abstract val serverThread: AffinityExecutor
        val services: ServiceHub
        val servicesThatAcceptUploads: List<AcceptsFileUpload>
        lateinit var smm: StateMachineManager
        open fun start(): AbstractNode
        protected abstract fun startMessagingService(): Unit
        open fun stop(): Unit
        lateinit var storage: StorageService
        lateinit var wallet: WalletService
      abstract class AbstractNodeService
        Module Contents AbstractNodeService(net: MessagingService)
        protected inline fun <reified Q : AbstractRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R, crossinline exceptionConsumer: (Message, Exception) -> Unit): Unit
        protected inline fun <reified Q : AbstractRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R): Unit
        val net: MessagingService
      abstract class AbstractRequestMessage
        Module Contents AbstractRequestMessage(replyTo: MessageRecipients, sessionID: Long?)
        val replyTo: MessageRecipients
        val sessionID: Long?
      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
      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>
          protected val threads: MutableSet<Thread>
        open fun checkOnThread(): Unit
        open fun executeASAP(runnable: () -> Unit): Unit
        open fun <T> fetchFrom(fetcher: () -> T): T
        open fun flush(): Unit
        abstract val isOnThread: Boolean
      interface AllPossibleRecipients : MessageRecipients
      data class Amount : Comparable<Amount>
        Module Contents Amount(amount: BigDecimal, currency: Currency)
        Amount(pennies: Long, currency: Currency)
        fun compareTo(other: Amount): Int
        val currency: Currency
        operator fun div(other: Long): Amount
        operator fun div(other: Int): Amount
        operator fun minus(other: Amount): Amount
        val pennies: Long
        operator fun plus(other: Amount): Amount
        operator fun times(other: Long): Amount
        operator fun times(other: Int): Amount
        fun toString(): String
      class ArtemisMessagingService : MessagingService
        Module Contents ArtemisMessagingService(directory: Path, myHostPort: <ERROR CLASS>, defaultExecutor: Executor = RunOnCallerThread)
        inner class Handler : MessageHandlerRegistration
          Module Contents Handler(executor: Executor?, topic: String, callback: (Message, MessageHandlerRegistration) -> Unit)
          val callback: (Message, MessageHandlerRegistration) -> Unit
          val executor: Executor?
          val topic: String
        val TOPIC_PROPERTY: String
        fun addMessageHandler(topic: String, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        fun createMessage(topic: String, data: ByteArray): Message
        val defaultExecutor: Executor
        val directory: Path
        val log: <ERROR CLASS>
        fun makeRecipient(hostAndPort: <ERROR CLASS>): SingleMessageRecipient
        fun makeRecipient(hostname: String): <ERROR CLASS>
        val myAddress: SingleMessageRecipient
        val myHostPort: <ERROR CLASS>
        fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        fun send(message: Message, target: MessageRecipients): Unit
        fun start(): Unit
        fun stop(): Unit
        fun toHostAndPort(hostname: String): <ERROR CLASS>
      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
          Module Contents AutoOfferMessage(otherSide: SingleMessageRecipient, otherSessionID: Long, dealBeingOffered: DealState)
          val dealBeingOffered: DealState
          val otherSessionID: Long
          val otherSide: SingleMessageRecipient
        object Handler
          Module Contents 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
          object RECEIVED : Step
          fun register(node: Node): Unit
          fun tracker(): <ERROR CLASS>
        class Requester<T> : ProtocolLogic<SignedTransaction>
          Module Contents Requester(dealToBeOffered: DealState)
          object ANNOUNCING : Step
          object DEALING : Step
          object RECEIVED : Step
          fun call(): SignedTransaction
          val dealToBeOffered: DealState
          fun notUs(vararg parties: Party): List<Party>
          val progressTracker: <ERROR CLASS>
          fun tracker(): <ERROR CLASS>
        val TOPIC: String
      class BriefLogFormatter : Formatter
        Module Contents BriefLogFormatter()
        fun format(logRecord: LogRecord): String
        fun init(): Unit
        fun initVerbose(vararg loggerNames: String): Unit
        fun loggingOff(vararg names: String): Unit
        fun loggingOff(vararg classes: KClass<*>): Unit
        fun loggingOn(vararg names: String): Unit
        fun loggingOn(vararg classes: KClass<*>): Unit
      open class BusinessCalendar
        Module Contents val TEST_CALENDAR_DATA: <ERROR CLASS>
        class UnknownCalendar : Exception
          Module Contents UnknownCalendar(name: String)
        open fun applyRollConvention(testDate: LocalDate, dateRollConvention: DateRollConvention): LocalDate
        val calendars: Array<out String>
        val calendars: <ERROR CLASS>
        fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = 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
        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 : Contract
        Module Contents Cash()
        interface Commands : CommandData
          Module Contents data class Exit : Commands
            Module Contents Exit(amount: Amount)
            val amount: Amount
          data class Issue : Commands
            Module Contents Issue(nonce: Long = SecureRandom.getInstanceStrong().nextLong())
            val nonce: Long
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
        data class State : OwnableState
          Module Contents State(deposit: PartyReference, amount: Amount, owner: PublicKey)
          val amount: Amount
          val contract: Cash
          val deposit: PartyReference
          val owner: PublicKey
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        fun generateIssue(tx: TransactionBuilder, amount: Amount, at: PartyReference, owner: PublicKey): Unit
        fun generateSpend(tx: TransactionBuilder, amount: Amount, to: PublicKey, cashStates: List<StateAndRef<State>>, onlyFromParties: Set<Party>? = null): List<PublicKey>
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      object CityDatabase
        Module Contents operator fun get(name: String): PhysicalLocation?
      data class Command
        Module Contents Command(data: CommandData, key: PublicKey)
        Command(value: CommandData, signers: List<PublicKey>)
        val signers: List<PublicKey>
        fun toString(): String
        val value: CommandData
      interface CommandData
      class CommercialPaper : Contract
        Module Contents CommercialPaper()
        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: PartyReference, owner: PublicKey, faceValue: Amount, maturityDate: Instant)
          val contract: CommercialPaper
          val faceValue: Amount
          val issuance: PartyReference
          val maturityDate: Instant
          val owner: PublicKey
          fun toString(): String
          fun withFaceValue(newFaceValue: Amount): <ERROR CLASS>
          fun withIssuance(newIssuance: PartyReference): <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: PartyReference, faceValue: Amount, maturityDate: Instant): TransactionBuilder
        fun generateMove(tx: TransactionBuilder, paper: StateAndRef<State>, newOwner: PublicKey): Unit
        fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<State>, wallet: List<StateAndRef<State>>): Unit
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      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: TransactionForVerification): 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
      class CrowdFund : Contract
        Module Contents CrowdFund()
        data class Campaign
          Module Contents Campaign(owner: PublicKey, name: String, target: Amount, closingTime: Instant)
          val closingTime: Instant
          val name: String
          val owner: PublicKey
          val target: Amount
          fun toString(): String
        interface Commands : CommandData
          Module Contents class Close : TypeOnlyCommandData, Commands
            Module Contents Close()
          class Pledge : TypeOnlyCommandData, Commands
            Module Contents Pledge()
          class Register : TypeOnlyCommandData, Commands
            Module Contents Register()
        data class Pledge
          Module Contents Pledge(owner: PublicKey, amount: Amount)
          val amount: Amount
          val owner: PublicKey
        data class State : ContractState
          Module Contents State(campaign: Campaign, closed: Boolean = false, pledges: List<Pledge> = ArrayList())
          val campaign: Campaign
          val closed: Boolean
          val contract: CrowdFund
          val pledgedAmount: Amount
          val pledges: List<Pledge>
        fun generateClose(tx: TransactionBuilder, campaign: StateAndRef<State>, wallet: List<StateAndRef<State>>): Unit
        fun generatePledge(tx: TransactionBuilder, campaign: StateAndRef<State>, subscriber: PublicKey): Unit
        fun generateRegister(owner: PartyReference, fundingTarget: Amount, fundingName: String, closingTime: Instant): TransactionBuilder
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      class CubicSplineInterpolator : Interpolator
        Module Contents CubicSplineInterpolator(xs: DoubleArray, ys: DoubleArray)
        fun create(xs: DoubleArray, ys: DoubleArray): CubicSplineInterpolator
        fun interpolate(x: Double): Double
      class DataUploadServlet
        Module Contents DataUploadServlet()
        fun doPost(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
      class DataVendingService : AbstractNodeService
        Module Contents DataVendingService(net: MessagingService, storage: StorageService)
        class Request : AbstractRequestMessage
          Module Contents Request(hashes: List<SecureHash>, replyTo: SingleMessageRecipient, sessionID: Long)
          val hashes: List<SecureHash>
        val logger: <ERROR CLASS>
      enum class DateOffset
        Module Contents TWODAYS
        ZERO
      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(): TransactionBuilder
        abstract val parties: Array<Party>
        abstract val ref: String
        abstract fun withPublicKey(before: Party, after: PublicKey): DealState
      class DemoClock : Clock
        Module Contents DemoClock(delegateClock: Clock = Clock.systemUTC())
        fun getZone(): ZoneId
        fun instant(): Instant
        fun updateDate(date: LocalDate): Boolean
        fun withZone(zone: ZoneId): Clock
      open class DigitalSignature : OpaqueBytes
        Module Contents DigitalSignature(bits: ByteArray, covering: Int = 0)
        class LegallyIdentifiable : WithKey
          Module Contents LegallyIdentifiable(signer: Party, bits: ByteArray, covering: Int)
          val signer: Party
        open class WithKey : DigitalSignature
          Module Contents WithKey(by: PublicKey, bits: ByteArray, covering: Int = 0)
          val by: PublicKey
          fun verifyWithECDSA(content: ByteArray): Unit
          fun verifyWithECDSA(content: OpaqueBytes): Unit
        val covering: Int
      class DummyContract : Contract
        Module Contents DummyContract()
        interface Commands : CommandData
          Module Contents class Create : TypeOnlyCommandData, Commands
            Module Contents Create()
        class State : ContractState
          Module Contents State(magicNumber: Int = 0)
          val contract: DummyContract
          val magicNumber: Int
        fun generateInitial(owner: PartyReference, magicNumber: Int): TransactionBuilder
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): 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 DummyTimestampingAuthority
        Module Contents val identity: Party
        val key: KeyPair
      class E2ETestKeyManagementService : KeyManagementService
        Module Contents E2ETestKeyManagementService()
        fun freshKey(): KeyPair
        val keys: Map<PublicKey, PrivateKey>
      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
      open class Event
        Module Contents Event(date: LocalDate)
        val date: LocalDate
      object ExitServerProtocol
        Module Contents class Broadcast : ProtocolLogic<Boolean>
          Module Contents Broadcast(exitCode: Integer)
          fun call(): Boolean
          val exitCode: Integer
        data class ExitMessage
          Module Contents ExitMessage(exitCode: Int)
          val exitCode: Int
        object Handler
          Module Contents fun register(node: Node): Unit
        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: SingleMessageRecipient)
        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 queryTopic: String
      abstract class FetchDataProtocol<T : NamedByHash, W : Any> : ProtocolLogic<Result<T>>
        Module Contents FetchDataProtocol(requests: Set<SecureHash>, otherSide: SingleMessageRecipient)
        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 Result<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: SingleMessageRecipient
        protected abstract val queryTopic: String
        protected val requests: Set<SecureHash>
      class FetchTransactionsProtocol : FetchDataProtocol<SignedTransaction, SignedTransaction>
        Module Contents FetchTransactionsProtocol(requests: Set<SecureHash>, otherSide: SingleMessageRecipient)
        const val TOPIC: String
        protected fun load(txid: SecureHash): SignedTransaction?
        protected val queryTopic: String
      data class Fix : CommandData
        Module Contents Fix(of: FixOf, value: BigDecimal)
        val of: FixOf
        val value: BigDecimal
      data class FixOf
        Module Contents FixOf(name: String, forDay: LocalDate, ofTenor: Tenor)
        val forDay: LocalDate
        val name: String
        val ofTenor: Tenor
      interface FixableDealState : DealState
        Module Contents abstract fun generateFix(ptx: TransactionBuilder, oldStateRef: StateRef, fix: Fix): Unit
        abstract fun nextFixingOf(): FixOf?
      class FixedRate : Rate
        Module Contents FixedRate(ratioUnit: RatioUnit)
        fun toString(): String
      class FixedRatePaymentEvent : RatePaymentEvent
        Module Contents FixedRatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount, rate: Rate)
        val CSVHeader: String
        val flow: Amount
        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, rate: Rate)
        val CSVHeader: String
        fun asCSV(): String
        val fixingDate: LocalDate
        val flow: Amount
        fun toString(): String
        fun withNewRate(newRate: Rate): FloatingRatePaymentEvent
      enum class Frequency
        Module Contents Annual
          Module Contents fun offset(d: LocalDate): LocalDate
        BiWeekly
          Module Contents fun offset(d: LocalDate): LocalDate
        Monthly
          Module Contents fun offset(d: LocalDate): LocalDate
        Quarterly
          Module Contents fun offset(d: LocalDate): LocalDate
        SemiAnnual
          Module Contents fun offset(d: LocalDate): LocalDate
        Weekly
          Module Contents fun offset(d: LocalDate): LocalDate
        val annualCompoundCount: Int
        abstract fun offset(d: LocalDate): LocalDate
      class IRSSimulation : Simulation
        Module Contents IRSSimulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        fun iterate(): Unit
        val om: <ERROR CLASS>
        fun start(): Unit
      interface IdentityService
        Module Contents abstract fun partyFromKey(key: PublicKey): Party?
        abstract fun partyFromName(name: String): Party?
        abstract fun registerIdentity(party: Party): 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
      class InMemoryIdentityService : IdentityService
        Module Contents InMemoryIdentityService()
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
      class InMemoryMessagingNetwork
        Module Contents InMemoryMessagingNetwork()
        inner class Builder : MessagingServiceBuilder<InMemoryMessaging>
          Module Contents Builder(manuallyPumped: Boolean, id: Handle)
          val id: Handle
          val manuallyPumped: Boolean
          fun start(): <ERROR CLASS><InMemoryMessaging>
        class Handle : SingleMessageRecipient
          Module Contents Handle(id: Int)
          fun equals(other: Any?): Boolean
          fun hashCode(): Int
          val id: Int
          fun toString(): String
        inner class InMemoryMessaging : MessagingService
          Module Contents InMemoryMessaging(manuallyPumped: Boolean, handle: Handle)
          inner class Handler : MessageHandlerRegistration
            Module Contents Handler(executor: Executor?, topic: String, callback: (Message, MessageHandlerRegistration) -> Unit)
            val callback: (Message, MessageHandlerRegistration) -> Unit
            val executor: Executor?
            val topic: String
          protected inner class InnerState
            Module Contents InnerState()
            val handlers: MutableList<Handler>
            val pendingRedelivery: LinkedList<Message>
          fun addMessageHandler(topic: String, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
          protected val backgroundThread: Nothing?
          fun createMessage(topic: String, data: ByteArray): Message
          val myAddress: SingleMessageRecipient
          fun pump(block: Boolean): Boolean
          fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
          protected var running: Boolean
          fun send(message: Message, target: MessageRecipients): Unit
          protected val state: ThreadBox<InnerState>
          fun stop(): Unit
        interface LatencyCalculator
          Module Contents abstract fun between(sender: SingleMessageRecipient, receiver: SingleMessageRecipient): Duration
        val allMessages: <ERROR CLASS><<ERROR CLASS><SingleMessageRecipient, Message, MessageRecipients>>
        fun createNode(manuallyPumped: Boolean): <ERROR CLASS><Handle, MessagingServiceBuilder<InMemoryMessaging>>
        fun createNodeWithID(manuallyPumped: Boolean, id: Int): MessagingServiceBuilder<InMemoryMessaging>
        val endpoints: List<InMemoryMessaging>
        val everyoneOnline: AllPossibleRecipients
        var latencyCalculator: LatencyCalculator?
        fun setupTimestampingNode(manuallyPumped: Boolean): <ERROR CLASS><NodeInfo, InMemoryMessaging>
        fun stop(): Unit
      open class InMemoryNetworkMapCache : NetworkMapCache
        Module Contents InMemoryNetworkMapCache()
        open fun addMapService(smm: StateMachineManager, net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int?): <ERROR CLASS><Unit>
        open fun addNode(node: NodeInfo): Unit
        open fun deregisterForUpdates(smm: StateMachineManager, net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        open fun get(): <ERROR CLASS>
        open fun get(serviceType: ServiceType): <ERROR CLASS>
        open fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        open val networkMapNodes: List<NodeInfo>
        open val partyNodes: List<NodeInfo>
        fun processUpdatePush(req: Update): Unit
        open val ratesOracleNodes: List<NodeInfo>
        protected var registeredNodes: MutableMap<Party, NodeInfo>
        open val regulators: List<NodeInfo>
        open fun removeNode(node: NodeInfo): Unit
        open val timestampingNodes: List<NodeInfo>
      class InMemoryNetworkMapService : NetworkMapService, AbstractNodeService
        Module Contents InMemoryNetworkMapService(net: MessagingService, home: NodeRegistration, cache: NetworkMapCache)
        val cache: NetworkMapCache
        fun getUnacknowledgedCount(subscriber: SingleMessageRecipient): Int?
        val maxSizeRegistrationRequestBytes: Int
        val maxUnacknowledgedUpdates: Int
        val nodes: List<NodeInfo>
        fun notifySubscribers(wireReg: WireNodeRegistration): Unit
        fun processAcknowledge(req: UpdateAcknowledge): Unit
        fun processFetchAllRequest(req: FetchMapRequest): FetchMapResponse
        fun processQueryRequest(req: QueryIdentityRequest): QueryIdentityResponse
        fun processRegistrationChangeRequest(req: RegistrationRequest): RegistrationResponse
        fun processSubscriptionRequest(req: SubscribeRequest): SubscribeResponse
      class InsufficientBalanceException : Exception
        Module Contents InsufficientBalanceException(amountMissing: Amount)
        val amountMissing: Amount
      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: Rate): Calculation
          fun exportSchedule(): Unit
          val expression: Expression
          val fixedLegPaymentSchedule: Map<LocalDate, FixedRatePaymentEvent>
          val floatingLegPaymentSchedule: Map<LocalDate, FloatingRatePaymentEvent>
          fun getFixing(date: LocalDate): FloatingRatePaymentEvent
          fun nextFixingDate(): LocalDate?
        interface Commands : CommandData
          Module Contents class Agree : TypeOnlyCommandData, Commands
            Module Contents Agree()
          class Fix : TypeOnlyCommandData, Commands
            Module Contents Fix()
          class Mature : TypeOnlyCommandData, Commands
            Module Contents Mature()
          class Pay : TypeOnlyCommandData, Commands
            Module Contents Pay()
        data class Common
          Module Contents Common(baseCurrency: Currency, eligibleCurrency: Currency, eligibleCreditSupport: String, independentAmounts: Amount, threshold: Amount, minimumTransferAmount: Amount, rounding: Amount, 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
          val interestRate: ReferenceRate
          val localBusinessDay: BusinessCalendar
          val minimumTransferAmount: Amount
          val notificationTime: String
          val resolutionTime: String
          val rounding: Amount
          val threshold: Amount
          val tradeID: String
          val valuationDate: String
        abstract class CommonLeg
          Module Contents CommonLeg(notional: Amount, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment)
          var dayCountBasisDay: DayCountBasisDay
          var dayCountBasisYear: DayCountBasisYear
          var dayInMonth: Int
          val effectiveDate: LocalDate
          val effectiveDateAdjustment: DateRollConvention?
          open fun equals(other: Any?): Boolean
          open fun hashCode(): Int
          var interestPeriodAdjustment: AccrualAdjustment
          val notional: Amount
          var paymentCalendar: BusinessCalendar
          var paymentDelay: Int
          val paymentFrequency: Frequency
          var paymentRule: PaymentRule
          val terminationDate: LocalDate
          val terminationDateAdjustment: DateRollConvention?
          open fun toString(): String
        class FixedLeg : CommonLeg
          Module Contents FixedLeg(fixedRatePayer: Party, notional: Amount, 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)
          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, 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, fixingPeriod: DateOffset, resetRule: PaymentRule, fixingsPerPayment: Frequency, fixingCalendar: BusinessCalendar, index: String, indexSource: String, indexTenor: Tenor)
          open fun equals(other: Any?): Boolean
          var fixingCalendar: BusinessCalendar
          var fixingPeriod: DateOffset
          var fixingRollConvention: DateRollConvention
          var fixingsPerPayment: Frequency
          var floatingRatePayer: Party
          open fun hashCode(): Int
          var index: String
          var indexSource: String
          var indexTenor: Tenor
          var resetDayInMonth: Int
          var resetRule: PaymentRule
          var rollConvention: DateRollConvention
          open fun toString(): String
        data class State : FixableDealState
          Module Contents State(fixedLeg: FixedLeg, floatingLeg: FloatingLeg, calculation: Calculation, common: Common)
          val calculation: Calculation
          val common: Common
          val contract: InterestRateSwap
          fun evaluateCalculation(businessDate: LocalDate, expression: Expression = calculation.expression): Any
          val fixedLeg: FixedLeg
          val floatingLeg: FloatingLeg
          fun generateAgreement(): TransactionBuilder
          fun generateFix(ptx: TransactionBuilder, oldStateRef: StateRef, fix: Fix): Unit
          fun isRelevant(ourKeys: Set<PublicKey>): Boolean
          fun nextFixingOf(): FixOf?
          val parties: Array<Party>
          fun prettyPrint(): String
          val ref: String
          val thread: <ERROR CLASS>
          fun withPublicKey(before: Party, after: PublicKey): DealState
        fun generateAgreement(floatingLeg: FloatingLeg, fixedLeg: FixedLeg, calculation: Calculation, common: Common): TransactionBuilder
        fun generateFix(tx: TransactionBuilder, irs: StateAndRef<State>, fixing: <ERROR CLASS><LocalDate, Rate>): Unit
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      class InterestRateSwapAPI
        Module Contents InterestRateSwapAPI(api: APIServer)
        val api: APIServer
        fun exitServer(): <ERROR CLASS>
        fun fetchDeal(ref: String): <ERROR CLASS>
        fun fetchDeals(): Array<State>
        fun fetchDemoDate(): LocalDate
        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
      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
        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 toPrivate(publicKey: PublicKey): PrivateKey
      data class LedgerTransaction : NamedByHash
        Module Contents LedgerTransaction(inputs: List<StateRef>, attachments: List<Attachment>, outputs: List<ContractState>, commands: List<AuthenticatedObject<CommandData>>, id: SecureHash)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        val outputs: List<ContractState>
      class LinearInterpolator : Interpolator
        Module Contents LinearInterpolator(xs: DoubleArray, ys: DoubleArray)
        fun create(xs: DoubleArray, ys: DoubleArray): LinearInterpolator
        fun interpolate(x: Double): Double
      interface LinearState : ContractState
        Module Contents abstract fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        abstract val thread: SecureHash
      interface Message
        Module Contents abstract val data: ByteArray
        abstract val debugMessageID: String
        abstract val debugTimestamp: Instant
        abstract fun serialise(): ByteArray
        abstract val topic: String
      interface MessageHandlerRegistration
      interface MessageRecipientGroup : MessageRecipients
      interface MessageRecipients
      interface MessagingService
        Module Contents abstract fun addMessageHandler(topic: String = "", executor: Executor? = null, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        abstract fun createMessage(topic: String, data: ByteArray): Message
        abstract val myAddress: SingleMessageRecipient
        abstract fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        abstract fun send(message: Message, target: MessageRecipients): Unit
        abstract fun stop(): Unit
      interface MessagingServiceBuilder<out T : MessagingService>
        Module Contents abstract fun start(): <ERROR CLASS><out T>
      class MissingAttachmentsException : Exception
        Module Contents MissingAttachmentsException(ids: List<SecureHash>)
        val ids: List<SecureHash>
      class MockIdentityService : IdentityService
        Module Contents MockIdentityService(identities: List<Party>)
        val identities: List<Party>
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
      class MockNetwork
        Module Contents MockNetwork(threadPerNode: Boolean = false, defaultFactory: Factory = MockNetwork.DefaultFactory)
        object DefaultFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        interface Factory
          Module Contents abstract fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        class MockNode : AbstractNode
          Module Contents MockNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int)
          protected open fun findMyLocation(): PhysicalLocation?
          val id: Int
          protected open val log: <ERROR CLASS>
          protected open fun makeIdentityService(): MockIdentityService
          protected open fun makeMessagingService(): MessagingService
          val mockNet: MockNetwork
          val place: PhysicalLocation
          protected open val serverThread: AffinityExecutor
          open fun start(): MockNode
          protected open fun startMessagingService(): Unit
        fun addressToNode(address: SingleMessageRecipient): MockNode
        fun createNode(networkMapAddress: NodeInfo? = null, forcedID: Int = -1, nodeFactory: Factory = defaultFactory, vararg advertisedServices: ServiceType): MockNode
        fun createTwoNodes(nodeFactory: Factory = defaultFactory): <ERROR CLASS><MockNode, MockNode>
        val filesystem: <ERROR CLASS>
        val identities: ArrayList<Party>
        val messagingNetwork: InMemoryMessagingNetwork
        val nodes: List<MockNode>
        fun runNetwork(rounds: Int = -1): Unit
      class MockNetworkMapCache : InMemoryNetworkMapCache
        Module Contents MockNetworkMapCache()
        data class MockAddress : SingleMessageRecipient
          Module Contents MockAddress(id: String)
          val id: String
        fun addRegistration(node: NodeInfo): Unit
        fun deleteRegistration(identity: Party): Boolean
      class MonitoringService
        Module Contents MonitoringService(metrics: <ERROR CLASS>)
        val metrics: <ERROR CLASS>
      interface NamedByHash
        Module Contents abstract val id: SecureHash
      sealed class NetworkCacheError : Exception
        Module Contents class DeregistrationFailed : NetworkCacheError
          Module Contents DeregistrationFailed()
      interface NetworkMapCache
        Module Contents abstract fun addMapService(smm: StateMachineManager, net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int? = null): <ERROR CLASS><Unit>
        abstract fun addNode(node: NodeInfo): Unit
        abstract fun deregisterForUpdates(smm: StateMachineManager, net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        abstract fun get(): Collection<NodeInfo>
        abstract fun get(serviceType: ServiceType): Collection<NodeInfo>
        abstract fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        val logger: <ERROR CLASS>
        abstract val networkMapNodes: List<NodeInfo>
        open fun nodeForPartyName(name: String): NodeInfo?
        abstract val partyNodes: List<NodeInfo>
        abstract val ratesOracleNodes: List<NodeInfo>
        abstract val regulators: List<NodeInfo>
        abstract fun removeNode(node: NodeInfo): Unit
        abstract val timestampingNodes: List<NodeInfo>
      interface NetworkMapService
        Module Contents val DEFAULT_EXPIRATION_PERIOD: Period
        val FETCH_PROTOCOL_TOPIC: String
        class FetchMapRequest : AbstractRequestMessage
          Module Contents FetchMapRequest(subscribe: Boolean, ifChangedSinceVersion: Int?, replyTo: MessageRecipients, sessionID: Long)
          val ifChangedSinceVersion: Int?
          val subscribe: Boolean
        data class FetchMapResponse
          Module Contents FetchMapResponse(nodes: Collection<NodeRegistration>?, version: Int)
          val nodes: Collection<NodeRegistration>?
          val version: Int
        val PUSH_ACK_PROTOCOL_TOPIC: String
        val PUSH_PROTOCOL_TOPIC: String
        val QUERY_PROTOCOL_TOPIC: String
        class QueryIdentityRequest : AbstractRequestMessage
          Module Contents QueryIdentityRequest(identity: Party, replyTo: MessageRecipients, sessionID: Long)
          val identity: Party
        data class QueryIdentityResponse
          Module Contents QueryIdentityResponse(node: NodeInfo?)
          val node: NodeInfo?
        val REGISTER_PROTOCOL_TOPIC: String
        class RegistrationRequest : AbstractRequestMessage
          Module Contents RegistrationRequest(wireReg: WireNodeRegistration, replyTo: MessageRecipients, sessionID: Long)
          val wireReg: WireNodeRegistration
        data class RegistrationResponse
          Module Contents RegistrationResponse(success: Boolean)
          val success: Boolean
        val SUBSCRIPTION_PROTOCOL_TOPIC: String
        class SubscribeRequest : AbstractRequestMessage
          Module Contents SubscribeRequest(subscribe: Boolean, replyTo: MessageRecipients, sessionID: Long)
          val subscribe: Boolean
        data class SubscribeResponse
          Module Contents SubscribeResponse(confirmed: Boolean)
          val confirmed: Boolean
        object Type : ServiceType
        data class Update
          Module Contents Update(wireReg: WireNodeRegistration, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireReg: WireNodeRegistration
        data class UpdateAcknowledge
          Module Contents UpdateAcknowledge(wireRegHash: SecureHash, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireRegHash: SecureHash
        val logger: <ERROR CLASS>
        abstract val nodes: List<NodeInfo>
      class Node : AbstractNode
        Module Contents Node(dir: Path, p2pAddr: <ERROR CLASS>, configuration: NodeConfiguration, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, clock: Clock = Clock.systemUTC())
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingService
        val p2pAddr: <ERROR CLASS>
        protected val serverThread: ServiceAffinityExecutor
        fun start(): Node
        protected fun startMessagingService(): Unit
        fun stop(): Unit
        lateinit var webServer: <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
        val metrics: <ERROR CLASS>
        fun openAttachment(id: SecureHash): Attachment?
        val storePath: Path
        fun upload(data: InputStream): <ERROR CLASS>
      interface NodeConfiguration
        Module Contents abstract val exportJMXto: String
        abstract val myLegalName: String
        abstract val nearestCity: String
      class NodeConfigurationFromConfig : NodeConfiguration
        Module Contents NodeConfigurationFromConfig(config: <ERROR CLASS> = ConfigFactory.load())
        val config: <ERROR CLASS>
        val exportJMXto: String
        val myLegalName: String
        val nearestCity: 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.Factory)
          val factory: InterpolatorFactory
          val fixes: List<Fix>
          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 inputRates: Map<Tenor, BigDecimal>
          val size: Int
        class Oracle
          Module Contents Oracle(identity: Party, signingKey: KeyPair)
          val identity: Party
          var knownFixes: FixContainer
          fun query(queries: List<FixOf>): List<Fix>
          fun sign(wtx: WireTransaction): LegallyIdentifiable
        class Service : AcceptsFileUpload, AbstractNodeService
          Module Contents Service(node: AbstractNode)
          val acceptableFileExtensions: <ERROR CLASS>
          val dataTypePrefix: String
          val oracle: Oracle
          val ss: StorageService
          fun upload(data: InputStream): String
        object Type : ServiceType
        class UnknownFix : Exception
          Module Contents UnknownFix(fix: FixOf)
          val fix: FixOf
          fun toString(): String
        fun parseFile(s: String): FixContainer
        fun parseFix(s: String): Fix
        fun parseFixOf(key: String): FixOf
      sealed class NodeMapError : Exception
        Module Contents class InvalidSignature : NodeMapError
          Module Contents InvalidSignature()
        class InvalidSubscriber : NodeMapError
          Module Contents InvalidSubscriber()
        class UnknownChangeType : NodeMapError
          Module Contents UnknownChangeType()
      class NodeRegistration
        Module Contents NodeRegistration(node: NodeInfo, serial: Long, type: AddOrRemove, expires: Instant)
        var expires: Instant
        val node: NodeInfo
        val serial: Long
        fun toString(): String
        fun toWire(privateKey: PrivateKey): WireNodeRegistration
        val type: AddOrRemove
      class NodeTimestamperService : AbstractNodeService
        Module Contents NodeTimestamperService(net: MessagingService, identity: Party, signingKey: KeyPair, clock: Clock = Clock.systemDefaultZone(), tolerance: Duration = 30.seconds)
        val TIMESTAMPING_PROTOCOL_TOPIC: String
        val clock: Clock
        val identity: Party
        fun processRequest(req: Request): LegallyIdentifiable
        val signingKey: KeyPair
        val tolerance: Duration
      class NodeWalletService : WalletService
        Module Contents NodeWalletService(services: ServiceHub)
        val cashBalances: Map<Currency, Amount>
        val currentWallet: Wallet
        fun fillWithSomeTestCash(howMuch: Amount, atLeastThisManyStates: Int = 3, atMostThisManyStates: Int = 10, rng: Random = Random()): Unit
        val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        fun notifyAll(txns: Iterable<WireTransaction>): Wallet
      object NullPublicKey : PublicKey, Comparable<PublicKey>
        Module Contents fun compareTo(other: PublicKey): Int
        fun getAlgorithm(): String
        fun getEncoded(): ByteArray
        fun getFormat(): String
        fun toString(): String
      open class OpaqueBytes
        Module Contents OpaqueBytes(bits: ByteArray)
        val bits: ByteArray
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        fun of(vararg b: Byte): OpaqueBytes
        val size: Int
        open fun toString(): String
      interface OwnableState : ContractState
        Module Contents abstract val owner: PublicKey
        abstract fun withNewOwner(newOwner: PublicKey): <ERROR CLASS><CommandData, OwnableState>
      data class Party
        Module Contents Party(name: String, owningKey: PublicKey)
        val name: String
        val owningKey: PublicKey
        fun ref(bytes: OpaqueBytes): PartyReference
        fun ref(vararg bytes: Byte): PartyReference
        fun toString(): String
      data class PartyReference
        Module Contents PartyReference(party: Party, reference: OpaqueBytes)
        val party: Party
        val reference: OpaqueBytes
        fun toString(): String
      abstract class PaymentEvent : Event
        Module Contents PaymentEvent(date: LocalDate)
        abstract fun calculate(): Amount
      enum class PaymentRule
        Module Contents InAdvance
        InArrears
      open class PercentageRatioUnit : RatioUnit
        Module Contents PercentageRatioUnit(percentageAsString: String)
        open fun toString(): String
      data class PhysicalLocation
        Module Contents PhysicalLocation(coordinate: WorldCoordinate, description: String)
        val coordinate: WorldCoordinate
        val description: String
      class Polynomial
        Module Contents Polynomial(coefficients: DoubleArray)
        fun getValue(x: Double): <ERROR CLASS>
      class ProgressTracker
        Module Contents ProgressTracker(vararg steps: Step)
        sealed class Change
          Module Contents class Position : Change
            Module Contents Position(tracker: ProgressTracker, newStep: Step)
            val newStep: Step
            fun toString(): String
            val tracker: ProgressTracker
          class Rendering : Change
            Module Contents Rendering(tracker: ProgressTracker, ofStep: Step)
            val ofStep: Step
            fun toString(): String
            val tracker: ProgressTracker
          class Structural : Change
            Module Contents Structural(tracker: ProgressTracker, parent: Step)
            val parent: Step
            fun toString(): String
            val tracker: ProgressTracker
        object DONE : Step
          Module Contents fun equals(other: Any?): Boolean
        inner class RelabelableStep : Step
          Module Contents RelabelableStep(currentLabel: String)
          open val changes: <ERROR CLASS>
          var currentLabel: String
          open val label: String
        class Step
          Module Contents Step(label: String)
          open val changes: <ERROR CLASS><Change>
          open 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 childrenFor: HashMap<Step, ProgressTracker>
        var currentStep: Step
        val currentStepRecursive: Step
        fun nextStep(): Step
        var parent: ProgressTracker?
        var stepIndex: Int
        val steps: Array<Step>
        val topLevelTracker: ProgressTracker
      data class ProtocolClassRef : ProtocolRef
        Module Contents ProtocolClassRef(className: String)
        val className: String
      data class ProtocolInstanceRef
        Module Contents ProtocolInstanceRef(protocolInstance: SecureHash, protocolClass: ProtocolClassRef, protocolStepId: String)
        val protocolClass: ProtocolClassRef
        val protocolInstance: SecureHash
        val protocolStepId: String
      abstract class ProtocolLogic<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(topic: String, sessionIDForReceive: Long): UntrustworthyData<T>
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, clazz: Class<T>): UntrustworthyData<T>
        fun send(topic: String, destination: MessageRecipients, sessionID: Long, obj: Any): Unit
        inline fun <reified T : Any> sendAndReceive(topic: String, destination: MessageRecipients, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any): UntrustworthyData<T>
        val serviceHub: ServiceHub
        fun <R> subProtocol(subLogic: ProtocolLogic<R>): R
      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
      class ProtocolStateMachine<R>
        Module Contents ProtocolStateMachine(logic: ProtocolLogic<R>, scheduler: <ERROR CLASS>)
        lateinit var logger: <ERROR CLASS>
        val logic: ProtocolLogic<R>
        fun prepareForResumeWith(serviceHub: ServiceHub, withObject: Any?, logger: <ERROR CLASS>, suspendFunc: (FiberRequest, ByteArray) -> Unit): Unit
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, recvType: Class<T>): UntrustworthyData<T>
        val resultFuture: <ERROR CLASS><R>
        fun run(): R
        fun send(topic: String, destination: MessageRecipients, sessionID: Long, obj: Any): Unit
        fun <T : Any> sendAndReceive(topic: String, destination: MessageRecipients, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any, recvType: Class<T>): UntrustworthyData<T>
        lateinit var serviceHub: ServiceHub
      open class Rate
        Module Contents Rate(ratioUnit: RatioUnit? = null)
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val ratioUnit: RatioUnit?
      abstract class RatePaymentEvent : PaymentEvent
        Module Contents RatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount, rate: Rate)
        val CSVHeader: String
        val accrualEndDate: LocalDate
        val accrualStartDate: LocalDate
        open fun asCSV(): String
        open fun calculate(): Amount
        val dayCountBasisDay: DayCountBasisDay
        val dayCountBasisYear: DayCountBasisYear
        val dayCountFactor: BigDecimal
        val days: Int
        abstract val flow: Amount
        val notional: Amount
        val rate: Rate
      open class RatesFixProtocol : ProtocolLogic<Unit>
        Module Contents RatesFixProtocol(tx: TransactionBuilder, oracle: NodeInfo, 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
        class QueryRequest : AbstractRequestMessage
          Module Contents QueryRequest(queries: List<FixOf>, replyTo: SingleMessageRecipient, sessionID: Long)
          val queries: List<FixOf>
        object SIGNING : Step
        class SignRequest : AbstractRequestMessage
          Module Contents SignRequest(tx: WireTransaction, replyTo: SingleMessageRecipient, sessionID: Long)
          val tx: WireTransaction
        val TOPIC: String
        val TOPIC_QUERY: String
        val TOPIC_SIGN: String
        object WORKING : Step
        protected open fun beforeSigning(fix: Fix): Unit
        open fun call(): Unit
        open val progressTracker: ProgressTracker
        fun query(): Fix
        fun sign(): LegallyIdentifiable
        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
        val value: BigDecimal
      class RecordingMap<K, V> : MutableMap<K, V>
        Module Contents RecordingMap(wrappedMap: MutableMap<K, V>, logger: <ERROR CLASS> = loggerFor<RecordingMap<K, V>>())
        data class Get<K> : Record
          Module Contents Get(key: K)
          val key: K
        data class Put<K, V> : Record
          Module Contents Put(key: K, value: V)
          val key: K
          val value: V
        interface Record
        fun clearRecords(): Unit
        fun get(key: K): V?
        fun put(key: K, value: V): V?
        fun putAll(from: Map<out K, V>): Unit
        fun putAllUnrecorded(from: Map<out K, V>): Unit
        val records: List<Record>
      class ReferenceRate : FloatingRate
        Module Contents ReferenceRate(oracle: String, tenor: Tenor, name: String)
        val name: String
        val oracle: String
        val tenor: Tenor
        fun toString(): String
      interface RegulatorService
        Module Contents object Type : ServiceType
      class Requirements
        Module Contents Requirements()
        infix fun String.by(expr: Boolean): Unit
      class ResolveTransactionsProtocol : ProtocolLogic<Unit>
        Module Contents ResolveTransactionsProtocol(stx: SignedTransaction, otherSide: SingleMessageRecipient)
        ResolveTransactionsProtocol(wtx: WireTransaction, otherSide: SingleMessageRecipient)
        ResolveTransactionsProtocol(txHashes: Set<SecureHash>, otherSide: SingleMessageRecipient)
        class ExcessivelyLargeTransactionGraph : Exception
          Module Contents ExcessivelyLargeTransactionGraph()
        fun call(): Unit
      class ResponseFilter
        Module Contents ResponseFilter()
        fun filter(requestContext: <ERROR CLASS>, responseContext: <ERROR CLASS>): Unit
      sealed class SecureHash : OpaqueBytes
        Module Contents class SHA256 : SecureHash
          Module Contents SHA256(bits: ByteArray)
          val signatureAlgorithmName: String
        fun parse(str: String): <ERROR CLASS>
        fun prefixChars(prefixLen: Int = 6): <ERROR CLASS>
        fun randomSHA256(): SHA256
        fun sha256(bits: ByteArray): SHA256
        fun sha256(str: String): <ERROR CLASS>
        fun sha256Twice(bits: ByteArray): SHA256
        abstract val signatureAlgorithmName: String
        open fun toString(): <ERROR CLASS>
      class SerializedBytes<T : Any> : OpaqueBytes
        Module Contents SerializedBytes(bits: ByteArray)
        val hash: SecureHash
        fun writeToFile(path: Path): Path
      object SerializedBytesSerializer
        Module Contents fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type: Class<SerializedBytes<Any>>): SerializedBytes<Any>
        fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: SerializedBytes<Any>): Unit
      interface ServiceHub
        Module Contents abstract val clock: Clock
        abstract val identityService: IdentityService
        abstract val keyManagementService: KeyManagementService
        abstract val monitoringService: MonitoringService
        abstract val networkMapCache: NetworkMapCache
        abstract val networkService: MessagingService
        open fun recordTransactions(txs: List<SignedTransaction>, skipRecordingMap: Boolean = false): Unit
        abstract val storageService: StorageService
        open fun verifyTransaction(ltx: LedgerTransaction): Unit
        abstract val walletService: WalletService
      abstract class ServiceType
        Module Contents ServiceType(id: String)
        open operator fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val id: String
        open fun toString(): String
      open class SignedData<T : Any>
        Module Contents SignedData(raw: SerializedBytes<T>, sig: WithKey)
        val raw: SerializedBytes<T>
        val sig: WithKey
        fun verified(): T
        protected open fun verifyData(data: T): Unit
      data class SignedTransaction : NamedByHash
        Module Contents SignedTransaction(txBits: SerializedBytes<WireTransaction>, sigs: List<WithKey>)
        val id: SecureHash
        operator fun plus(sig: WithKey): SignedTransaction
        val sigs: List<WithKey>
        val tx: WireTransaction
        val txBits: SerializedBytes<WireTransaction>
        fun verify(throwIfSignaturesAreMissing: Boolean = true): Set<PublicKey>
        fun verifySignatures(): Unit
        fun withAdditionalSignature(sig: WithKey): SignedTransaction
      abstract class Simulation
        Module Contents Simulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        inner class BankFactory : Factory
          Module Contents BankFactory()
          var counter: Int
          fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
          fun createAll(): List<SimulatedNode>
        object NetworkMapNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        object RatesOracleFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        object RegulatorFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        open class SimulatedNode : MockNode
          Module Contents SimulatedNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int)
          protected open fun findMyLocation(): PhysicalLocation?
        object TimestampingNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        val allProtocolSteps: <ERROR CLASS><<ERROR CLASS><SimulatedNode, Change>>
        val bankFactory: BankFactory
        val bankLocations: <ERROR CLASS>
        val banks: List<SimulatedNode>
        var currentDay: LocalDate
        val dateChanges: <ERROR CLASS><LocalDate>
        val doneSteps: <ERROR CLASS><Collection<SimulatedNode>>
        val extraNodeLabels: MutableMap<SimulatedNode, String>
        open fun iterate(): Unit
        val latencyInjector: LatencyCalculator?
        protected fun linkConsensus(nodes: Collection<SimulatedNode>, protocol: ProtocolLogic<*>): Unit
        protected fun linkProtocolProgress(node: SimulatedNode, protocol: ProtocolLogic<*>): Unit
        val network: MockNetwork
        val networkMap: SimulatedNode
        val ratesOracle: SimulatedNode
        val regulators: List<SimulatedNode>
        val runAsync: Boolean
        val serviceProviders: List<SimulatedNode>
        open fun start(): Unit
        fun startTradingCircle(tradeBetween: (Int, Int) -> <ERROR CLASS><out <ERROR CLASS>>): Unit
        fun stop(): Unit
        val timestamper: SimulatedNode
      interface SingleMessageRecipient : MessageRecipients
      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: T, ref: StateRef)
        val ref: StateRef
        val state: T
      class StateMachineManager
        Module Contents StateMachineManager(serviceHub: ServiceHub, executor: AffinityExecutor)
        class FiberRequest
          Module Contents FiberRequest(topic: String, destination: MessageRecipients?, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any?)
          class ExpectingResponse<R : Any> : FiberRequest
            Module Contents ExpectingResponse(topic: String, destination: MessageRecipients?, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any?, responseType: Class<R>)
            val responseType: Class<R>
          class NotExpectingResponse : FiberRequest
            Module Contents NotExpectingResponse(topic: String, destination: MessageRecipients, sessionIDForSend: Long, obj: Any?)
          val destination: MessageRecipients?
          val obj: Any?
          val sessionIDForReceive: Long
          val sessionIDForSend: Long
          val stackTraceInCaseOfProblems: StackSnapshot
          val topic: String
        inner class FiberScheduler
          Module Contents FiberScheduler()
        fun <T> add(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
        val executor: AffinityExecutor
        fun <T> findStateMachines(klass: Class<out ProtocolLogic<T>>): List<<ERROR CLASS><ProtocolLogic<T>, <ERROR CLASS><T>>>
        val scheduler: FiberScheduler
        val serviceHub: ServiceHub
      data class StateRef
        Module Contents StateRef(txhash: SecureHash, index: Int)
        val index: Int
        fun toString(): String
        val txhash: SecureHash
      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
        fun selectAllDeals(): Selection
        fun selectDeal(ref: String): Selection
      interface StorageService
        Module Contents abstract val attachments: AttachmentStorage
        abstract val myLegalIdentity: Party
        abstract val myLegalIdentityKey: KeyPair
        abstract val stateMachines: MutableMap<SecureHash, ByteArray>
        abstract val validatedTransactions: MutableMap<SecureHash, SignedTransaction>
      open class StorageServiceImpl : StorageService
        Module Contents StorageServiceImpl(attachments: AttachmentStorage, keypair: KeyPair, identity: Party = Party("Unit test party", keypair.public), recordingAs: (String) -> String = { tableName -> "" })
        open val attachments: AttachmentStorage
        open val myLegalIdentity: Party
        open val myLegalIdentityKey: KeyPair
        val recordingAs: (String) -> String
        open val stateMachines: MutableMap<SecureHash, ByteArray>
        protected val tables: HashMap<String, MutableMap<*, *>>
        open val validatedTransactions: MutableMap<SecureHash, SignedTransaction>
      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<T>
        Module Contents ThreadBox(content: T, lock: Lock = ReentrantLock())
        val content: T
        val lock: Lock
        inline fun <R> locked(body: T.() -> R): R
      data class TimestampCommand : CommandData
        Module Contents TimestampCommand(time: Instant, tolerance: Duration)
        TimestampCommand(after: Instant?, before: Instant?)
        val after: Instant?
        val before: Instant?
        val midpoint: Instant
      interface TimestamperService
        Module Contents object Type : ServiceType
        abstract val identity: Party
        abstract fun timestamp(wtxBytes: SerializedBytes<WireTransaction>): LegallyIdentifiable
      sealed class TimestampingError : Exception
        Module Contents class NotForMe : TimestampingError
          Module Contents NotForMe()
        class NotOnTimeException : TimestampingError
          Module Contents NotOnTimeException()
        class RequiresExactlyOneCommand : TimestampingError
          Module Contents RequiresExactlyOneCommand()
      class TimestampingProtocol : ProtocolLogic<LegallyIdentifiable>
        Module Contents TimestampingProtocol(node: NodeInfo, wtxBytes: SerializedBytes<WireTransaction>, progressTracker: ProgressTracker = TimestampingProtocol.tracker())
        class Client : TimestamperService
          Module Contents Client(stateMachineManager: StateMachineManager, node: NodeInfo)
          val identity: Party
          fun timestamp(wtxBytes: SerializedBytes<WireTransaction>): LegallyIdentifiable
        object REQUESTING : Step
        class Request : AbstractRequestMessage
          Module Contents Request(tx: SerializedBytes<WireTransaction>, replyTo: MessageRecipients, sessionID: Long)
          val tx: SerializedBytes<WireTransaction>
        object VALIDATING : Step
        fun call(): LegallyIdentifiable
        val progressTracker: ProgressTracker
        fun tracker(): ProgressTracker
      object TopicStringValidator
        Module Contents fun check(tag: String): <ERROR CLASS>
      class TradeSimulation : Simulation
        Module Contents TradeSimulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        fun start(): Unit
      class TraderDemoProtocolBuyer : ProtocolLogic<Unit>
        Module Contents TraderDemoProtocolBuyer(attachmentsPath: Path)
        object STARTING_BUY : Step
        object WAITING_FOR_SELLER_TO_CONNECT : Step
        fun call(): Unit
        val progressTracker: ProgressTracker
      class TraderDemoProtocolSeller : ProtocolLogic<Unit>
        Module Contents TraderDemoProtocolSeller(myAddress: <ERROR CLASS>, otherSide: SingleMessageRecipient, progressTracker: ProgressTracker = TraderDemoProtocolSeller.tracker())
        object ANNOUNCING : Step
        val PROSPECTUS_HASH: <ERROR CLASS>
        object SELF_ISSUING : Step
        object TRADING : Step
        fun call(): Unit
        val myAddress: <ERROR CLASS>
        val otherSide: SingleMessageRecipient
        val progressTracker: ProgressTracker
        fun selfIssueSomeCommercialPaper(ownedBy: PublicKey, tsa: NodeInfo): StateAndRef<State>
        fun tracker(): <ERROR CLASS>
      data class TransactionBuildStep
        Module Contents TransactionBuildStep(generateMethodName: String, args: Map<String, Any?>)
        val args: Map<String, Any?>
        val generateMethodName: String
      class TransactionBuilder
        Module Contents TransactionBuilder(inputs: MutableList<StateRef> = arrayListOf(), attachments: MutableList<SecureHash> = arrayListOf(), outputs: MutableList<ContractState> = arrayListOf(), commands: MutableList<Command> = arrayListOf())
        fun addAttachment(attachment: Attachment): Unit
        fun addCommand(arg: Command): Unit
        fun addCommand(data: CommandData, vararg keys: PublicKey): <ERROR CLASS>
        fun addCommand(data: CommandData, keys: List<PublicKey>): Unit
        fun addInputState(ref: StateRef): Unit
        fun addOutputState(state: ContractState): Unit
        fun addSignatureUnchecked(sig: WithKey): Unit
        fun attachments(): List<SecureHash>
        fun checkAndAddSignature(sig: WithKey): Unit
        fun checkSignature(sig: WithKey): Unit
        fun commands(): List<Command>
        fun inputStates(): List<StateRef>
        fun outputStates(): List<ContractState>
        fun setTime(time: Instant, authenticatedBy: Party, timeTolerance: Duration): Unit
        fun signWith(key: KeyPair): Unit
        val time: TimestampCommand?
        fun timestamp(timestamper: TimestamperService, clock: Clock = Clock.systemUTC()): Unit
        fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction
        fun toWireTransaction(): WireTransaction
        fun withItems(vararg items: Any): TransactionBuilder
      class TransactionConflictException : Exception
        Module Contents TransactionConflictException(conflictRef: StateRef, tx1: LedgerTransaction, tx2: LedgerTransaction)
        val conflictRef: StateRef
        val tx1: LedgerTransaction
        val tx2: LedgerTransaction
      data class TransactionForVerification
        Module Contents TransactionForVerification(inStates: List<ContractState>, outStates: List<ContractState>, attachments: List<Attachment>, commands: List<AuthenticatedObject<CommandData>>, origHash: SecureHash)
        data class InOutGroup<T : ContractState, K : Any>
          Module Contents InOutGroup(inputs: List<T>, outputs: List<T>, groupingKey: K)
          val groupingKey: K
          val inputs: List<T>
          val outputs: List<T>
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        fun equals(other: Any?): Boolean
        fun getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun <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 inStates: List<ContractState>
        val origHash: SecureHash
        val outStates: List<ContractState>
        fun verify(): Unit
      class TransactionGraphSearch : Callable<List<WireTransaction>>
        Module Contents TransactionGraphSearch(transactions: Map<SecureHash, SignedTransaction>, startPoints: List<WireTransaction>)
        class Query
          Module Contents Query(withCommandOfType: Class<out CommandData>? = null)
          val withCommandOfType: Class<out CommandData>?
        fun call(): List<WireTransaction>
        var query: Query
        val startPoints: List<WireTransaction>
        val transactions: Map<SecureHash, SignedTransaction>
      class TransactionGroup
        Module Contents TransactionGroup(transactions: Set<LedgerTransaction>, nonVerifiedRoots: Set<LedgerTransaction>)
        val nonVerifiedRoots: Set<LedgerTransaction>
        val transactions: Set<LedgerTransaction>
        fun verify(): Set<TransactionForVerification>
      class TransactionResolutionException : Exception
        Module Contents TransactionResolutionException(hash: SecureHash)
        val hash: SecureHash
      class TransactionVerificationException : Exception
        Module Contents TransactionVerificationException(tx: TransactionForVerification, contract: Contract, cause: Throwable?)
        val contract: Contract
        val tx: TransactionForVerification
      class TransientProperty<T>
        Module Contents TransientProperty(initializer: () -> T)
        operator fun getValue(thisRef: Any?, property: KProperty<*>): T
      object TwoPartyDealProtocol
        Module Contents class Acceptor<T : DealState> : Secondary<T>
          Module Contents Acceptor(otherSide: SingleMessageRecipient, timestampingAuthority: Party, dealToBuy: T, sessionID: Long, progressTracker: ProgressTracker = Secondary.tracker())
          protected open fun assembleSharedTX(handshake: Handshake<T>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val dealToBuy: T
          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
        class Fixer<T : FixableDealState> : Secondary<StateRef>
          Module Contents Fixer(otherSide: SingleMessageRecipient, timestampingAuthority: Party, dealToFix: StateAndRef<T>, sessionID: Long, replacementProgressTracker: ProgressTracker? = null)
          protected open fun assembleSharedTX(handshake: Handshake<StateRef>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          fun createTracker(): ProgressTracker
          val dealToFix: StateAndRef<T>
          open val progressTracker: ProgressTracker
          val replacementProgressTracker: ProgressTracker?
          protected open fun validateHandshake(handshake: Handshake<StateRef>): Handshake<StateRef>
        class Floater<T : FixableDealState> : Primary<StateRef>
          Module Contents Floater(otherSide: SingleMessageRecipient, otherSessionID: Long, timestampingAuthority: NodeInfo, dealToFix: StateAndRef<T>, myKeyPair: KeyPair, sessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          open val progressTracker: ProgressTracker
          val sessionID: Long
        data class Handshake<T>
          Module Contents Handshake(payload: T, publicKey: PublicKey, sessionID: Long)
          val payload: T
          val publicKey: PublicKey
          val sessionID: Long
        class Instigator<T : DealState> : Primary<T>
          Module Contents Instigator(otherSide: SingleMessageRecipient, timestampingAuthority: NodeInfo, dealBeingOffered: T, myKeyPair: KeyPair, buyerSessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          open val progressTracker: ProgressTracker
        abstract class Primary<U> : ProtocolLogic<SignedTransaction>
          Module Contents Primary(payload: U, otherSide: SingleMessageRecipient, otherSessionID: Long, myKeyPair: KeyPair, timestampingAuthority: NodeInfo, progressTracker: ProgressTracker = Primary.tracker())
          object AWAITING_PROPOSAL : Step
          object COPYING_TO_REGULATOR : Step
          object RECORDING : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object TIMESTAMPING : Step
          object VERIFYING : Step
          open fun call(): SignedTransaction
          fun getPartialTransaction(): UntrustworthyData<SignedTransaction>
          val myKeyPair: KeyPair
          val otherSessionID: Long
          val otherSide: SingleMessageRecipient
          val payload: U
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          val timestampingAuthority: NodeInfo
          fun tracker(): <ERROR CLASS>
          fun verifyPartialTransaction(untrustedPartialTX: UntrustworthyData<SignedTransaction>): SignedTransaction
        abstract class Secondary<U> : ProtocolLogic<SignedTransaction>
          Module Contents Secondary(otherSide: SingleMessageRecipient, timestampingAuthority: Party, sessionID: Long, 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
          val otherSide: SingleMessageRecipient
          open val progressTracker: ProgressTracker
          val sessionID: Long
          val timestampingAuthority: Party
          fun tracker(): ProgressTracker
          protected abstract fun validateHandshake(handshake: Handshake<U>): Handshake<U>
        class SignaturesFromPrimary
          Module Contents SignaturesFromPrimary(timestampAuthoritySig: WithKey, sellerSig: WithKey)
          val sellerSig: WithKey
          val timestampAuthoritySig: WithKey
      object TwoPartyTradeProtocol
        Module Contents class AssetMismatchException : Exception
          Module Contents AssetMismatchException(expectedTypeName: String, typeName: String)
          val expectedTypeName: String
          fun toString(): String
          val typeName: String
        class Buyer : ProtocolLogic<SignedTransaction>
          Module Contents Buyer(otherSide: SingleMessageRecipient, timestampingAuthority: Party, acceptablePrice: Amount, typeToBuy: Class<out OwnableState>, sessionID: Long)
          object RECEIVING : Step
          object SIGNING : Step
          object SWAPPING_SIGNATURES : Step
          object VERIFYING : Step
          val acceptablePrice: Amount
          open fun call(): SignedTransaction
          val otherSide: SingleMessageRecipient
          open val progressTracker: ProgressTracker
          val sessionID: Long
          val timestampingAuthority: Party
          val typeToBuy: Class<out OwnableState>
        class Seller : ProtocolLogic<SignedTransaction>
          Module Contents Seller(otherSide: SingleMessageRecipient, timestampingAuthority: NodeInfo, assetToSell: StateAndRef<OwnableState>, price: Amount, myKeyPair: KeyPair, buyerSessionID: Long, progressTracker: ProgressTracker = Seller.tracker())
          object AWAITING_PROPOSAL : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object TIMESTAMPING : Step
          object VERIFYING : Step
          val assetToSell: StateAndRef<OwnableState>
          val buyerSessionID: Long
          open fun call(): SignedTransaction
          val myKeyPair: KeyPair
          val otherSide: SingleMessageRecipient
          val price: Amount
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          val timestampingAuthority: NodeInfo
          fun tracker(): ProgressTracker
        class SellerTradeInfo
          Module Contents SellerTradeInfo(assetForSale: StateAndRef<OwnableState>, price: Amount, sellerOwnerKey: PublicKey, sessionID: Long)
          val assetForSale: StateAndRef<OwnableState>
          val price: Amount
          val sellerOwnerKey: PublicKey
          val sessionID: Long
        class SignaturesFromSeller
          Module Contents SignaturesFromSeller(timestampAuthoritySig: WithKey, sellerSig: WithKey)
          val sellerSig: WithKey
          val timestampAuthoritySig: WithKey
        val TRADE_TOPIC: String
        class UnacceptablePriceException : Exception
          Module Contents UnacceptablePriceException(givenPrice: Amount)
          val givenPrice: Amount
        fun runBuyer(smm: StateMachineManager, timestampingAuthority: NodeInfo, otherSide: SingleMessageRecipient, acceptablePrice: Amount, typeToBuy: Class<out OwnableState>, sessionID: Long): <ERROR CLASS><SignedTransaction>
        fun runSeller(smm: StateMachineManager, timestampingAuthority: NodeInfo, otherSide: SingleMessageRecipient, assetToSell: StateAndRef<OwnableState>, price: Amount, myKeyPair: KeyPair, buyerSessionID: Long): <ERROR CLASS><SignedTransaction>
      abstract class TypeOnlyCommandData : CommandData
        Module Contents TypeOnlyCommandData()
        open fun equals(other: Any?): Boolean
        open fun hashCode(): <ERROR CLASS>
      open class UnknownType
        Module Contents UnknownType()
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
      class UntrustworthyData<T>
        Module Contents UntrustworthyData(fromUntrustedWorld: T)
        val data: T
        inline fun <R> validate(validator: (T) -> R): R
      object UpdateBusinessDayProtocol
        Module Contents class Broadcast : ProtocolLogic<Boolean>
          Module Contents Broadcast(date: LocalDate, progressTracker: ProgressTracker = Broadcast.tracker())
          object LOCAL : Step
          object NOTIFYING : Step
          fun call(): Boolean
          val date: LocalDate
          val progressTracker: ProgressTracker
          fun tracker(): <ERROR CLASS>
        object Handler
          Module Contents fun register(node: Node): Unit
        val TOPIC: String
        data class UpdateBusinessDayMessage
          Module Contents UpdateBusinessDayMessage(date: LocalDate, sessionID: Long)
          val date: LocalDate
          val sessionID: Long
        class Updater : ProtocolLogic<Boolean>
          Module Contents Updater(date: LocalDate, sessionID: Long, progressTracker: ProgressTracker = Updater.tracker())
          object FETCHING : Step
          object FIXING : Step
          object ITERATING_DEALS : Step
          object ITERATING_FIXINGS : Step
          fun call(): Boolean
          val date: LocalDate
          fun otherParty(deal: DealState): NodeInfo
          fun processDeal(party: NodeInfo, deal: StateAndRef<DealState>, date: LocalDate, sessionID: Long): Unit
          fun processInterestRateSwap(party: NodeInfo, deal: StateAndRef<State>, date: LocalDate, sessionID: Long): Unit
          val progressTracker: ProgressTracker
          val sessionID: Long
          fun tracker(): ProgressTracker
      data class Wallet
        Module Contents Wallet(states: List<StateAndRef<ContractState>>)
        val cashBalances: Map<Currency, Amount>
        val states: List<StateAndRef<ContractState>>
        inline fun <reified T : OwnableState> statesOfType(): List<StateAndRef<T>>
      interface WalletService
        Module Contents abstract val cashBalances: Map<Currency, Amount>
        abstract val currentWallet: Wallet
        abstract val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        open fun <T : LinearState> linearHeadsOfType_(stateType: Class<T>): Map<SecureHash, StateAndRef<T>>
        open fun notify(tx: WireTransaction): Wallet
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Wallet
        open fun statesForRefs(refs: List<StateRef>): Map<StateRef, ContractState?>
      class WireNodeRegistration : SignedData<NodeRegistration>
        Module Contents WireNodeRegistration(raw: SerializedBytes<NodeRegistration>, sig: WithKey)
        protected fun verifyData(reg: NodeRegistration): Unit
      data class WireTransaction : NamedByHash
        Module Contents WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<ContractState>, commands: List<Command>)
        val attachments: List<SecureHash>
        val commands: List<Command>
        fun deserialize(bits: SerializedBytes<WireTransaction>, kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun <T : ContractState> outRef(state: ContractState): StateAndRef<T>
        val outputs: List<ContractState>
        val serialized: SerializedBytes<WireTransaction>
        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
      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>
      java.nio.file.Path
        Module Contents fun <R> Path.use(block: (InputStream) -> R): R
      java.security.KeyPair
        Module Contents operator fun KeyPair.component1(): PrivateKey
        operator fun KeyPair.component2(): PublicKey
        fun KeyPair.signWithECDSA(bitsToSign: ByteArray): WithKey
        fun KeyPair.signWithECDSA(bitsToSign: OpaqueBytes): WithKey
        fun KeyPair.signWithECDSA(bitsToSign: OpaqueBytes, party: Party): LegallyIdentifiable
        fun KeyPair.signWithECDSA(bitsToSign: ByteArray, party: Party): LegallyIdentifiable
      java.security.PrivateKey
        Module Contents fun PrivateKey.signWithECDSA(bits: ByteArray): DigitalSignature
        fun PrivateKey.signWithECDSA(bitsToSign: ByteArray, publicKey: PublicKey): WithKey
      java.security.PublicKey
        Module Contents fun PublicKey.toStringShort(): String
        fun PublicKey.verifyWithECDSA(content: ByteArray, signature: DigitalSignature): Unit
      java.time.LocalDate
        Module Contents fun LocalDate.isWorkingDay(accordingToCalendar: BusinessCalendar): Boolean
      java.time.temporal.Temporal
        Module Contents infix fun Temporal.until(endExclusive: Temporal): Duration
      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
        val Double.bd: BigDecimal
      kotlin.Int
        Module Contents val Int.DOLLARS: Amount
        val Int.POUNDS: Amount
        val Int.SWISS_FRANCS: Amount
        val Int.bd: BigDecimal
        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
      kotlin.String
        Module Contents val String.bd: BigDecimal
      kotlin.String
        Module Contents val String.percent: PercentageRatioUnit
      kotlin.collections.Iterable
        Module Contents fun Iterable<Amount>.sumOrNull(): Nothing?
        fun Iterable<Amount>.sumOrThrow(): <ERROR CLASS>
        fun Iterable<Amount>.sumOrZero(currency: Currency): Amount
      kotlin.collections.Iterable
        Module Contents fun Iterable<ContractState>.sumCash(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCashBy(owner: PublicKey): <ERROR CLASS>
        fun Iterable<ContractState>.sumCashOrNull(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCashOrZero(currency: Currency): <ERROR CLASS>
      kotlin.collections.List
        Module Contents inline fun <reified T : ContractState> List<StateAndRef<ContractState>>.filterStatesOfType(): List<StateAndRef<T>>
        fun List<AuthenticatedObject<CommandData>>.getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun List<AuthenticatedObject<CommandData>>.getTimestampByName(vararg names: String): TimestampCommand?
        fun <T> List<T>.indexOfOrThrow(item: T): Int
        inline fun <reified T : CommandData> List<AuthenticatedObject<CommandData>>.requireSingleCommand(): <ERROR CLASS>
        fun List<AuthenticatedObject<CommandData>>.requireSingleCommand(klass: Class<out CommandData>): <ERROR CLASS>
        inline fun <reified T : CommandData> List<AuthenticatedObject<CommandData>>.select(signer: PublicKey? = null, party: Party? = null): <ERROR CLASS>
    package 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, 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
      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, 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
      class Config
        Module Contents Config(services: ServiceHub)
        val defaultObjectMapper: <ERROR CLASS>
        fun getContext(type: Class<*>): <ERROR CLASS>
        val services: ServiceHub
      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
      class InterestRateSwapAPI
        Module Contents InterestRateSwapAPI(api: APIServer)
        val api: APIServer
        fun exitServer(): <ERROR CLASS>
        fun fetchDeal(ref: String): <ERROR CLASS>
        fun fetchDeals(): Array<State>
        fun fetchDemoDate(): LocalDate
        fun storeDeal(newDeal: State): <ERROR CLASS>
        fun storeDemoDate(newDemoDate: LocalDate): <ERROR CLASS>
      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
      class ResponseFilter
        Module Contents ResponseFilter()
        fun filter(requestContext: <ERROR CLASS>, responseContext: <ERROR CLASS>): Unit
      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
        fun selectAllDeals(): Selection
        fun selectDeal(ref: String): Selection
      data class TransactionBuildStep
        Module Contents TransactionBuildStep(generateMethodName: String, args: Map<String, Any?>)
        val args: Map<String, Any?>
        val generateMethodName: String
    package contracts
      Module Contents val CASH_PROGRAM_ID: Cash
      val CP_PROGRAM_ID: CommercialPaper
      val CROWDFUND_PROGRAM_ID: CrowdFund
      class Cash : Contract
        Module Contents Cash()
        interface Commands : CommandData
          Module Contents data class Exit : Commands
            Module Contents Exit(amount: Amount)
            val amount: Amount
          data class Issue : Commands
            Module Contents Issue(nonce: Long = SecureRandom.getInstanceStrong().nextLong())
            val nonce: Long
          class Move : TypeOnlyCommandData, Commands
            Module Contents Move()
        data class State : OwnableState
          Module Contents State(deposit: PartyReference, amount: Amount, owner: PublicKey)
          val amount: Amount
          val contract: Cash
          val deposit: PartyReference
          val owner: PublicKey
          fun toString(): String
          fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>
        fun generateIssue(tx: TransactionBuilder, amount: Amount, at: PartyReference, owner: PublicKey): Unit
        fun generateSpend(tx: TransactionBuilder, amount: Amount, to: PublicKey, cashStates: List<StateAndRef<State>>, onlyFromParties: Set<Party>? = null): List<PublicKey>
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      class CommercialPaper : Contract
        Module Contents CommercialPaper()
        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: PartyReference, owner: PublicKey, faceValue: Amount, maturityDate: Instant)
          val contract: CommercialPaper
          val faceValue: Amount
          val issuance: PartyReference
          val maturityDate: Instant
          val owner: PublicKey
          fun toString(): String
          fun withFaceValue(newFaceValue: Amount): <ERROR CLASS>
          fun withIssuance(newIssuance: PartyReference): <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: PartyReference, faceValue: Amount, maturityDate: Instant): TransactionBuilder
        fun generateMove(tx: TransactionBuilder, paper: StateAndRef<State>, newOwner: PublicKey): Unit
        fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<State>, wallet: List<StateAndRef<State>>): Unit
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      class CrowdFund : Contract
        Module Contents CrowdFund()
        data class Campaign
          Module Contents Campaign(owner: PublicKey, name: String, target: Amount, closingTime: Instant)
          val closingTime: Instant
          val name: String
          val owner: PublicKey
          val target: Amount
          fun toString(): String
        interface Commands : CommandData
          Module Contents class Close : TypeOnlyCommandData, Commands
            Module Contents Close()
          class Pledge : TypeOnlyCommandData, Commands
            Module Contents Pledge()
          class Register : TypeOnlyCommandData, Commands
            Module Contents Register()
        data class Pledge
          Module Contents Pledge(owner: PublicKey, amount: Amount)
          val amount: Amount
          val owner: PublicKey
        data class State : ContractState
          Module Contents State(campaign: Campaign, closed: Boolean = false, pledges: List<Pledge> = ArrayList())
          val campaign: Campaign
          val closed: Boolean
          val contract: CrowdFund
          val pledgedAmount: Amount
          val pledges: List<Pledge>
        fun generateClose(tx: TransactionBuilder, campaign: StateAndRef<State>, wallet: List<StateAndRef<State>>): Unit
        fun generatePledge(tx: TransactionBuilder, campaign: StateAndRef<State>, subscriber: PublicKey): Unit
        fun generateRegister(owner: PartyReference, fundingTarget: Amount, fundingName: String, closingTime: Instant): TransactionBuilder
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      val DUMMY_PROGRAM_ID: DummyContract
      interface DealState : LinearState
        Module Contents abstract fun generateAgreement(): TransactionBuilder
        abstract val parties: Array<Party>
        abstract val ref: String
        abstract fun withPublicKey(before: Party, after: PublicKey): DealState
      class DummyContract : Contract
        Module Contents DummyContract()
        interface Commands : CommandData
          Module Contents class Create : TypeOnlyCommandData, Commands
            Module Contents Create()
        class State : ContractState
          Module Contents State(magicNumber: Int = 0)
          val contract: DummyContract
          val magicNumber: Int
        fun generateInitial(owner: PartyReference, magicNumber: Int): TransactionBuilder
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      open class Event
        Module Contents Event(date: LocalDate)
        val date: LocalDate
      interface FixableDealState : DealState
        Module Contents abstract fun generateFix(ptx: TransactionBuilder, oldStateRef: StateRef, fix: Fix): Unit
        abstract fun nextFixingOf(): FixOf?
      class FixedRate : Rate
        Module Contents FixedRate(ratioUnit: RatioUnit)
        fun toString(): String
      class FixedRatePaymentEvent : RatePaymentEvent
        Module Contents FixedRatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount, rate: Rate)
        val CSVHeader: String
        val flow: Amount
        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, rate: Rate)
        val CSVHeader: String
        fun asCSV(): String
        val fixingDate: LocalDate
        val flow: Amount
        fun toString(): String
        fun withNewRate(newRate: Rate): FloatingRatePaymentEvent
      val IRS_PROGRAM_ID: InterestRateSwap
      class InsufficientBalanceException : Exception
        Module Contents InsufficientBalanceException(amountMissing: Amount)
        val amountMissing: Amount
      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: Rate): Calculation
          fun exportSchedule(): Unit
          val expression: Expression
          val fixedLegPaymentSchedule: Map<LocalDate, FixedRatePaymentEvent>
          val floatingLegPaymentSchedule: Map<LocalDate, FloatingRatePaymentEvent>
          fun getFixing(date: LocalDate): FloatingRatePaymentEvent
          fun nextFixingDate(): LocalDate?
        interface Commands : CommandData
          Module Contents class Agree : TypeOnlyCommandData, Commands
            Module Contents Agree()
          class Fix : TypeOnlyCommandData, Commands
            Module Contents Fix()
          class Mature : TypeOnlyCommandData, Commands
            Module Contents Mature()
          class Pay : TypeOnlyCommandData, Commands
            Module Contents Pay()
        data class Common
          Module Contents Common(baseCurrency: Currency, eligibleCurrency: Currency, eligibleCreditSupport: String, independentAmounts: Amount, threshold: Amount, minimumTransferAmount: Amount, rounding: Amount, 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
          val interestRate: ReferenceRate
          val localBusinessDay: BusinessCalendar
          val minimumTransferAmount: Amount
          val notificationTime: String
          val resolutionTime: String
          val rounding: Amount
          val threshold: Amount
          val tradeID: String
          val valuationDate: String
        abstract class CommonLeg
          Module Contents CommonLeg(notional: Amount, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment)
          var dayCountBasisDay: DayCountBasisDay
          var dayCountBasisYear: DayCountBasisYear
          var dayInMonth: Int
          val effectiveDate: LocalDate
          val effectiveDateAdjustment: DateRollConvention?
          open fun equals(other: Any?): Boolean
          open fun hashCode(): Int
          var interestPeriodAdjustment: AccrualAdjustment
          val notional: Amount
          var paymentCalendar: BusinessCalendar
          var paymentDelay: Int
          val paymentFrequency: Frequency
          var paymentRule: PaymentRule
          val terminationDate: LocalDate
          val terminationDateAdjustment: DateRollConvention?
          open fun toString(): String
        class FixedLeg : CommonLeg
          Module Contents FixedLeg(fixedRatePayer: Party, notional: Amount, 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)
          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, 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, fixingPeriod: DateOffset, resetRule: PaymentRule, fixingsPerPayment: Frequency, fixingCalendar: BusinessCalendar, index: String, indexSource: String, indexTenor: Tenor)
          open fun equals(other: Any?): Boolean
          var fixingCalendar: BusinessCalendar
          var fixingPeriod: DateOffset
          var fixingRollConvention: DateRollConvention
          var fixingsPerPayment: Frequency
          var floatingRatePayer: Party
          open fun hashCode(): Int
          var index: String
          var indexSource: String
          var indexTenor: Tenor
          var resetDayInMonth: Int
          var resetRule: PaymentRule
          var rollConvention: DateRollConvention
          open fun toString(): String
        data class State : FixableDealState
          Module Contents State(fixedLeg: FixedLeg, floatingLeg: FloatingLeg, calculation: Calculation, common: Common)
          val calculation: Calculation
          val common: Common
          val contract: InterestRateSwap
          fun evaluateCalculation(businessDate: LocalDate, expression: Expression = calculation.expression): Any
          val fixedLeg: FixedLeg
          val floatingLeg: FloatingLeg
          fun generateAgreement(): TransactionBuilder
          fun generateFix(ptx: TransactionBuilder, oldStateRef: StateRef, fix: Fix): Unit
          fun isRelevant(ourKeys: Set<PublicKey>): Boolean
          fun nextFixingOf(): FixOf?
          val parties: Array<Party>
          fun prettyPrint(): String
          val ref: String
          val thread: <ERROR CLASS>
          fun withPublicKey(before: Party, after: PublicKey): DealState
        fun generateAgreement(floatingLeg: FloatingLeg, fixedLeg: FixedLeg, calculation: Calculation, common: Common): TransactionBuilder
        fun generateFix(tx: TransactionBuilder, irs: StateAndRef<State>, fixing: <ERROR CLASS><LocalDate, Rate>): Unit
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      abstract class PaymentEvent : Event
        Module Contents PaymentEvent(date: LocalDate)
        abstract fun calculate(): Amount
      open class PercentageRatioUnit : RatioUnit
        Module Contents PercentageRatioUnit(percentageAsString: String)
        open fun toString(): String
      open class Rate
        Module Contents Rate(ratioUnit: RatioUnit? = null)
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val ratioUnit: RatioUnit?
      abstract class RatePaymentEvent : PaymentEvent
        Module Contents RatePaymentEvent(date: LocalDate, accrualStartDate: LocalDate, accrualEndDate: LocalDate, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, notional: Amount, rate: Rate)
        val CSVHeader: String
        val accrualEndDate: LocalDate
        val accrualStartDate: LocalDate
        open fun asCSV(): String
        open fun calculate(): Amount
        val dayCountBasisDay: DayCountBasisDay
        val dayCountBasisYear: DayCountBasisYear
        val dayCountFactor: BigDecimal
        val days: Int
        abstract val flow: Amount
        val notional: Amount
        val rate: Rate
      open class RatioUnit
        Module Contents RatioUnit(value: BigDecimal)
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        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
      kotlin.collections.Iterable
        Module Contents fun Iterable<ContractState>.sumCash(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCashBy(owner: PublicKey): <ERROR CLASS>
        fun Iterable<ContractState>.sumCashOrNull(): <ERROR CLASS>
        fun Iterable<ContractState>.sumCashOrZero(currency: Currency): <ERROR CLASS>
      operator fun Amount.times(other: RatioUnit): Amount
    package core
      Module Contents enum class AccrualAdjustment
        Module Contents Adjusted
        Unadjusted
      data class Amount : Comparable<Amount>
        Module Contents Amount(amount: BigDecimal, currency: Currency)
        Amount(pennies: Long, currency: Currency)
        fun compareTo(other: Amount): Int
        val currency: Currency
        operator fun div(other: Long): Amount
        operator fun div(other: Int): Amount
        operator fun minus(other: Amount): Amount
        val pennies: Long
        operator fun plus(other: Amount): Amount
        operator fun times(other: Long): Amount
        operator fun times(other: Int): Amount
        fun toString(): String
      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
      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: Array<out String>
        val calendars: <ERROR CLASS>
        fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = 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
        open fun hashCode(): Int
        val holidayDates: List<LocalDate>
        open fun isWorkingDay(date: LocalDate): Boolean
        fun moveBusinessDays(date: LocalDate, direction: DateRollDirection, i: Int): LocalDate
        fun parseDateFromString(it: String): LocalDate
      val CHF: Currency
      data class Command
        Module Contents Command(data: CommandData, key: PublicKey)
        Command(value: CommandData, signers: List<PublicKey>)
        val signers: List<PublicKey>
        fun toString(): String
        val value: CommandData
      interface CommandData
      interface Contract
        Module Contents abstract val legalContractReference: SecureHash
        abstract fun verify(tx: TransactionForVerification): Unit
      interface ContractState
        Module Contents abstract val contract: Contract
      enum class DateOffset
        Module Contents TWODAYS
        ZERO
      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
      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
      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
      enum class Frequency
        Module Contents Annual
          Module Contents fun offset(d: LocalDate): LocalDate
        BiWeekly
          Module Contents fun offset(d: LocalDate): LocalDate
        Monthly
          Module Contents fun offset(d: LocalDate): LocalDate
        Quarterly
          Module Contents fun offset(d: LocalDate): LocalDate
        SemiAnnual
          Module Contents fun offset(d: LocalDate): LocalDate
        Weekly
          Module Contents fun offset(d: LocalDate): LocalDate
        val annualCompoundCount: Int
        abstract fun offset(d: LocalDate): LocalDate
      val GBP: Currency
      data class LedgerTransaction : NamedByHash
        Module Contents LedgerTransaction(inputs: List<StateRef>, attachments: List<Attachment>, outputs: List<ContractState>, commands: List<AuthenticatedObject<CommandData>>, id: SecureHash)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        val outputs: List<ContractState>
      interface LinearState : ContractState
        Module Contents abstract fun isRelevant(ourKeys: Set<PublicKey>): Boolean
        abstract val thread: SecureHash
      interface NamedByHash
        Module Contents abstract val id: SecureHash
      interface OwnableState : ContractState
        Module Contents abstract val owner: PublicKey
        abstract fun withNewOwner(newOwner: PublicKey): <ERROR CLASS><CommandData, OwnableState>
      data class Party
        Module Contents Party(name: String, owningKey: PublicKey)
        val name: String
        val owningKey: PublicKey
        fun ref(bytes: OpaqueBytes): PartyReference
        fun ref(vararg bytes: Byte): PartyReference
        fun toString(): String
      data class PartyReference
        Module Contents PartyReference(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
      val RunOnCallerThread: <ERROR CLASS>
      data class SignedTransaction : NamedByHash
        Module Contents SignedTransaction(txBits: SerializedBytes<WireTransaction>, sigs: List<WithKey>)
        val id: SecureHash
        operator fun plus(sig: WithKey): SignedTransaction
        val sigs: List<WithKey>
        val tx: WireTransaction
        val txBits: SerializedBytes<WireTransaction>
        fun verify(throwIfSignaturesAreMissing: Boolean = true): Set<PublicKey>
        fun verifySignatures(): Unit
        fun withAdditionalSignature(sig: WithKey): SignedTransaction
      data class StateAndRef<out T : ContractState>
        Module Contents StateAndRef(state: T, ref: StateRef)
        val ref: StateRef
        val state: 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
      class ThreadBox<T>
        Module Contents ThreadBox(content: T, lock: Lock = ReentrantLock())
        val content: T
        val lock: Lock
        inline fun <R> locked(body: T.() -> R): R
      data class TimestampCommand : CommandData
        Module Contents TimestampCommand(time: Instant, tolerance: Duration)
        TimestampCommand(after: Instant?, before: Instant?)
        val after: Instant?
        val before: Instant?
        val midpoint: Instant
      class TransactionBuilder
        Module Contents TransactionBuilder(inputs: MutableList<StateRef> = arrayListOf(), attachments: MutableList<SecureHash> = arrayListOf(), outputs: MutableList<ContractState> = arrayListOf(), commands: MutableList<Command> = arrayListOf())
        fun addAttachment(attachment: Attachment): Unit
        fun addCommand(arg: Command): Unit
        fun addCommand(data: CommandData, vararg keys: PublicKey): <ERROR CLASS>
        fun addCommand(data: CommandData, keys: List<PublicKey>): Unit
        fun addInputState(ref: StateRef): Unit
        fun addOutputState(state: ContractState): Unit
        fun addSignatureUnchecked(sig: WithKey): Unit
        fun attachments(): List<SecureHash>
        fun checkAndAddSignature(sig: WithKey): Unit
        fun checkSignature(sig: WithKey): Unit
        fun commands(): List<Command>
        fun inputStates(): List<StateRef>
        fun outputStates(): List<ContractState>
        fun setTime(time: Instant, authenticatedBy: Party, timeTolerance: Duration): Unit
        fun signWith(key: KeyPair): Unit
        val time: TimestampCommand?
        fun timestamp(timestamper: TimestamperService, clock: Clock = Clock.systemUTC()): Unit
        fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction
        fun toWireTransaction(): WireTransaction
        fun withItems(vararg items: Any): TransactionBuilder
      class TransactionConflictException : Exception
        Module Contents TransactionConflictException(conflictRef: StateRef, tx1: LedgerTransaction, tx2: LedgerTransaction)
        val conflictRef: StateRef
        val tx1: LedgerTransaction
        val tx2: LedgerTransaction
      data class TransactionForVerification
        Module Contents TransactionForVerification(inStates: List<ContractState>, outStates: List<ContractState>, attachments: List<Attachment>, commands: List<AuthenticatedObject<CommandData>>, origHash: SecureHash)
        data class InOutGroup<T : ContractState, K : Any>
          Module Contents InOutGroup(inputs: List<T>, outputs: List<T>, groupingKey: K)
          val groupingKey: K
          val inputs: List<T>
          val outputs: List<T>
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        fun equals(other: Any?): Boolean
        fun getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun <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 inStates: List<ContractState>
        val origHash: SecureHash
        val outStates: List<ContractState>
        fun verify(): Unit
      class TransactionGraphSearch : Callable<List<WireTransaction>>
        Module Contents TransactionGraphSearch(transactions: Map<SecureHash, SignedTransaction>, startPoints: List<WireTransaction>)
        class Query
          Module Contents Query(withCommandOfType: Class<out CommandData>? = null)
          val withCommandOfType: Class<out CommandData>?
        fun call(): List<WireTransaction>
        var query: Query
        val startPoints: List<WireTransaction>
        val transactions: Map<SecureHash, SignedTransaction>
      class TransactionGroup
        Module Contents TransactionGroup(transactions: Set<LedgerTransaction>, nonVerifiedRoots: Set<LedgerTransaction>)
        val nonVerifiedRoots: Set<LedgerTransaction>
        val transactions: Set<LedgerTransaction>
        fun verify(): Set<TransactionForVerification>
      class TransactionResolutionException : Exception
        Module Contents TransactionResolutionException(hash: SecureHash)
        val hash: SecureHash
      class TransactionVerificationException : Exception
        Module Contents TransactionVerificationException(tx: TransactionForVerification, contract: Contract, cause: Throwable?)
        val contract: Contract
        val tx: TransactionForVerification
      class TransientProperty<T>
        Module Contents TransientProperty(initializer: () -> T)
        operator fun getValue(thisRef: Any?, property: KProperty<*>): T
      abstract class TypeOnlyCommandData : CommandData
        Module Contents TypeOnlyCommandData()
        open fun equals(other: Any?): Boolean
        open fun hashCode(): <ERROR CLASS>
      val USD: Currency
      data class WireTransaction : NamedByHash
        Module Contents WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<ContractState>, commands: List<Command>)
        val attachments: List<SecureHash>
        val commands: List<Command>
        fun deserialize(bits: SerializedBytes<WireTransaction>, kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
        val id: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        fun <T : ContractState> outRef(state: ContractState): StateAndRef<T>
        val outputs: List<ContractState>
        val serialized: SerializedBytes<WireTransaction>
        fun toString(): String
      fun calculateDaysBetween(startDate: LocalDate, endDate: LocalDate, dcbYear: DayCountBasisYear, dcbDay: DayCountBasisDay): Int
      fun currency(code: String): Currency
      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>
      fun ContractState.hash(): SecureHash
      java.nio.file.Path
        Module Contents fun <R> Path.use(block: (InputStream) -> R): R
      java.time.LocalDate
        Module Contents fun LocalDate.isWorkingDay(accordingToCalendar: BusinessCalendar): Boolean
      java.time.temporal.Temporal
        Module Contents infix fun Temporal.until(endExclusive: Temporal): Duration
      kotlin.Double
        Module Contents val Double.DOLLARS: Amount
        val Double.bd: BigDecimal
      kotlin.Int
        Module Contents val Int.DOLLARS: Amount
        val Int.POUNDS: Amount
        val Int.SWISS_FRANCS: Amount
        val Int.bd: BigDecimal
        val Int.days: Duration
        val Int.hours: Duration
        val Int.minutes: Duration
        val Int.seconds: Duration
      kotlin.Long
        Module Contents val Long.bd: BigDecimal
      kotlin.String
        Module Contents val String.bd: BigDecimal
      kotlin.collections.Iterable
        Module Contents fun Iterable<Amount>.sumOrNull(): Nothing?
        fun Iterable<Amount>.sumOrThrow(): <ERROR CLASS>
        fun Iterable<Amount>.sumOrZero(currency: Currency): Amount
      kotlin.collections.List
        Module Contents inline fun <reified T : ContractState> List<StateAndRef<ContractState>>.filterStatesOfType(): List<StateAndRef<T>>
        fun List<AuthenticatedObject<CommandData>>.getTimestampBy(timestampingAuthority: Party): TimestampCommand?
        fun List<AuthenticatedObject<CommandData>>.getTimestampByName(vararg names: String): TimestampCommand?
        fun <T> List<T>.indexOfOrThrow(item: T): Int
        inline fun <reified T : CommandData> List<AuthenticatedObject<CommandData>>.requireSingleCommand(): <ERROR CLASS>
        fun List<AuthenticatedObject<CommandData>>.requireSingleCommand(klass: Class<out CommandData>): <ERROR CLASS>
        inline fun <reified T : CommandData> List<AuthenticatedObject<CommandData>>.select(signer: PublicKey? = null, party: Party? = null): <ERROR CLASS>
      inline fun <T> logElapsedTime(label: String, logger: <ERROR CLASS>? = null, body: () -> T): T
      fun random63BitValue(): Long
      inline fun <R> requireThat(body: Requirements.() -> R): R
      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>
      fun WireTransaction.toLedgerTransaction(identityService: IdentityService, attachmentStorage: AttachmentStorage): LedgerTransaction
      inline fun <reified T : CommandData> verifyMoveCommands(inputs: List<OwnableState>, tx: TransactionForVerification): Unit
      fun SignedTransaction.verifyToLedgerTransaction(identityService: IdentityService, attachmentStorage: AttachmentStorage): LedgerTransaction
    package core.crypto
      Module Contents open class DigitalSignature : OpaqueBytes
        Module Contents DigitalSignature(bits: ByteArray, covering: Int = 0)
        class LegallyIdentifiable : WithKey
          Module Contents LegallyIdentifiable(signer: Party, bits: ByteArray, covering: Int)
          val signer: Party
        open class WithKey : DigitalSignature
          Module Contents WithKey(by: PublicKey, bits: ByteArray, covering: Int = 0)
          val by: PublicKey
          fun verifyWithECDSA(content: ByteArray): Unit
          fun verifyWithECDSA(content: OpaqueBytes): Unit
        val covering: Int
      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
      sealed class SecureHash : OpaqueBytes
        Module Contents class SHA256 : SecureHash
          Module Contents SHA256(bits: ByteArray)
          val signatureAlgorithmName: String
        fun parse(str: String): <ERROR CLASS>
        fun prefixChars(prefixLen: Int = 6): <ERROR CLASS>
        fun randomSHA256(): SHA256
        fun sha256(bits: ByteArray): SHA256
        fun sha256(str: String): <ERROR CLASS>
        fun sha256Twice(bits: ByteArray): SHA256
        abstract val signatureAlgorithmName: String
        open fun toString(): <ERROR CLASS>
      open class SignedData<T : Any>
        Module Contents SignedData(raw: SerializedBytes<T>, sig: WithKey)
        val raw: SerializedBytes<T>
        val sig: WithKey
        fun verified(): T
        protected open fun verifyData(data: T): Unit
      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.toStringShort(): String
        fun PublicKey.verifyWithECDSA(content: ByteArray, signature: DigitalSignature): Unit
      kotlin.ByteArray
        Module Contents fun ByteArray.sha256(): SHA256
      fun OpaqueBytes.sha256(): SHA256
    package 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 core.messaging
      Module Contents 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 topic: String
      interface MessageHandlerRegistration
      interface MessageRecipientGroup : MessageRecipients
      interface MessageRecipients
      interface MessagingService
        Module Contents abstract fun addMessageHandler(topic: String = "", executor: Executor? = null, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        abstract fun createMessage(topic: String, data: ByteArray): Message
        abstract val myAddress: SingleMessageRecipient
        abstract fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        abstract fun send(message: Message, target: MessageRecipients): Unit
        abstract fun stop(): Unit
      interface MessagingServiceBuilder<out T : MessagingService>
        Module Contents abstract fun start(): <ERROR CLASS><out T>
      interface SingleMessageRecipient : MessageRecipients
      class StackSnapshot : Throwable
        Module Contents StackSnapshot()
      class StateMachineManager
        Module Contents StateMachineManager(serviceHub: ServiceHub, executor: AffinityExecutor)
        class FiberRequest
          Module Contents FiberRequest(topic: String, destination: MessageRecipients?, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any?)
          class ExpectingResponse<R : Any> : FiberRequest
            Module Contents ExpectingResponse(topic: String, destination: MessageRecipients?, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any?, responseType: Class<R>)
            val responseType: Class<R>
          class NotExpectingResponse : FiberRequest
            Module Contents NotExpectingResponse(topic: String, destination: MessageRecipients, sessionIDForSend: Long, obj: Any?)
          val destination: MessageRecipients?
          val obj: Any?
          val sessionIDForReceive: Long
          val sessionIDForSend: Long
          val stackTraceInCaseOfProblems: StackSnapshot
          val topic: String
        inner class FiberScheduler
          Module Contents FiberScheduler()
        fun <T> add(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
        val executor: AffinityExecutor
        fun <T> findStateMachines(klass: Class<out ProtocolLogic<T>>): List<<ERROR CLASS><ProtocolLogic<T>, <ERROR CLASS><T>>>
        val scheduler: FiberScheduler
        val serviceHub: ServiceHub
      object TopicStringValidator
        Module Contents fun check(tag: String): <ERROR CLASS>
      fun MessagingService.runOnNextMessage(topic: String = "", executor: Executor? = null, callback: (Message) -> Unit): Unit
      fun MessagingService.send(topic: String, obj: Any, to: MessageRecipients): Unit
    package core.node
      Module Contents abstract class AbstractNode
        Module Contents AbstractNode(dir: Path, configuration: NodeConfiguration, initialNetworkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, platformClock: Clock)
        val PRIVATE_KEY_FILE_NAME: String
        val PUBLIC_IDENTITY_FILE_NAME: String
        protected val _servicesThatAcceptUploads: ArrayList<AcceptsFileUpload>
        val advertisedServices: Set<ServiceType>
        lateinit var api: APIServer
        val configuration: NodeConfiguration
        protected open fun constructStorageService(attachments: NodeAttachmentService, keypair: KeyPair, identity: Party): StorageServiceImpl
        val dir: Path
        protected open fun findMyLocation(): PhysicalLocation?
        lateinit var identity: IdentityService
        var inNodeNetworkMapService: NetworkMapService?
        var inNodeTimestampingService: NodeTimestamperService?
        val info: NodeInfo
        val initialNetworkMapAddress: NodeInfo?
        protected open fun initialiseStorageService(dir: Path): StorageService
        lateinit var interestRatesService: Service
        lateinit var keyManagement: E2ETestKeyManagementService
        protected abstract val log: <ERROR CLASS>
        protected open fun makeIdentityService(): IdentityService
        protected open fun makeInterestRatesOracleService(): Unit
        protected abstract fun makeMessagingService(): MessagingService
        protected open fun makeNetworkMapService(): Unit
        protected open fun makeTimestampingService(): Unit
        lateinit var net: MessagingService
        var networkMapSeq: Long
        val networkMapServiceCallTimeout: Duration
        val platformClock: Clock
        protected abstract val serverThread: AffinityExecutor
        val services: ServiceHub
        val servicesThatAcceptUploads: List<AcceptsFileUpload>
        lateinit var smm: StateMachineManager
        open fun start(): AbstractNode
        protected abstract fun startMessagingService(): Unit
        open fun stop(): Unit
        lateinit var storage: StorageService
        lateinit var wallet: WalletService
      interface AcceptsFileUpload
        Module Contents abstract val acceptableFileExtensions: List<String>
        abstract val dataTypePrefix: String
        abstract fun upload(data: InputStream): String
      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?
      class ConfigurationException : Exception
        Module Contents ConfigurationException(message: String)
      class Node : AbstractNode
        Module Contents Node(dir: Path, p2pAddr: <ERROR CLASS>, configuration: NodeConfiguration, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, clock: Clock = Clock.systemUTC())
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingService
        val p2pAddr: <ERROR CLASS>
        protected val serverThread: ServiceAffinityExecutor
        fun start(): Node
        protected fun startMessagingService(): Unit
        fun stop(): Unit
        lateinit var webServer: <ERROR CLASS>
      interface NodeConfiguration
        Module Contents abstract val exportJMXto: String
        abstract val myLegalName: String
        abstract val nearestCity: String
      class NodeConfigurationFromConfig : NodeConfiguration
        Module Contents NodeConfigurationFromConfig(config: <ERROR CLASS> = ConfigFactory.load())
        val config: <ERROR CLASS>
        val exportJMXto: String
        val myLegalName: String
        val nearestCity: 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?
      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 val keyManagementService: KeyManagementService
        abstract val monitoringService: MonitoringService
        abstract val networkMapCache: NetworkMapCache
        abstract val networkService: MessagingService
        open fun recordTransactions(txs: List<SignedTransaction>, skipRecordingMap: Boolean = false): Unit
        abstract val storageService: StorageService
        open fun verifyTransaction(ltx: LedgerTransaction): Unit
        abstract val walletService: WalletService
      data class WorldCoordinate
        Module Contents WorldCoordinate(latitude: Double, longitude: Double)
        val latitude: Double
        val longitude: Double
        fun project(screenWidth: Double, screenHeight: Double, topLatitude: Double, bottomLatitude: Double, leftLongitude: Double, rightLongitude: Double): <ERROR CLASS><Double, Double>
      operator fun <ERROR CLASS>.getValue(receiver: NodeConfigurationFromConfig, metadata: KProperty<*>): <ERROR CLASS>
    package core.node.services
      Module Contents abstract class AbstractNodeService
        Module Contents AbstractNodeService(net: MessagingService)
        protected inline fun <reified Q : AbstractRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R, crossinline exceptionConsumer: (Message, Exception) -> Unit): Unit
        protected inline fun <reified Q : AbstractRequestMessage, reified R : Any> addMessageHandler(topic: String, crossinline handler: (Q) -> R): Unit
        val net: MessagingService
      interface AttachmentStorage
        Module Contents abstract fun importAttachment(jar: InputStream): SecureHash
        abstract fun openAttachment(id: SecureHash): Attachment?
      object DummyTimestampingAuthority
        Module Contents val identity: Party
        val key: KeyPair
      interface IdentityService
        Module Contents abstract fun partyFromKey(key: PublicKey): Party?
        abstract fun partyFromName(name: String): Party?
        abstract fun registerIdentity(party: Party): Unit
      class InMemoryNetworkMapService : NetworkMapService, AbstractNodeService
        Module Contents InMemoryNetworkMapService(net: MessagingService, home: NodeRegistration, cache: NetworkMapCache)
        val cache: NetworkMapCache
        fun getUnacknowledgedCount(subscriber: SingleMessageRecipient): Int?
        val maxSizeRegistrationRequestBytes: Int
        val maxUnacknowledgedUpdates: Int
        val nodes: List<NodeInfo>
        fun notifySubscribers(wireReg: WireNodeRegistration): Unit
        fun processAcknowledge(req: UpdateAcknowledge): Unit
        fun processFetchAllRequest(req: FetchMapRequest): FetchMapResponse
        fun processQueryRequest(req: QueryIdentityRequest): QueryIdentityResponse
        fun processRegistrationChangeRequest(req: RegistrationRequest): RegistrationResponse
        fun processSubscriptionRequest(req: SubscribeRequest): SubscribeResponse
      interface NetworkMapService
        Module Contents val DEFAULT_EXPIRATION_PERIOD: Period
        val FETCH_PROTOCOL_TOPIC: String
        class FetchMapRequest : AbstractRequestMessage
          Module Contents FetchMapRequest(subscribe: Boolean, ifChangedSinceVersion: Int?, replyTo: MessageRecipients, sessionID: Long)
          val ifChangedSinceVersion: Int?
          val subscribe: Boolean
        data class FetchMapResponse
          Module Contents FetchMapResponse(nodes: Collection<NodeRegistration>?, version: Int)
          val nodes: Collection<NodeRegistration>?
          val version: Int
        val PUSH_ACK_PROTOCOL_TOPIC: String
        val PUSH_PROTOCOL_TOPIC: String
        val QUERY_PROTOCOL_TOPIC: String
        class QueryIdentityRequest : AbstractRequestMessage
          Module Contents QueryIdentityRequest(identity: Party, replyTo: MessageRecipients, sessionID: Long)
          val identity: Party
        data class QueryIdentityResponse
          Module Contents QueryIdentityResponse(node: NodeInfo?)
          val node: NodeInfo?
        val REGISTER_PROTOCOL_TOPIC: String
        class RegistrationRequest : AbstractRequestMessage
          Module Contents RegistrationRequest(wireReg: WireNodeRegistration, replyTo: MessageRecipients, sessionID: Long)
          val wireReg: WireNodeRegistration
        data class RegistrationResponse
          Module Contents RegistrationResponse(success: Boolean)
          val success: Boolean
        val SUBSCRIPTION_PROTOCOL_TOPIC: String
        class SubscribeRequest : AbstractRequestMessage
          Module Contents SubscribeRequest(subscribe: Boolean, replyTo: MessageRecipients, sessionID: Long)
          val subscribe: Boolean
        data class SubscribeResponse
          Module Contents SubscribeResponse(confirmed: Boolean)
          val confirmed: Boolean
        object Type : ServiceType
        data class Update
          Module Contents Update(wireReg: WireNodeRegistration, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireReg: WireNodeRegistration
        data class UpdateAcknowledge
          Module Contents UpdateAcknowledge(wireRegHash: SecureHash, replyTo: MessageRecipients)
          val replyTo: MessageRecipients
          val wireRegHash: SecureHash
        val logger: <ERROR CLASS>
        abstract val nodes: List<NodeInfo>
      class 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
        val metrics: <ERROR CLASS>
        fun openAttachment(id: SecureHash): Attachment?
        val storePath: Path
        fun upload(data: InputStream): <ERROR CLASS>
      object NodeInterestRates
        Module Contents class FixContainer
          Module Contents FixContainer(fixes: List<Fix>, factory: InterpolatorFactory = CubicSplineInterpolator.Factory)
          val factory: InterpolatorFactory
          val fixes: List<Fix>
          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 inputRates: Map<Tenor, BigDecimal>
          val size: Int
        class Oracle
          Module Contents Oracle(identity: Party, signingKey: KeyPair)
          val identity: Party
          var knownFixes: FixContainer
          fun query(queries: List<FixOf>): List<Fix>
          fun sign(wtx: WireTransaction): LegallyIdentifiable
        class Service : AcceptsFileUpload, AbstractNodeService
          Module Contents Service(node: AbstractNode)
          val acceptableFileExtensions: <ERROR CLASS>
          val dataTypePrefix: String
          val oracle: Oracle
          val ss: StorageService
          fun upload(data: InputStream): String
        object Type : ServiceType
        class UnknownFix : Exception
          Module Contents UnknownFix(fix: FixOf)
          val fix: FixOf
          fun toString(): String
        fun parseFile(s: String): FixContainer
        fun parseFix(s: String): Fix
        fun parseFixOf(key: String): FixOf
      sealed class NodeMapError : Exception
        Module Contents class InvalidSignature : NodeMapError
          Module Contents InvalidSignature()
        class InvalidSubscriber : NodeMapError
          Module Contents InvalidSubscriber()
        class UnknownChangeType : NodeMapError
          Module Contents UnknownChangeType()
      class NodeRegistration
        Module Contents NodeRegistration(node: NodeInfo, serial: Long, type: AddOrRemove, expires: Instant)
        var expires: Instant
        val node: NodeInfo
        val serial: Long
        fun toString(): String
        fun toWire(privateKey: PrivateKey): WireNodeRegistration
        val type: AddOrRemove
      class NodeTimestamperService : AbstractNodeService
        Module Contents NodeTimestamperService(net: MessagingService, identity: Party, signingKey: KeyPair, clock: Clock = Clock.systemDefaultZone(), tolerance: Duration = 30.seconds)
        val TIMESTAMPING_PROTOCOL_TOPIC: String
        val clock: Clock
        val identity: Party
        fun processRequest(req: Request): LegallyIdentifiable
        val signingKey: KeyPair
        val tolerance: Duration
      interface RegulatorService
        Module Contents object Type : ServiceType
      abstract class ServiceType
        Module Contents ServiceType(id: String)
        open operator fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        val id: String
        open fun toString(): String
      interface TimestamperService
        Module Contents object Type : ServiceType
        abstract val identity: Party
        abstract fun timestamp(wtxBytes: SerializedBytes<WireTransaction>): LegallyIdentifiable
      sealed class TimestampingError : Exception
        Module Contents class NotForMe : TimestampingError
          Module Contents NotForMe()
        class NotOnTimeException : TimestampingError
          Module Contents NotOnTimeException()
        class RequiresExactlyOneCommand : TimestampingError
          Module Contents RequiresExactlyOneCommand()
      class WireNodeRegistration : SignedData<NodeRegistration>
        Module Contents WireNodeRegistration(raw: SerializedBytes<NodeRegistration>, sig: WithKey)
        protected fun verifyData(reg: NodeRegistration): Unit
    package core.node.servlets
      Module Contents class AttachmentDownloadServlet
        Module Contents AttachmentDownloadServlet()
        fun doGet(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
      class DataUploadServlet
        Module Contents DataUploadServlet()
        fun doPost(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
    package core.node.subsystems
      Module Contents class ArtemisMessagingService : MessagingService
        Module Contents ArtemisMessagingService(directory: Path, myHostPort: <ERROR CLASS>, defaultExecutor: Executor = RunOnCallerThread)
        inner class Handler : MessageHandlerRegistration
          Module Contents Handler(executor: Executor?, topic: String, callback: (Message, MessageHandlerRegistration) -> Unit)
          val callback: (Message, MessageHandlerRegistration) -> Unit
          val executor: Executor?
          val topic: String
        val TOPIC_PROPERTY: String
        fun addMessageHandler(topic: String, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
        fun createMessage(topic: String, data: ByteArray): Message
        val defaultExecutor: Executor
        val directory: Path
        val log: <ERROR CLASS>
        fun makeRecipient(hostAndPort: <ERROR CLASS>): SingleMessageRecipient
        fun makeRecipient(hostname: String): <ERROR CLASS>
        val myAddress: SingleMessageRecipient
        val myHostPort: <ERROR CLASS>
        fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
        fun send(message: Message, target: MessageRecipients): Unit
        fun start(): Unit
        fun stop(): Unit
        fun toHostAndPort(hostname: String): <ERROR CLASS>
      class DataVendingService : AbstractNodeService
        Module Contents DataVendingService(net: MessagingService, storage: StorageService)
        class Request : AbstractRequestMessage
          Module Contents Request(hashes: List<SecureHash>, replyTo: SingleMessageRecipient, sessionID: Long)
          val hashes: List<SecureHash>
        val logger: <ERROR CLASS>
      class E2ETestKeyManagementService : KeyManagementService
        Module Contents E2ETestKeyManagementService()
        fun freshKey(): KeyPair
        val keys: Map<PublicKey, PrivateKey>
      class InMemoryIdentityService : IdentityService
        Module Contents InMemoryIdentityService()
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
      open class InMemoryNetworkMapCache : NetworkMapCache
        Module Contents InMemoryNetworkMapCache()
        open fun addMapService(smm: StateMachineManager, net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int?): <ERROR CLASS><Unit>
        open fun addNode(node: NodeInfo): Unit
        open fun deregisterForUpdates(smm: StateMachineManager, net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        open fun get(): <ERROR CLASS>
        open fun get(serviceType: ServiceType): <ERROR CLASS>
        open fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        open val networkMapNodes: List<NodeInfo>
        open val partyNodes: List<NodeInfo>
        fun processUpdatePush(req: Update): Unit
        open val ratesOracleNodes: List<NodeInfo>
        protected var registeredNodes: MutableMap<Party, NodeInfo>
        open val regulators: List<NodeInfo>
        open fun removeNode(node: NodeInfo): Unit
        open val timestampingNodes: List<NodeInfo>
      interface KeyManagementService
        Module Contents abstract fun freshKey(): KeyPair
        abstract val keys: Map<PublicKey, PrivateKey>
        open fun toPrivate(publicKey: PublicKey): PrivateKey
      class MonitoringService
        Module Contents MonitoringService(metrics: <ERROR CLASS>)
        val metrics: <ERROR CLASS>
      sealed class NetworkCacheError : Exception
        Module Contents class DeregistrationFailed : NetworkCacheError
          Module Contents DeregistrationFailed()
      interface NetworkMapCache
        Module Contents abstract fun addMapService(smm: StateMachineManager, net: MessagingService, service: NodeInfo, subscribe: Boolean, ifChangedSinceVer: Int? = null): <ERROR CLASS><Unit>
        abstract fun addNode(node: NodeInfo): Unit
        abstract fun deregisterForUpdates(smm: StateMachineManager, net: MessagingService, service: NodeInfo): <ERROR CLASS><Unit>
        abstract fun get(): Collection<NodeInfo>
        abstract fun get(serviceType: ServiceType): Collection<NodeInfo>
        abstract fun getRecommended(type: ServiceType, contract: Contract, vararg party: Party): NodeInfo?
        val logger: <ERROR CLASS>
        abstract val networkMapNodes: List<NodeInfo>
        open fun nodeForPartyName(name: String): NodeInfo?
        abstract val partyNodes: List<NodeInfo>
        abstract val ratesOracleNodes: List<NodeInfo>
        abstract val regulators: List<NodeInfo>
        abstract fun removeNode(node: NodeInfo): Unit
        abstract val timestampingNodes: List<NodeInfo>
      class NodeWalletService : WalletService
        Module Contents NodeWalletService(services: ServiceHub)
        val cashBalances: Map<Currency, Amount>
        val currentWallet: Wallet
        fun fillWithSomeTestCash(howMuch: Amount, atLeastThisManyStates: Int = 3, atMostThisManyStates: Int = 10, rng: Random = Random()): Unit
        val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        fun notifyAll(txns: Iterable<WireTransaction>): Wallet
      interface StorageService
        Module Contents abstract val attachments: AttachmentStorage
        abstract val myLegalIdentity: Party
        abstract val myLegalIdentityKey: KeyPair
        abstract val stateMachines: MutableMap<SecureHash, ByteArray>
        abstract val validatedTransactions: MutableMap<SecureHash, SignedTransaction>
      open class StorageServiceImpl : StorageService
        Module Contents StorageServiceImpl(attachments: AttachmentStorage, keypair: KeyPair, identity: Party = Party("Unit test party", keypair.public), recordingAs: (String) -> String = { tableName -> "" })
        open val attachments: AttachmentStorage
        open val myLegalIdentity: Party
        open val myLegalIdentityKey: KeyPair
        val recordingAs: (String) -> String
        open val stateMachines: MutableMap<SecureHash, ByteArray>
        protected val tables: HashMap<String, MutableMap<*, *>>
        open val validatedTransactions: MutableMap<SecureHash, SignedTransaction>
      val TOPIC_DEFAULT_POSTFIX: String
      data class Wallet
        Module Contents Wallet(states: List<StateAndRef<ContractState>>)
        val cashBalances: Map<Currency, Amount>
        val states: List<StateAndRef<ContractState>>
        inline fun <reified T : OwnableState> statesOfType(): List<StateAndRef<T>>
      interface WalletService
        Module Contents abstract val cashBalances: Map<Currency, Amount>
        abstract val currentWallet: Wallet
        abstract val linearHeads: Map<SecureHash, StateAndRef<LinearState>>
        open fun <T : LinearState> linearHeadsOfType_(stateType: Class<T>): Map<SecureHash, StateAndRef<T>>
        open fun notify(tx: WireTransaction): Wallet
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Wallet
        open fun statesForRefs(refs: List<StateRef>): Map<StateRef, ContractState?>
      inline fun <reified T : LinearState> WalletService.linearHeadsOfType(): <ERROR CLASS>
    package core.protocols
      Module Contents abstract class ProtocolLogic<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(topic: String, sessionIDForReceive: Long): UntrustworthyData<T>
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, clazz: Class<T>): UntrustworthyData<T>
        fun send(topic: String, destination: MessageRecipients, sessionID: Long, obj: Any): Unit
        inline fun <reified T : Any> sendAndReceive(topic: String, destination: MessageRecipients, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any): UntrustworthyData<T>
        val serviceHub: ServiceHub
        fun <R> subProtocol(subLogic: ProtocolLogic<R>): R
      class ProtocolStateMachine<R>
        Module Contents ProtocolStateMachine(logic: ProtocolLogic<R>, scheduler: <ERROR CLASS>)
        lateinit var logger: <ERROR CLASS>
        val logic: ProtocolLogic<R>
        fun prepareForResumeWith(serviceHub: ServiceHub, withObject: Any?, logger: <ERROR CLASS>, suspendFunc: (FiberRequest, ByteArray) -> Unit): Unit
        fun <T : Any> receive(topic: String, sessionIDForReceive: Long, recvType: Class<T>): UntrustworthyData<T>
        val resultFuture: <ERROR CLASS><R>
        fun run(): R
        fun send(topic: String, destination: MessageRecipients, sessionID: Long, obj: Any): Unit
        fun <T : Any> sendAndReceive(topic: String, destination: MessageRecipients, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any, recvType: Class<T>): UntrustworthyData<T>
        lateinit var serviceHub: ServiceHub
    package core.serialization
      Module Contents val ATTACHMENT_STORAGE: 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 MissingAttachmentsException : Exception
        Module Contents MissingAttachmentsException(ids: List<SecureHash>)
        val ids: List<SecureHash>
      open class OpaqueBytes
        Module Contents OpaqueBytes(bits: ByteArray)
        val bits: ByteArray
        open fun equals(other: Any?): Boolean
        open fun hashCode(): Int
        fun of(vararg b: Byte): OpaqueBytes
        val size: Int
        open fun toString(): String
      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
      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
      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
    package core.testing
      Module Contents class IRSSimulation : Simulation
        Module Contents IRSSimulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        fun iterate(): Unit
        val om: <ERROR CLASS>
        fun start(): Unit
      class InMemoryMessagingNetwork
        Module Contents InMemoryMessagingNetwork()
        inner class Builder : MessagingServiceBuilder<InMemoryMessaging>
          Module Contents Builder(manuallyPumped: Boolean, id: Handle)
          val id: Handle
          val manuallyPumped: Boolean
          fun start(): <ERROR CLASS><InMemoryMessaging>
        class Handle : SingleMessageRecipient
          Module Contents Handle(id: Int)
          fun equals(other: Any?): Boolean
          fun hashCode(): Int
          val id: Int
          fun toString(): String
        inner class InMemoryMessaging : MessagingService
          Module Contents InMemoryMessaging(manuallyPumped: Boolean, handle: Handle)
          inner class Handler : MessageHandlerRegistration
            Module Contents Handler(executor: Executor?, topic: String, callback: (Message, MessageHandlerRegistration) -> Unit)
            val callback: (Message, MessageHandlerRegistration) -> Unit
            val executor: Executor?
            val topic: String
          protected inner class InnerState
            Module Contents InnerState()
            val handlers: MutableList<Handler>
            val pendingRedelivery: LinkedList<Message>
          fun addMessageHandler(topic: String, executor: Executor?, callback: (Message, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
          protected val backgroundThread: Nothing?
          fun createMessage(topic: String, data: ByteArray): Message
          val myAddress: SingleMessageRecipient
          fun pump(block: Boolean): Boolean
          fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
          protected var running: Boolean
          fun send(message: Message, target: MessageRecipients): Unit
          protected val state: ThreadBox<InnerState>
          fun stop(): Unit
        interface LatencyCalculator
          Module Contents abstract fun between(sender: SingleMessageRecipient, receiver: SingleMessageRecipient): Duration
        val allMessages: <ERROR CLASS><<ERROR CLASS><SingleMessageRecipient, Message, MessageRecipients>>
        fun createNode(manuallyPumped: Boolean): <ERROR CLASS><Handle, MessagingServiceBuilder<InMemoryMessaging>>
        fun createNodeWithID(manuallyPumped: Boolean, id: Int): MessagingServiceBuilder<InMemoryMessaging>
        val endpoints: List<InMemoryMessaging>
        val everyoneOnline: AllPossibleRecipients
        var latencyCalculator: LatencyCalculator?
        fun setupTimestampingNode(manuallyPumped: Boolean): <ERROR CLASS><NodeInfo, InMemoryMessaging>
        fun stop(): Unit
      class MockIdentityService : IdentityService
        Module Contents MockIdentityService(identities: List<Party>)
        val identities: List<Party>
        fun partyFromKey(key: PublicKey): Party?
        fun partyFromName(name: String): Party?
        fun registerIdentity(party: Party): Unit
      class MockNetwork
        Module Contents MockNetwork(threadPerNode: Boolean = false, defaultFactory: Factory = MockNetwork.DefaultFactory)
        object DefaultFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        interface Factory
          Module Contents abstract fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        class MockNode : AbstractNode
          Module Contents MockNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int)
          protected open fun findMyLocation(): PhysicalLocation?
          val id: Int
          protected open val log: <ERROR CLASS>
          protected open fun makeIdentityService(): MockIdentityService
          protected open fun makeMessagingService(): MessagingService
          val mockNet: MockNetwork
          val place: PhysicalLocation
          protected open val serverThread: AffinityExecutor
          open fun start(): MockNode
          protected open fun startMessagingService(): Unit
        fun addressToNode(address: SingleMessageRecipient): MockNode
        fun createNode(networkMapAddress: NodeInfo? = null, forcedID: Int = -1, nodeFactory: Factory = defaultFactory, vararg advertisedServices: ServiceType): MockNode
        fun createTwoNodes(nodeFactory: Factory = defaultFactory): <ERROR CLASS><MockNode, MockNode>
        val filesystem: <ERROR CLASS>
        val identities: ArrayList<Party>
        val messagingNetwork: InMemoryMessagingNetwork
        val nodes: List<MockNode>
        fun runNetwork(rounds: Int = -1): Unit
      class MockNetworkMapCache : InMemoryNetworkMapCache
        Module Contents MockNetworkMapCache()
        data class MockAddress : SingleMessageRecipient
          Module Contents MockAddress(id: String)
          val id: String
        fun addRegistration(node: NodeInfo): Unit
        fun deleteRegistration(identity: Party): Boolean
      abstract class Simulation
        Module Contents Simulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        inner class BankFactory : Factory
          Module Contents BankFactory()
          var counter: Int
          fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
          fun createAll(): List<SimulatedNode>
        object NetworkMapNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        object RatesOracleFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        object RegulatorFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        open class SimulatedNode : MockNode
          Module Contents SimulatedNode(dir: Path, config: NodeConfiguration, mockNet: MockNetwork, networkMapAddress: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int)
          protected open fun findMyLocation(): PhysicalLocation?
        object TimestampingNodeFactory : Factory
          Module Contents fun create(dir: Path, config: NodeConfiguration, network: MockNetwork, networkMapAddr: NodeInfo?, advertisedServices: Set<ServiceType>, id: Int): MockNode
        val allProtocolSteps: <ERROR CLASS><<ERROR CLASS><SimulatedNode, Change>>
        val bankFactory: BankFactory
        val bankLocations: <ERROR CLASS>
        val banks: List<SimulatedNode>
        var currentDay: LocalDate
        val dateChanges: <ERROR CLASS><LocalDate>
        val doneSteps: <ERROR CLASS><Collection<SimulatedNode>>
        val extraNodeLabels: MutableMap<SimulatedNode, String>
        open fun iterate(): Unit
        val latencyInjector: LatencyCalculator?
        protected fun linkConsensus(nodes: Collection<SimulatedNode>, protocol: ProtocolLogic<*>): Unit
        protected fun linkProtocolProgress(node: SimulatedNode, protocol: ProtocolLogic<*>): Unit
        val network: MockNetwork
        val networkMap: SimulatedNode
        val ratesOracle: SimulatedNode
        val regulators: List<SimulatedNode>
        val runAsync: Boolean
        val serviceProviders: List<SimulatedNode>
        open fun start(): Unit
        fun startTradingCircle(tradeBetween: (Int, Int) -> <ERROR CLASS><out <ERROR CLASS>>): Unit
        fun stop(): Unit
        val timestamper: SimulatedNode
      class TradeSimulation : Simulation
        Module Contents TradeSimulation(runAsync: Boolean, latencyInjector: LatencyCalculator?)
        fun start(): Unit
    package core.utilities
      Module Contents object ANSIProgressRenderer
        Module Contents var progressTracker: ProgressTracker?
      enum class AddOrRemove
        Module Contents ADD
        REMOVE
      interface AffinityExecutor : Executor
        Module Contents class Gate : AffinityExecutor
          Module Contents Gate(alwaysQueue: Boolean = false)
          fun execute(command: Runnable): Unit
          val isOnThread: Boolean
          val taskQueueSize: Int
          fun waitAndRun(): Unit
        val SAME_THREAD: AffinityExecutor
        class ServiceAffinityExecutor : AffinityExecutor, ThreadPoolExecutor
          Module Contents ServiceAffinityExecutor(threadName: String, numThreads: Int)
          protected fun afterExecute(r: Runnable, t: Throwable?): Unit
          val isOnThread: Boolean
          val logger: <ERROR CLASS>
          protected val threads: MutableSet<Thread>
        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 BriefLogFormatter : Formatter
        Module Contents BriefLogFormatter()
        fun format(logRecord: LogRecord): String
        fun init(): Unit
        fun initVerbose(vararg loggerNames: String): Unit
        fun loggingOff(vararg names: String): Unit
        fun loggingOff(vararg classes: KClass<*>): Unit
        fun loggingOn(vararg names: String): Unit
        fun loggingOn(vararg classes: KClass<*>): Unit
      object Emoji
        Module Contents const val CODE_BAG_OF_CASH: String
        const val CODE_DIAMOND: String
        const val CODE_GREEN_TICK: String
        const val CODE_LEFT_ARROW: String
        const val CODE_NEWSPAPER: String
        const val CODE_PAPERCLIP: String
        const val CODE_RIGHT_ARROW: String
        val bagOfCash: String
        val diamond: String
        val hasEmojiTerminal: <ERROR CLASS>
        val leftArrow: String
        val newspaper: String
        val paperclip: String
        fun renderIfSupported(obj: Any): String
        val rightArrow: String
      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
        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>
      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 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 childrenFor: HashMap<Step, ProgressTracker>
        var currentStep: Step
        val currentStepRecursive: Step
        fun nextStep(): Step
        var parent: ProgressTracker?
        var stepIndex: Int
        val steps: Array<Step>
        val topLevelTracker: ProgressTracker
      class RecordingMap<K, V> : MutableMap<K, V>
        Module Contents RecordingMap(wrappedMap: MutableMap<K, V>, logger: <ERROR CLASS> = loggerFor<RecordingMap<K, V>>())
        data class Get<K> : Record
          Module Contents Get(key: K)
          val key: K
        data class Put<K, V> : Record
          Module Contents Put(key: K, value: V)
          val key: K
          val value: V
        interface Record
        fun clearRecords(): Unit
        fun get(key: K): V?
        fun put(key: K, value: V): V?
        fun putAll(from: Map<out K, V>): Unit
        fun putAllUnrecorded(from: Map<out K, V>): Unit
        val records: List<Record>
      class UntrustworthyData<T>
        Module Contents UntrustworthyData(fromUntrustedWorld: T)
        val data: T
        inline fun <R> validate(validator: (T) -> R): R
      inline fun <reified T : Any> loggerFor(): <ERROR CLASS>
      inline fun <ERROR CLASS>.trace(msg: () -> String): Unit
    package demos
      Module Contents class DemoClock : Clock
        Module Contents DemoClock(delegateClock: Clock = Clock.systemUTC())
        fun getZone(): ZoneId
        fun instant(): Instant
        fun updateDate(date: LocalDate): Boolean
        fun withZone(zone: ZoneId): Clock
      class TraderDemoProtocolBuyer : ProtocolLogic<Unit>
        Module Contents TraderDemoProtocolBuyer(attachmentsPath: Path)
        object STARTING_BUY : Step
        object WAITING_FOR_SELLER_TO_CONNECT : Step
        fun call(): Unit
        val progressTracker: ProgressTracker
      class TraderDemoProtocolSeller : ProtocolLogic<Unit>
        Module Contents TraderDemoProtocolSeller(myAddress: <ERROR CLASS>, otherSide: SingleMessageRecipient, progressTracker: ProgressTracker = TraderDemoProtocolSeller.tracker())
        object ANNOUNCING : Step
        val PROSPECTUS_HASH: <ERROR CLASS>
        object SELF_ISSUING : Step
        object TRADING : Step
        fun call(): Unit
        val myAddress: <ERROR CLASS>
        val otherSide: SingleMessageRecipient
        val progressTracker: ProgressTracker
        fun selfIssueSomeCommercialPaper(ownedBy: PublicKey, tsa: NodeInfo): StateAndRef<State>
        fun tracker(): <ERROR CLASS>
      fun main(args: Array<String>): Unit
      fun main(args: Array<String>): Unit
      fun main(args: Array<String>): Unit
      fun nodeInfo(hostAndPortString: String, identityFile: String, advertisedServices: Set<ServiceType> = emptySet()): NodeInfo
    package demos.protocols
      Module Contents object AutoOfferProtocol
        Module Contents data class AutoOfferMessage
          Module Contents AutoOfferMessage(otherSide: SingleMessageRecipient, otherSessionID: Long, dealBeingOffered: DealState)
          val dealBeingOffered: DealState
          val otherSessionID: Long
          val otherSide: SingleMessageRecipient
        object Handler
          Module Contents 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
          object RECEIVED : Step
          fun register(node: Node): Unit
          fun tracker(): <ERROR CLASS>
        class Requester<T> : ProtocolLogic<SignedTransaction>
          Module Contents Requester(dealToBeOffered: DealState)
          object ANNOUNCING : Step
          object DEALING : Step
          object RECEIVED : Step
          fun call(): SignedTransaction
          val dealToBeOffered: DealState
          fun notUs(vararg parties: Party): List<Party>
          val progressTracker: <ERROR CLASS>
          fun tracker(): <ERROR CLASS>
        val TOPIC: String
      object ExitServerProtocol
        Module Contents class Broadcast : ProtocolLogic<Boolean>
          Module Contents Broadcast(exitCode: Integer)
          fun call(): Boolean
          val exitCode: Integer
        data class ExitMessage
          Module Contents ExitMessage(exitCode: Int)
          val exitCode: Int
        object Handler
          Module Contents fun register(node: Node): Unit
        val TOPIC: String
      object UpdateBusinessDayProtocol
        Module Contents class Broadcast : ProtocolLogic<Boolean>
          Module Contents Broadcast(date: LocalDate, progressTracker: ProgressTracker = Broadcast.tracker())
          object LOCAL : Step
          object NOTIFYING : Step
          fun call(): Boolean
          val date: LocalDate
          val progressTracker: ProgressTracker
          fun tracker(): <ERROR CLASS>
        object Handler
          Module Contents fun register(node: Node): Unit
        val TOPIC: String
        data class UpdateBusinessDayMessage
          Module Contents UpdateBusinessDayMessage(date: LocalDate, sessionID: Long)
          val date: LocalDate
          val sessionID: Long
        class Updater : ProtocolLogic<Boolean>
          Module Contents Updater(date: LocalDate, sessionID: Long, progressTracker: ProgressTracker = Updater.tracker())
          object FETCHING : Step
          object FIXING : Step
          object ITERATING_DEALS : Step
          object ITERATING_FIXINGS : Step
          fun call(): Boolean
          val date: LocalDate
          fun otherParty(deal: DealState): NodeInfo
          fun processDeal(party: NodeInfo, deal: StateAndRef<DealState>, date: LocalDate, sessionID: Long): Unit
          fun processInterestRateSwap(party: NodeInfo, deal: StateAndRef<State>, date: LocalDate, sessionID: Long): Unit
          val progressTracker: ProgressTracker
          val sessionID: Long
          fun tracker(): ProgressTracker
    package protocols
      Module Contents abstract class AbstractRequestMessage
        Module Contents AbstractRequestMessage(replyTo: MessageRecipients, sessionID: Long?)
        val replyTo: MessageRecipients
        val sessionID: Long?
      class FetchAttachmentsProtocol : FetchDataProtocol<Attachment, ByteArray>
        Module Contents FetchAttachmentsProtocol(requests: Set<SecureHash>, otherSide: SingleMessageRecipient)
        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 queryTopic: String
      abstract class FetchDataProtocol<T : NamedByHash, W : Any> : ProtocolLogic<Result<T>>
        Module Contents FetchDataProtocol(requests: Set<SecureHash>, otherSide: SingleMessageRecipient)
        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 Result<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: SingleMessageRecipient
        protected abstract val queryTopic: String
        protected val requests: Set<SecureHash>
      class FetchTransactionsProtocol : FetchDataProtocol<SignedTransaction, SignedTransaction>
        Module Contents FetchTransactionsProtocol(requests: Set<SecureHash>, otherSide: SingleMessageRecipient)
        const val TOPIC: String
        protected fun load(txid: SecureHash): SignedTransaction?
        protected val queryTopic: String
      open class RatesFixProtocol : ProtocolLogic<Unit>
        Module Contents RatesFixProtocol(tx: TransactionBuilder, oracle: NodeInfo, 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
        class QueryRequest : AbstractRequestMessage
          Module Contents QueryRequest(queries: List<FixOf>, replyTo: SingleMessageRecipient, sessionID: Long)
          val queries: List<FixOf>
        object SIGNING : Step
        class SignRequest : AbstractRequestMessage
          Module Contents SignRequest(tx: WireTransaction, replyTo: SingleMessageRecipient, sessionID: Long)
          val tx: WireTransaction
        val TOPIC: String
        val TOPIC_QUERY: String
        val TOPIC_SIGN: String
        object WORKING : Step
        protected open fun beforeSigning(fix: Fix): Unit
        open fun call(): Unit
        open val progressTracker: ProgressTracker
        fun query(): Fix
        fun sign(): LegallyIdentifiable
        fun tracker(fixName: String): ProgressTracker
        protected val tx: TransactionBuilder
      class ResolveTransactionsProtocol : ProtocolLogic<Unit>
        Module Contents ResolveTransactionsProtocol(stx: SignedTransaction, otherSide: SingleMessageRecipient)
        ResolveTransactionsProtocol(wtx: WireTransaction, otherSide: SingleMessageRecipient)
        ResolveTransactionsProtocol(txHashes: Set<SecureHash>, otherSide: SingleMessageRecipient)
        class ExcessivelyLargeTransactionGraph : Exception
          Module Contents ExcessivelyLargeTransactionGraph()
        fun call(): Unit
      class TimestampingProtocol : ProtocolLogic<LegallyIdentifiable>
        Module Contents TimestampingProtocol(node: NodeInfo, wtxBytes: SerializedBytes<WireTransaction>, progressTracker: ProgressTracker = TimestampingProtocol.tracker())
        class Client : TimestamperService
          Module Contents Client(stateMachineManager: StateMachineManager, node: NodeInfo)
          val identity: Party
          fun timestamp(wtxBytes: SerializedBytes<WireTransaction>): LegallyIdentifiable
        object REQUESTING : Step
        class Request : AbstractRequestMessage
          Module Contents Request(tx: SerializedBytes<WireTransaction>, replyTo: MessageRecipients, sessionID: Long)
          val tx: SerializedBytes<WireTransaction>
        object VALIDATING : Step
        fun call(): LegallyIdentifiable
        val progressTracker: ProgressTracker
        fun tracker(): ProgressTracker
      object TwoPartyDealProtocol
        Module Contents class Acceptor<T : DealState> : Secondary<T>
          Module Contents Acceptor(otherSide: SingleMessageRecipient, timestampingAuthority: Party, dealToBuy: T, sessionID: Long, progressTracker: ProgressTracker = Secondary.tracker())
          protected open fun assembleSharedTX(handshake: Handshake<T>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          val dealToBuy: T
          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
        class Fixer<T : FixableDealState> : Secondary<StateRef>
          Module Contents Fixer(otherSide: SingleMessageRecipient, timestampingAuthority: Party, dealToFix: StateAndRef<T>, sessionID: Long, replacementProgressTracker: ProgressTracker? = null)
          protected open fun assembleSharedTX(handshake: Handshake<StateRef>): <ERROR CLASS><TransactionBuilder, List<PublicKey>>
          fun createTracker(): ProgressTracker
          val dealToFix: StateAndRef<T>
          open val progressTracker: ProgressTracker
          val replacementProgressTracker: ProgressTracker?
          protected open fun validateHandshake(handshake: Handshake<StateRef>): Handshake<StateRef>
        class Floater<T : FixableDealState> : Primary<StateRef>
          Module Contents Floater(otherSide: SingleMessageRecipient, otherSessionID: Long, timestampingAuthority: NodeInfo, dealToFix: StateAndRef<T>, myKeyPair: KeyPair, sessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          open val progressTracker: ProgressTracker
          val sessionID: Long
        data class Handshake<T>
          Module Contents Handshake(payload: T, publicKey: PublicKey, sessionID: Long)
          val payload: T
          val publicKey: PublicKey
          val sessionID: Long
        class Instigator<T : DealState> : Primary<T>
          Module Contents Instigator(otherSide: SingleMessageRecipient, timestampingAuthority: NodeInfo, dealBeingOffered: T, myKeyPair: KeyPair, buyerSessionID: Long, progressTracker: ProgressTracker = Primary.tracker())
          open val progressTracker: ProgressTracker
        abstract class Primary<U> : ProtocolLogic<SignedTransaction>
          Module Contents Primary(payload: U, otherSide: SingleMessageRecipient, otherSessionID: Long, myKeyPair: KeyPair, timestampingAuthority: NodeInfo, progressTracker: ProgressTracker = Primary.tracker())
          object AWAITING_PROPOSAL : Step
          object COPYING_TO_REGULATOR : Step
          object RECORDING : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object TIMESTAMPING : Step
          object VERIFYING : Step
          open fun call(): SignedTransaction
          fun getPartialTransaction(): UntrustworthyData<SignedTransaction>
          val myKeyPair: KeyPair
          val otherSessionID: Long
          val otherSide: SingleMessageRecipient
          val payload: U
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          val timestampingAuthority: NodeInfo
          fun tracker(): <ERROR CLASS>
          fun verifyPartialTransaction(untrustedPartialTX: UntrustworthyData<SignedTransaction>): SignedTransaction
        abstract class Secondary<U> : ProtocolLogic<SignedTransaction>
          Module Contents Secondary(otherSide: SingleMessageRecipient, timestampingAuthority: Party, sessionID: Long, 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
          val otherSide: SingleMessageRecipient
          open val progressTracker: ProgressTracker
          val sessionID: Long
          val timestampingAuthority: Party
          fun tracker(): ProgressTracker
          protected abstract fun validateHandshake(handshake: Handshake<U>): Handshake<U>
        class SignaturesFromPrimary
          Module Contents SignaturesFromPrimary(timestampAuthoritySig: WithKey, sellerSig: WithKey)
          val sellerSig: WithKey
          val timestampAuthoritySig: WithKey
      object TwoPartyTradeProtocol
        Module Contents class AssetMismatchException : Exception
          Module Contents AssetMismatchException(expectedTypeName: String, typeName: String)
          val expectedTypeName: String
          fun toString(): String
          val typeName: String
        class Buyer : ProtocolLogic<SignedTransaction>
          Module Contents Buyer(otherSide: SingleMessageRecipient, timestampingAuthority: Party, acceptablePrice: Amount, typeToBuy: Class<out OwnableState>, sessionID: Long)
          object RECEIVING : Step
          object SIGNING : Step
          object SWAPPING_SIGNATURES : Step
          object VERIFYING : Step
          val acceptablePrice: Amount
          open fun call(): SignedTransaction
          val otherSide: SingleMessageRecipient
          open val progressTracker: ProgressTracker
          val sessionID: Long
          val timestampingAuthority: Party
          val typeToBuy: Class<out OwnableState>
        class Seller : ProtocolLogic<SignedTransaction>
          Module Contents Seller(otherSide: SingleMessageRecipient, timestampingAuthority: NodeInfo, assetToSell: StateAndRef<OwnableState>, price: Amount, myKeyPair: KeyPair, buyerSessionID: Long, progressTracker: ProgressTracker = Seller.tracker())
          object AWAITING_PROPOSAL : Step
          object SENDING_SIGS : Step
          object SIGNING : Step
          object TIMESTAMPING : Step
          object VERIFYING : Step
          val assetToSell: StateAndRef<OwnableState>
          val buyerSessionID: Long
          open fun call(): SignedTransaction
          val myKeyPair: KeyPair
          val otherSide: SingleMessageRecipient
          val price: Amount
          open val progressTracker: ProgressTracker
          open fun signWithOurKey(partialTX: SignedTransaction): WithKey
          val timestampingAuthority: NodeInfo
          fun tracker(): ProgressTracker
        class SellerTradeInfo
          Module Contents SellerTradeInfo(assetForSale: StateAndRef<OwnableState>, price: Amount, sellerOwnerKey: PublicKey, sessionID: Long)
          val assetForSale: StateAndRef<OwnableState>
          val price: Amount
          val sellerOwnerKey: PublicKey
          val sessionID: Long
        class SignaturesFromSeller
          Module Contents SignaturesFromSeller(timestampAuthoritySig: WithKey, sellerSig: WithKey)
          val sellerSig: WithKey
          val timestampAuthoritySig: WithKey
        val TRADE_TOPIC: String
        class UnacceptablePriceException : Exception
          Module Contents UnacceptablePriceException(givenPrice: Amount)
          val givenPrice: Amount
        fun runBuyer(smm: StateMachineManager, timestampingAuthority: NodeInfo, otherSide: SingleMessageRecipient, acceptablePrice: Amount, typeToBuy: Class<out OwnableState>, sessionID: Long): <ERROR CLASS><SignedTransaction>
        fun runSeller(smm: StateMachineManager, timestampingAuthority: NodeInfo, otherSide: SingleMessageRecipient, assetToSell: StateAndRef<OwnableState>, price: Amount, myKeyPair: KeyPair, buyerSessionID: Long): <ERROR CLASS><SignedTransaction>