Module Contents alltypes
      Module Contents object ANSIProgressRenderer
        Module Contents var progressTracker: ProgressTracker?
      abstract class AbstractNode
        Module Contents AbstractNode(dir: Path, configuration: NodeConfiguration, timestamperAddress: LegallyIdentifiableNode?)
        val PRIVATE_KEY_FILE_NAME: String
        val PUBLIC_IDENTITY_FILE_NAME: String
        protected val _servicesThatAcceptUploads: ArrayList<AcceptsFileUpload>
        val configuration: NodeConfiguration
        protected open fun constructStorageService(attachments: NodeAttachmentService, keypair: KeyPair, identity: Party, contractFactory: ContractFactory): StorageServiceImpl
        protected val contractFactory: ContractFactory
        val dir: Path
        lateinit var identity: IdentityService
        var inNodeTimestampingService: NodeTimestamperService?
        protected open fun initialiseStorageService(dir: Path): StorageService
        lateinit var keyManagement: E2ETestKeyManagementService
        val legallyIdentifableAddress: LegallyIdentifiableNode
        protected abstract val log: <ERROR CLASS>
        protected open fun makeIdentityService(): IdentityService
        protected fun makeInterestRateOracleService(): Unit
        protected abstract fun makeMessagingService(): MessagingService
        lateinit var net: MessagingService
        protected open val serverThread: ExecutorService
        val services: ServiceHub
        val servicesThatAcceptUploads: List<AcceptsFileUpload>
        lateinit var smm: StateMachineManager
        open fun start(): AbstractNode
        open fun stop(): Unit
        lateinit var storage: StorageService
        val timestamperAddress: LegallyIdentifiableNode?
        lateinit var wallet: WalletService
      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
      interface AllPossibleRecipients : MessageRecipients
      data class Amount : Comparable<Amount>
        Module Contents 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>)
        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 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?
      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
      class BriefLogFormatter : Formatter
        Module Contents BriefLogFormatter()
        fun format(logRecord: LogRecord): String
        fun init(): Unit
        fun initVerbose(vararg loggerNames: String): Unit
        fun loggingOff(vararg names: String): Unit
        fun loggingOff(vararg classes: KClass<*>): Unit
        fun loggingOn(vararg names: String): Unit
        fun loggingOn(vararg classes: KClass<*>): Unit
      open class BusinessCalendar
        Module Contents val TEST_CALENDAR_DATA: <ERROR CLASS>
        class UnknownCalendar : Exception
          Module Contents UnknownCalendar(name: String)
        open fun applyRollConvention(testDate: LocalDate, dateRollConvention: DateRollConvention): LocalDate
        val calendars: <ERROR CLASS>
        fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = BusinessCalendar.getInstance(), dateRollConvention: DateRollConvention = DateRollConvention.Following, noOfAdditionalPeriods: Int = Integer.MAX_VALUE, endDate: LocalDate? = null, periodOffset: Int? = null): List<LocalDate>
        fun getInstance(vararg calname: String): BusinessCalendar
        val holidayDates: List<LocalDate>
        open fun isWorkingDay(date: LocalDate): Boolean
        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 deposit: PartyReference
          val owner: PublicKey
          val programRef: <ERROR CLASS>
          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
      data class Command
        Module Contents Command(data: CommandData, key: PublicKey)
        Command(data: CommandData, pubkeys: List<PublicKey>)
        val data: CommandData
        val pubkeys: List<PublicKey>
        fun toString(): String
      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 faceValue: Amount
          val issuance: PartyReference
          val maturityDate: Instant
          val owner: PublicKey
          val programRef: <ERROR CLASS>
          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()
        object LocalDateDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): LocalDate
        object ToStringSerializer
          Module Contents fun serialize(obj: Any, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        val defaultObjectMapper: <ERROR CLASS>
        fun getContext(type: Class<*>): <ERROR CLASS>
      class ConfigurationException : Exception
        Module Contents ConfigurationException(message: String)
      interface Contract
        Module Contents abstract val legalContractReference: SecureHash
        abstract fun verify(tx: TransactionForVerification): Unit
      interface ContractFactory
        Module Contents abstract operator fun <T : Contract> get(hash: SecureHash): T
      interface ContractState
        Module Contents abstract val programRef: SecureHash
      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 pledgedAmount: Amount
          val pledges: List<Pledge>
          val programRef: <ERROR CLASS>
        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 DataUploadServlet
        Module Contents DataUploadServlet()
        fun doPost(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit
      class DataVendingService
        Module Contents DataVendingService(net: MessagingService, storage: StorageService)
        data class Request
          Module Contents Request(hashes: List<SecureHash>, responseTo: SingleMessageRecipient, sessionID: Long)
          val hashes: List<SecureHash>
          val responseTo: SingleMessageRecipient
          val sessionID: Long
        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 Actual
        ActualJ
        Bus_SaoPaulo
        D30
        D30E
        D30F
        D30G
        D30N
        D30P
        D30Z
      enum class DayCountBasisYear
        Module Contents Actual
        ActualA
        ICMA
        ISMA
        Y252
        Y360
        Y365
        Y365B
        Y365F
        Y365L
        Y365Q
        Y366
      object DefaultConfiguration : NodeConfiguration
        Module Contents val exportJMXto: String
        val myLegalName: String
        fun toProperties(): Properties
      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()
        class State : ContractState
          Module Contents State()
          val programRef: SecureHash
        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
      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: Duration)
        val forDay: LocalDate
        val name: String
        val ofTenor: Duration
      class FixedIdentityService : IdentityService
        Module Contents FixedIdentityService(identities: List<Party>)
        fun partyFromKey(key: PublicKey): Party?
      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
      interface IdentityService
        Module Contents abstract fun partyFromKey(key: PublicKey): Party?
      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 InsufficientBalanceException : Exception
        Module Contents InsufficientBalanceException(amountMissing: Amount)
        val amountMissing: Amount
      interface KeyManagementService
        Module Contents abstract fun freshKey(): KeyPair
        abstract val keys: Map<PublicKey, PrivateKey>
        open fun toPrivate(publicKey: PublicKey): PrivateKey
      data class LedgerTransaction
        Module Contents LedgerTransaction(inputs: List<StateRef>, attachments: List<Attachment>, outputs: List<ContractState>, commands: List<AuthenticatedObject<CommandData>>, hash: SecureHash)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        val hash: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        val outputs: List<ContractState>
        fun toSignedTransaction(andSignWithKeys: List<KeyPair> = emptyList(), allowUnusedKeys: Boolean = false): SignedTransaction
        fun toWireTransaction(): WireTransaction
      data class LegallyIdentifiableNode
        Module Contents LegallyIdentifiableNode(address: SingleMessageRecipient, identity: Party)
        val address: SingleMessageRecipient
        val identity: Party
      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 MockNetworkMapService : NetworkMapService
        Module Contents MockNetworkMapService()
        val timestampingNodes: MutableList<LegallyIdentifiableNode>
      class MonitoringService
        Module Contents MonitoringService(metrics: <ERROR CLASS>)
        val metrics: <ERROR CLASS>
      interface NamedByHash
        Module Contents abstract val id: SecureHash
      interface NetworkMapService
        Module Contents abstract val timestampingNodes: List<LegallyIdentifiableNode>
      class Node : AbstractNode
        Module Contents Node(dir: Path, p2pAddr: <ERROR CLASS>, configuration: NodeConfiguration, timestamperAddress: LegallyIdentifiableNode?)
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingService
        val p2pAddr: <ERROR CLASS>
        fun start(): Node
        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
      class NodeConfigurationFromProperties : NodeConfiguration
        Module Contents NodeConfigurationFromProperties(properties: Properties)
        val exportJMXto: String
        val myLegalName: String
      object NodeInterestRates
        Module Contents class Oracle
          Module Contents Oracle(identity: Party, signingKey: KeyPair)
          val identity: Party
          var knownFixes: <ERROR CLASS>
          fun query(queries: List<FixOf>): List<Fix>
          fun sign(wtx: WireTransaction): LegallyIdentifiable
        class Service : AcceptsFileUpload
          Module Contents Service(node: AbstractNode)
          val acceptableFileExtensions: <ERROR CLASS>
          val dataTypePrefix: String
          val net: MessagingService
          val oracle: Oracle
          val ss: StorageService
          fun upload(data: InputStream): String
        class UnknownFix : Exception
          Module Contents UnknownFix(fix: FixOf)
          val fix: FixOf
          fun toString(): String
        fun parseFile(s: String): Map<FixOf, Fix>
        fun parseFixOf(key: String): FixOf
        fun parseOneRate(s: String): <ERROR CLASS><FixOf, Fix>
      class NodeTimestamperService
        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()): Wallet
        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
      enum class PaymentRule
        Module Contents InAdvance
        InArrears
      class ProgressTracker
        Module Contents ProgressTracker(vararg steps: Step)
        sealed class Change
          Module Contents class Position : Change
            Module Contents Position(newStep: Step)
            val newStep: Step
          class Rendering : Change
            Module Contents Rendering(ofStep: Step)
            val ofStep: Step
          class Structural : Change
            Module Contents Structural(parent: Step)
            val parent: Step
        object DONE : Step
          Module Contents fun equals(other: Any?): Boolean
        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 stepIndex: Int
        val steps: Array<Step>
      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 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>)
        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 RatesFixProtocol : ProtocolLogic<Unit>
        Module Contents RatesFixProtocol(tx: TransactionBuilder, oracle: LegallyIdentifiableNode, fixOf: FixOf, expectedRate: BigDecimal, rateTolerance: BigDecimal)
        class FixOutOfRange : Exception
          Module Contents FixOutOfRange(byAmount: BigDecimal)
          val byAmount: BigDecimal
        class QUERYING : Step
          Module Contents QUERYING(name: String)
          val name: String
        data class QueryRequest
          Module Contents QueryRequest(queries: List<FixOf>, replyTo: SingleMessageRecipient, sessionID: Long)
          val queries: List<FixOf>
          val replyTo: SingleMessageRecipient
          val sessionID: Long
        object SIGNING : Step
        data class SignRequest
          Module Contents SignRequest(tx: WireTransaction, replyTo: SingleMessageRecipient, sessionID: Long)
          val replyTo: SingleMessageRecipient
          val sessionID: Long
          val tx: WireTransaction
        val TOPIC: String
        object WORKING : Step
        protected open fun beforeSigning(fix: Fix): Unit
        open fun call(): Unit
        open val progressTracker: ProgressTracker
        fun query(): Fix
        fun sign(): LegallyIdentifiable
        protected val tx: TransactionBuilder
      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 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
      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
      interface ServiceHub
        Module Contents abstract val identityService: IdentityService
        abstract val keyManagementService: KeyManagementService
        abstract val monitoringService: MonitoringService
        abstract val networkMapService: NetworkMapService
        abstract val networkService: MessagingService
        abstract val storageService: StorageService
        open fun verifyTransaction(ltx: LedgerTransaction): Unit
        abstract val walletService: WalletService
      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
      interface SingleMessageRecipient : MessageRecipients
      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, runInThread: Executor)
        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 topic: String
        object SameThreadFiberScheduler
        fun <T> add(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
        val checkpointing: Boolean
        fun <T> findStateMachines(klass: Class<out ProtocolLogic<T>>): List<<ERROR CLASS><ProtocolLogic<T>, <ERROR CLASS><T>>>
        val runInThread: Executor
        val serviceHub: ServiceHub
      data class StateRef
        Module Contents StateRef(txhash: SecureHash, index: Int)
        val index: Int
        fun toString(): String
        val txhash: SecureHash
      interface StorageService
        Module Contents abstract val attachments: AttachmentStorage
        abstract val contractPrograms: ContractFactory
        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, contractFactory: ContractFactory, keypair: KeyPair, identity: Party = Party("Unit test party", keypair.public), recordingAs: (String) -> String = { tableName -> "" })
        open val attachments: AttachmentStorage
        open val contractPrograms: ContractFactory
        open val myLegalIdentity: Party
        open val myLegalIdentityKey: KeyPair
        val recordingAs: (String) -> String
        open val stateMachines: MutableMap<SecureHash, ByteArray>
        protected val tables: HashMap<String, MutableMap<Any, Any>>
        open val validatedTransactions: MutableMap<SecureHash, SignedTransaction>
      data class Tenor
        Module Contents Tenor(name: String)
        var name: 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 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: LegallyIdentifiableNode, wtxBytes: SerializedBytes<WireTransaction>)
        class Client : TimestamperService
          Module Contents Client(stateMachineManager: StateMachineManager, node: LegallyIdentifiableNode)
          val identity: Party
          fun timestamp(wtxBytes: SerializedBytes<WireTransaction>): LegallyIdentifiable
        data class Request
          Module Contents Request(tx: SerializedBytes<WireTransaction>, replyTo: MessageRecipients, replyToTopic: String)
          val replyTo: MessageRecipients
          val replyToTopic: String
          val tx: SerializedBytes<WireTransaction>
        fun call(): LegallyIdentifiable
      object TopicStringValidator
        Module Contents fun check(tag: String): <ERROR CLASS>
      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: LegallyIdentifiableNode): StateAndRef<State>
        fun tracker(): <ERROR CLASS>
      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>
          Module Contents InOutGroup(inputs: List<T>, outputs: List<T>)
          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> groupStates(ofType: Class<T>, selector: (T) -> Any): List<InOutGroup<T>>
        inline fun <reified T : ContractState> groupStates(selector: (T) -> Any): List<InOutGroup<T>>
        fun <T : ContractState> groupStatesInternal(inGroups: Map<Any, List<T>>, outGroups: Map<Any, List<T>>): List<InOutGroup<T>>
        fun hashCode(): Int
        val inStates: List<ContractState>
        val origHash: SecureHash
        val outStates: List<ContractState>
        fun verify(programMap: ContractFactory): 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(programMap: ContractFactory): 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 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: LegallyIdentifiableNode, 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: LegallyIdentifiableNode
          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: LegallyIdentifiableNode, otherSide: SingleMessageRecipient, acceptablePrice: Amount, typeToBuy: Class<out OwnableState>, sessionID: Long): <ERROR CLASS><SignedTransaction>
        fun runSeller(smm: StateMachineManager, timestampingAuthority: LegallyIdentifiableNode, 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>
      class UnknownContractException : Exception
        Module Contents UnknownContractException()
      class UntrustworthyData<T>
        Module Contents UntrustworthyData(fromUntrustedWorld: T)
        val data: T
        inline fun <R> validate(validator: (T) -> R): R
      data class Wallet
        Module Contents Wallet(states: List<StateAndRef<OwnableState>>)
        val cashBalances: Map<Currency, Amount>
        val states: List<StateAndRef<OwnableState>>
        inline fun <reified T : OwnableState> statesOfType(): List<StateAndRef<T>>
      interface WalletService
        Module Contents abstract val cashBalances: Map<Currency, Amount>
        abstract val currentWallet: Wallet
        open fun notify(tx: WireTransaction): Wallet
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Wallet
      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>): 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 toSignedTransaction(withSigs: List<WithKey>): SignedTransaction
        fun toString(): String
      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 inline fun <reified T : Any> ByteArray.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get(), includeClassName: Boolean = false): 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.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.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 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 class Config
        Module Contents Config()
        object LocalDateDeserializer
          Module Contents fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): LocalDate
        object ToStringSerializer
          Module Contents fun serialize(obj: Any, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit
        val defaultObjectMapper: <ERROR CLASS>
        fun getContext(type: Class<*>): <ERROR CLASS>
    package contracts
      Module Contents val CASH_PROGRAM_ID: <ERROR CLASS>
      val CP_PROGRAM_ID: <ERROR CLASS>
      val CROWDFUND_PROGRAM_ID: <ERROR CLASS>
      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 deposit: PartyReference
          val owner: PublicKey
          val programRef: <ERROR CLASS>
          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 faceValue: Amount
          val issuance: PartyReference
          val maturityDate: Instant
          val owner: PublicKey
          val programRef: <ERROR CLASS>
          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 pledgedAmount: Amount
          val pledges: List<Pledge>
          val programRef: <ERROR CLASS>
        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: <ERROR CLASS>
      class DummyContract : Contract
        Module Contents DummyContract()
        class State : ContractState
          Module Contents State()
          val programRef: SecureHash
        val legalContractReference: SecureHash
        fun verify(tx: TransactionForVerification): Unit
      class InsufficientBalanceException : Exception
        Module Contents InsufficientBalanceException(amountMissing: Amount)
        val amountMissing: 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>
    package core
      Module Contents enum class AccrualAdjustment
        Module Contents Adjusted
        Unadjusted
      data class Amount : Comparable<Amount>
        Module Contents 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: <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>
        fun getInstance(vararg calname: String): BusinessCalendar
        val holidayDates: List<LocalDate>
        open fun isWorkingDay(date: LocalDate): Boolean
        fun parseDateFromString(it: String): LocalDate
      val CHF: Currency
      data class Command
        Module Contents Command(data: CommandData, key: PublicKey)
        Command(data: CommandData, pubkeys: List<PublicKey>)
        val data: CommandData
        val pubkeys: List<PublicKey>
        fun toString(): String
      interface CommandData
      interface Contract
        Module Contents abstract val legalContractReference: SecureHash
        abstract fun verify(tx: TransactionForVerification): Unit
      interface ContractFactory
        Module Contents abstract operator fun <T : Contract> get(hash: SecureHash): T
      interface ContractState
        Module Contents abstract val programRef: SecureHash
      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 Actual
        ActualJ
        Bus_SaoPaulo
        D30
        D30E
        D30F
        D30G
        D30N
        D30P
        D30Z
      enum class DayCountBasisYear
        Module Contents Actual
        ActualA
        ICMA
        ISMA
        Y252
        Y360
        Y365
        Y365B
        Y365F
        Y365L
        Y365Q
        Y366
      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: Duration)
        val forDay: LocalDate
        val name: String
        val ofTenor: Duration
      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
        Module Contents LedgerTransaction(inputs: List<StateRef>, attachments: List<Attachment>, outputs: List<ContractState>, commands: List<AuthenticatedObject<CommandData>>, hash: SecureHash)
        val attachments: List<Attachment>
        val commands: List<AuthenticatedObject<CommandData>>
        val hash: SecureHash
        val inputs: List<StateRef>
        fun <T : ContractState> outRef(index: Int): StateAndRef<T>
        val outputs: List<ContractState>
        fun toSignedTransaction(andSignWithKeys: List<KeyPair> = emptyList(), allowUnusedKeys: Boolean = false): SignedTransaction
        fun toWireTransaction(): WireTransaction
      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)
        var name: 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>
          Module Contents InOutGroup(inputs: List<T>, outputs: List<T>)
          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> groupStates(ofType: Class<T>, selector: (T) -> Any): List<InOutGroup<T>>
        inline fun <reified T : ContractState> groupStates(selector: (T) -> Any): List<InOutGroup<T>>
        fun <T : ContractState> groupStatesInternal(inGroups: Map<Any, List<T>>, outGroups: Map<Any, List<T>>): List<InOutGroup<T>>
        fun hashCode(): Int
        val inStates: List<ContractState>
        val origHash: SecureHash
        val outStates: List<ContractState>
        fun verify(programMap: ContractFactory): 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(programMap: ContractFactory): 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
      class UnknownContractException : Exception
        Module Contents UnknownContractException()
      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>): 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 toSignedTransaction(withSigs: List<WithKey>): SignedTransaction
        fun toString(): String
      fun currency(code: String): Currency
      fun dayCountCalculator(startDate: LocalDate, endDate: LocalDate, dcbYear: DayCountBasisYear, dcbDay: DayCountBasisDay): BigDecimal
      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 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
      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>
      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.messaging
      Module Contents interface AllPossibleRecipients : MessageRecipients
      data class LegallyIdentifiableNode
        Module Contents LegallyIdentifiableNode(address: SingleMessageRecipient, identity: Party)
        val address: SingleMessageRecipient
        val identity: Party
      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 MockNetworkMapService : NetworkMapService
        Module Contents MockNetworkMapService()
        val timestampingNodes: MutableList<LegallyIdentifiableNode>
      interface NetworkMapService
        Module Contents abstract val timestampingNodes: List<LegallyIdentifiableNode>
      interface SingleMessageRecipient : MessageRecipients
      class StateMachineManager
        Module Contents StateMachineManager(serviceHub: ServiceHub, runInThread: Executor)
        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 topic: String
        object SameThreadFiberScheduler
        fun <T> add(loggerName: String, logic: ProtocolLogic<T>): <ERROR CLASS><T>
        val checkpointing: Boolean
        fun <T> findStateMachines(klass: Class<out ProtocolLogic<T>>): List<<ERROR CLASS><ProtocolLogic<T>, <ERROR CLASS><T>>>
        val runInThread: Executor
        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, to: MessageRecipients, obj: Any, includeClassName: Boolean = false): Unit
    package core.node
      Module Contents abstract class AbstractNode
        Module Contents AbstractNode(dir: Path, configuration: NodeConfiguration, timestamperAddress: LegallyIdentifiableNode?)
        val PRIVATE_KEY_FILE_NAME: String
        val PUBLIC_IDENTITY_FILE_NAME: String
        protected val _servicesThatAcceptUploads: ArrayList<AcceptsFileUpload>
        val configuration: NodeConfiguration
        protected open fun constructStorageService(attachments: NodeAttachmentService, keypair: KeyPair, identity: Party, contractFactory: ContractFactory): StorageServiceImpl
        protected val contractFactory: ContractFactory
        val dir: Path
        lateinit var identity: IdentityService
        var inNodeTimestampingService: NodeTimestamperService?
        protected open fun initialiseStorageService(dir: Path): StorageService
        lateinit var keyManagement: E2ETestKeyManagementService
        val legallyIdentifableAddress: LegallyIdentifiableNode
        protected abstract val log: <ERROR CLASS>
        protected open fun makeIdentityService(): IdentityService
        protected fun makeInterestRateOracleService(): Unit
        protected abstract fun makeMessagingService(): MessagingService
        lateinit var net: MessagingService
        protected open val serverThread: ExecutorService
        val services: ServiceHub
        val servicesThatAcceptUploads: List<AcceptsFileUpload>
        lateinit var smm: StateMachineManager
        open fun start(): AbstractNode
        open fun stop(): Unit
        lateinit var storage: StorageService
        val timestamperAddress: LegallyIdentifiableNode?
        lateinit var wallet: WalletService
      interface AcceptsFileUpload
        Module Contents abstract val acceptableFileExtensions: List<String>
        abstract val dataTypePrefix: String
        abstract fun upload(data: InputStream): String
      class ConfigurationException : Exception
        Module Contents ConfigurationException(message: String)
      object DefaultConfiguration : NodeConfiguration
        Module Contents val exportJMXto: String
        val myLegalName: String
        fun toProperties(): Properties
      class Node : AbstractNode
        Module Contents Node(dir: Path, p2pAddr: <ERROR CLASS>, configuration: NodeConfiguration, timestamperAddress: LegallyIdentifiableNode?)
        val DEFAULT_PORT: Int
        protected val log: <ERROR CLASS>
        protected fun makeMessagingService(): MessagingService
        val p2pAddr: <ERROR CLASS>
        fun start(): Node
        fun stop(): Unit
        lateinit var webServer: <ERROR CLASS>
      interface NodeConfiguration
        Module Contents abstract val exportJMXto: String
        abstract val myLegalName: String
      class NodeConfigurationFromProperties : NodeConfiguration
        Module Contents NodeConfigurationFromProperties(properties: Properties)
        val exportJMXto: String
        val myLegalName: String
    package core.node.services
      Module Contents class ArtemisMessagingService : MessagingService
        Module Contents ArtemisMessagingService(directory: Path, myHostPort: <ERROR CLASS>)
        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 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 AttachmentStorage
        Module Contents abstract fun importAttachment(jar: InputStream): SecureHash
        abstract fun openAttachment(id: SecureHash): Attachment?
      class DataVendingService
        Module Contents DataVendingService(net: MessagingService, storage: StorageService)
        data class Request
          Module Contents Request(hashes: List<SecureHash>, responseTo: SingleMessageRecipient, sessionID: Long)
          val hashes: List<SecureHash>
          val responseTo: SingleMessageRecipient
          val sessionID: Long
        val logger: <ERROR CLASS>
      object DummyTimestampingAuthority
        Module Contents val identity: Party
        val key: KeyPair
      class E2ETestKeyManagementService : KeyManagementService
        Module Contents E2ETestKeyManagementService()
        fun freshKey(): KeyPair
        val keys: Map<PublicKey, PrivateKey>
      class FixedIdentityService : IdentityService
        Module Contents FixedIdentityService(identities: List<Party>)
        fun partyFromKey(key: PublicKey): Party?
      interface IdentityService
        Module Contents abstract fun partyFromKey(key: PublicKey): Party?
      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>
      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 Oracle
          Module Contents Oracle(identity: Party, signingKey: KeyPair)
          val identity: Party
          var knownFixes: <ERROR CLASS>
          fun query(queries: List<FixOf>): List<Fix>
          fun sign(wtx: WireTransaction): LegallyIdentifiable
        class Service : AcceptsFileUpload
          Module Contents Service(node: AbstractNode)
          val acceptableFileExtensions: <ERROR CLASS>
          val dataTypePrefix: String
          val net: MessagingService
          val oracle: Oracle
          val ss: StorageService
          fun upload(data: InputStream): String
        class UnknownFix : Exception
          Module Contents UnknownFix(fix: FixOf)
          val fix: FixOf
          fun toString(): String
        fun parseFile(s: String): Map<FixOf, Fix>
        fun parseFixOf(key: String): FixOf
        fun parseOneRate(s: String): <ERROR CLASS><FixOf, Fix>
      class NodeTimestamperService
        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()): Wallet
        fun notifyAll(txns: Iterable<WireTransaction>): Wallet
      interface ServiceHub
        Module Contents abstract val identityService: IdentityService
        abstract val keyManagementService: KeyManagementService
        abstract val monitoringService: MonitoringService
        abstract val networkMapService: NetworkMapService
        abstract val networkService: MessagingService
        abstract val storageService: StorageService
        open fun verifyTransaction(ltx: LedgerTransaction): Unit
        abstract val walletService: WalletService
      interface StorageService
        Module Contents abstract val attachments: AttachmentStorage
        abstract val contractPrograms: ContractFactory
        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, contractFactory: ContractFactory, keypair: KeyPair, identity: Party = Party("Unit test party", keypair.public), recordingAs: (String) -> String = { tableName -> "" })
        open val attachments: AttachmentStorage
        open val contractPrograms: ContractFactory
        open val myLegalIdentity: Party
        open val myLegalIdentityKey: KeyPair
        val recordingAs: (String) -> String
        open val stateMachines: MutableMap<SecureHash, ByteArray>
        protected val tables: HashMap<String, MutableMap<Any, Any>>
        open val validatedTransactions: MutableMap<SecureHash, SignedTransaction>
      interface TimestamperService
        Module Contents 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()
      data class Wallet
        Module Contents Wallet(states: List<StateAndRef<OwnableState>>)
        val cashBalances: Map<Currency, Amount>
        val states: List<StateAndRef<OwnableState>>
        inline fun <reified T : OwnableState> statesOfType(): List<StateAndRef<T>>
      interface WalletService
        Module Contents abstract val cashBalances: Map<Currency, Amount>
        abstract val currentWallet: Wallet
        open fun notify(tx: WireTransaction): Wallet
        abstract fun notifyAll(txns: Iterable<WireTransaction>): Wallet
    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.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 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>)
        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 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
      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
      val THREAD_LOCAL_KRYO: <ERROR CLASS>
      fun createKryo(k: <ERROR CLASS> = Kryo()): <ERROR CLASS>
      inline fun <reified T : Any> OpaqueBytes.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get(), includeClassName: Boolean = false): T
      fun SerializedBytes<WireTransaction>.deserialize(): WireTransaction
      inline fun <reified T : Any> SerializedBytes<T>.deserialize(): T
      kotlin.ByteArray
        Module Contents inline fun <reified T : Any> ByteArray.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get(), includeClassName: Boolean = false): T
        fun ByteArray.opaque(): OpaqueBytes
      fun <T : Any> T.serialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get(), includeClassName: Boolean = false): SerializedBytes<T>
    package core.utilities
      Module Contents object ANSIProgressRenderer
        Module Contents var progressTracker: ProgressTracker?
      class BriefLogFormatter : Formatter
        Module Contents BriefLogFormatter()
        fun format(logRecord: LogRecord): String
        fun init(): Unit
        fun initVerbose(vararg loggerNames: String): Unit
        fun loggingOff(vararg names: String): Unit
        fun loggingOff(vararg classes: KClass<*>): Unit
        fun loggingOn(vararg names: String): Unit
        fun loggingOn(vararg classes: KClass<*>): Unit
      object Emoji
        Module Contents const val CODE_BAG_OF_CASH: String
        const val CODE_DIAMOND: String
        const val CODE_GREEN_TICK: String
        const val CODE_LEFT_ARROW: String
        const val CODE_NEWSPAPER: String
        const val CODE_PAPERCLIP: String
        const val CODE_RIGHT_ARROW: String
        val bagOfCash: String
        val diamond: String
        val hasEmojiTerminal: <ERROR CLASS>
        val leftArrow: String
        val newspaper: String
        val paperclip: String
        fun renderIfSupported(obj: Any): String
        val rightArrow: String
      class ProgressTracker
        Module Contents ProgressTracker(vararg steps: Step)
        sealed class Change
          Module Contents class Position : Change
            Module Contents Position(newStep: Step)
            val newStep: Step
          class Rendering : Change
            Module Contents Rendering(ofStep: Step)
            val ofStep: Step
          class Structural : Change
            Module Contents Structural(parent: Step)
            val parent: Step
        object DONE : Step
          Module Contents fun equals(other: Any?): Boolean
        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 stepIndex: Int
        val steps: Array<Step>
      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 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: LegallyIdentifiableNode): StateAndRef<State>
        fun tracker(): <ERROR CLASS>
      fun main(args: Array<String>): Unit
      fun main(args: Array<String>): Unit
    package protocols
      Module Contents 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: LegallyIdentifiableNode, fixOf: FixOf, expectedRate: BigDecimal, rateTolerance: BigDecimal)
        class FixOutOfRange : Exception
          Module Contents FixOutOfRange(byAmount: BigDecimal)
          val byAmount: BigDecimal
        class QUERYING : Step
          Module Contents QUERYING(name: String)
          val name: String
        data class QueryRequest
          Module Contents QueryRequest(queries: List<FixOf>, replyTo: SingleMessageRecipient, sessionID: Long)
          val queries: List<FixOf>
          val replyTo: SingleMessageRecipient
          val sessionID: Long
        object SIGNING : Step
        data class SignRequest
          Module Contents SignRequest(tx: WireTransaction, replyTo: SingleMessageRecipient, sessionID: Long)
          val replyTo: SingleMessageRecipient
          val sessionID: Long
          val tx: WireTransaction
        val TOPIC: String
        object WORKING : Step
        protected open fun beforeSigning(fix: Fix): Unit
        open fun call(): Unit
        open val progressTracker: ProgressTracker
        fun query(): Fix
        fun sign(): LegallyIdentifiable
        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: LegallyIdentifiableNode, wtxBytes: SerializedBytes<WireTransaction>)
        class Client : TimestamperService
          Module Contents Client(stateMachineManager: StateMachineManager, node: LegallyIdentifiableNode)
          val identity: Party
          fun timestamp(wtxBytes: SerializedBytes<WireTransaction>): LegallyIdentifiable
        data class Request
          Module Contents Request(tx: SerializedBytes<WireTransaction>, replyTo: MessageRecipients, replyToTopic: String)
          val replyTo: MessageRecipients
          val replyToTopic: String
          val tx: SerializedBytes<WireTransaction>
        fun call(): LegallyIdentifiable
      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: LegallyIdentifiableNode, 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: LegallyIdentifiableNode
          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: LegallyIdentifiableNode, otherSide: SingleMessageRecipient, acceptablePrice: Amount, typeToBuy: Class<out OwnableState>, sessionID: Long): <ERROR CLASS><SignedTransaction>
        fun runSeller(smm: StateMachineManager, timestampingAuthority: LegallyIdentifiableNode, otherSide: SingleMessageRecipient, assetToSell: StateAndRef<OwnableState>, price: Amount, myKeyPair: KeyPair, buyerSessionID: Long): <ERROR CLASS><SignedTransaction>