// Generated by tools/flatbuffers/generate_user_state.py; do not edit.
@file:OptIn(kotlin.ExperimentalUnsignedTypes::class)
package link.roadio.riff.userstate.model

import com.google.flatbuffers.kotlin.*
import link.roadio.riff.state.fbs.*
import link.roadio.riff.userstate.BoundedReadList
import link.roadio.riff.indexer.storage.flatbuffers.ReadOnlyByteBuffer
import java.nio.ByteBuffer

object UserStateCodec {
    private fun count(n: Int): Int { require(n in 0..1_000_000); return n }
    private fun putInstallationState(b: FlatBufferBuilder, v: InstallationStateModel): Offset<InstallationState> {
        InstallationState.startInstallationState(b)
        InstallationState.addReplayGainTarget(b, ReplayGainTarget(v.replayGainTarget.toUByte()))
        InstallationState.addReplayGainMode(b, ReplayGainMode(v.replayGainMode.toUByte()))
        InstallationState.addDimBacklight(b, DimBacklight(v.dimBacklight.toUByte()))
        v.calibrationPpiY?.let { InstallationState.addCalibrationPpiY(b, it) }
        v.calibrationPpiX?.let { InstallationState.addCalibrationPpiX(b, it) }
        InstallationState.addDiagonalMode(b, DiagonalMode(v.diagonalMode.toUByte()))
        InstallationState.addPlaybackProfileSlot(b, v.playbackProfileSlot.toUByte())
        InstallationState.addActiveProfileSlot(b, v.activeProfileSlot.toUByte())
        InstallationState.addHeader(b, putFileHeader(b, v.header))
        return InstallationState.endInstallationState(b)
    }

    private fun readInstallationState(v: InstallationState): InstallationStateModel = InstallationStateModel(
        header = readFileHeader(checkNotNull(v.header)),
        activeProfileSlot = v.activeProfileSlot.toInt(),
        playbackProfileSlot = v.playbackProfileSlot.toInt(),
        diagonalMode = v.diagonalMode.value.toInt(),
        calibrationPpiX = v.calibrationPpiX,
        calibrationPpiY = v.calibrationPpiY,
        dimBacklight = v.dimBacklight.value.toInt(),
        replayGainMode = v.replayGainMode.value.toInt(),
        replayGainTarget = v.replayGainTarget.value.toInt(),
    )

    private fun putHistoryEntry(b: FlatBufferBuilder, v: HistoryEntryModel): Offset<HistoryEntry> {
        return HistoryEntry.createHistoryEntry(b, v.generation.toULong(), v.mediaHi, v.mediaLo, v.flagsData.toULong())
    }

    private fun readHistoryEntry(v: HistoryEntry): HistoryEntryModel = HistoryEntryModel(
        generation = v.generation.toLong(),
        mediaHi = v.mediaHi,
        mediaLo = v.mediaLo,
        flagsData = v.flagsData.toLong(),
    )

    private fun putListeningHistory(b: FlatBufferBuilder, v: ListeningHistoryModel): Offset<ListeningHistory> {
        b.startVector(32, v.entries.size, 8)
        v.entries.asReversed().forEach { putHistoryEntry(b, it) }
        val entriesOffset = b.endVector<HistoryEntry>()
        ListeningHistory.startListeningHistory(b)
        ListeningHistory.addEntries(b, entriesOffset)
        ListeningHistory.addHeader(b, putFileHeader(b, v.header))
        return ListeningHistory.endListeningHistory(b)
    }

    private fun readListeningHistory(v: ListeningHistory): ListeningHistoryModel = ListeningHistoryModel(
        header = readFileHeader(checkNotNull(v.header)),
        entries = BoundedReadList(count(v.entriesLength)) { i -> readHistoryEntry(checkNotNull(v.entries(i))) },
    )

    private fun putProfileSettings(b: FlatBufferBuilder, v: ProfileSettingsModel): Offset<ProfileSettings> {
        ProfileSettings.startProfileSettings(b)
        ProfileSettings.addAiValence(b, v.aiValence)
        ProfileSettings.addAiArousal(b, v.aiArousal)
        ProfileSettings.addAiPteBands(b, v.aiPteBands.toUByte())
        ProfileSettings.addAiQueueSize(b, v.aiQueueSize.toUByte())
        ProfileSettings.addAudiobookSpeedTenths(b, v.audiobookSpeedTenths.toUByte())
        ProfileSettings.addContentMode(b, ContentKind(v.contentMode.toUByte()))
        ProfileSettings.addIgnoreLeadingArticles(b, v.ignoreLeadingArticles)
        ProfileSettings.addAutoSearch(b, v.autoSearch)
        ProfileSettings.addLongPressStartsPlayback(b, v.longPressStartsPlayback)
        ProfileSettings.addTheme(b, Theme(v.theme.toUByte()))
        return ProfileSettings.endProfileSettings(b)
    }

    private fun readProfileSettings(v: ProfileSettings): ProfileSettingsModel = ProfileSettingsModel(
        theme = v.theme.value.toInt(),
        longPressStartsPlayback = v.longPressStartsPlayback,
        autoSearch = v.autoSearch,
        ignoreLeadingArticles = v.ignoreLeadingArticles,
        contentMode = v.contentMode.value.toInt(),
        audiobookSpeedTenths = v.audiobookSpeedTenths.toInt(),
        aiQueueSize = v.aiQueueSize.toInt(),
        aiPteBands = v.aiPteBands.toInt(),
        aiArousal = v.aiArousal,
        aiValence = v.aiValence,
    )

    private fun putReaction(b: FlatBufferBuilder, v: ReactionModel): Offset<Reaction> {
        val targetOffset = putObjectKey(b, v.target)
        Reaction.startReaction(b)
        Reaction.addBanned(b, v.banned)
        Reaction.addPreference(b, Preference(v.preference.toUByte()))
        Reaction.addTarget(b, targetOffset)
        return Reaction.endReaction(b)
    }

    private fun readReaction(v: Reaction): ReactionModel = ReactionModel(
        target = readObjectKey(checkNotNull(v.target)),
        preference = v.preference.value.toInt(),
        banned = v.banned,
    )

    private fun putClassificationOverride(b: FlatBufferBuilder, v: ClassificationOverrideModel): Offset<ClassificationOverride> {
        val targetOffset = putObjectKey(b, v.target)
        ClassificationOverride.startClassificationOverride(b)
        ClassificationOverride.addKind(b, ContentKind(v.kind.toUByte()))
        ClassificationOverride.addTarget(b, targetOffset)
        return ClassificationOverride.endClassificationOverride(b)
    }

    private fun readClassificationOverride(v: ClassificationOverride): ClassificationOverrideModel = ClassificationOverrideModel(
        target = readObjectKey(checkNotNull(v.target)),
        kind = v.kind.value.toInt(),
    )

    private fun putQueueItem(b: FlatBufferBuilder, v: QueueItemModel): Offset<QueueItem> {
        val labelOffset = b.createString(v.label)
        QueueItem.startQueueItem(b)
        QueueItem.addKnownDurationUs(b, v.knownDurationUs)
        QueueItem.addLabel(b, labelOffset)
        QueueItem.addMediaId(b, putMediaKey(b, v.mediaId))
        v.occurrenceId?.let { QueueItem.addOccurrenceId(b, it.toULong()) }
        return QueueItem.endQueueItem(b)
    }

    private fun readQueueItem(v: QueueItem): QueueItemModel = QueueItemModel(
        occurrenceId = v.occurrenceId?.toLong(),
        mediaId = readMediaKey(checkNotNull(v.mediaId)),
        label = checkNotNull(v.label),
        knownDurationUs = v.knownDurationUs,
    )

    private fun putQueueRevision(b: FlatBufferBuilder, v: QueueRevisionModel): Offset<QueueRevision> {
        val itemsOffset = b.createVectorOfTables(v.items.map { putQueueItem(b, it) }.toTypedArray())
        QueueRevision.startQueueRevision(b)
        QueueRevision.addItems(b, itemsOffset)
        v.id?.let { QueueRevision.addId(b, it.toULong()) }
        return QueueRevision.endQueueRevision(b)
    }

    private fun readQueueRevision(v: QueueRevision): QueueRevisionModel = QueueRevisionModel(
        id = v.id?.toLong(),
        items = BoundedReadList(count(v.itemsLength)) { i -> readQueueItem(checkNotNull(v.items(i))) },
    )

    private fun putCheckpoint(b: FlatBufferBuilder, v: CheckpointModel): Offset<Checkpoint> {
        b.startVector(8, v.shuffleOrder.size, 8)
        v.shuffleOrder.asReversed().forEach { b.add(it.toULong()) }
        val shuffleOrderOffset = b.endVector<ULong>()
        Checkpoint.startCheckpoint(b)
        Checkpoint.addHistoryRecorded(b, v.historyRecorded)
        v.attemptId?.let { Checkpoint.addAttemptId(b, it.toULong()) }
        Checkpoint.addCompleted(b, v.completed)
        v.preferredBindingKey?.let { Checkpoint.addPreferredBindingKey(b, it.toULong()) }
        Checkpoint.addShuffleOrder(b, shuffleOrderOffset)
        Checkpoint.addShuffleEnabled(b, v.shuffleEnabled)
        Checkpoint.addRepeatEnabled(b, v.repeatEnabled)
        Checkpoint.addPlayRequested(b, v.playRequested)
        Checkpoint.addPositionUs(b, v.positionUs)
        v.occurrenceId?.let { Checkpoint.addOccurrenceId(b, it.toULong()) }
        v.revisionId?.let { Checkpoint.addRevisionId(b, it.toULong()) }
        return Checkpoint.endCheckpoint(b)
    }

    private fun readCheckpoint(v: Checkpoint): CheckpointModel = CheckpointModel(
        revisionId = v.revisionId?.toLong(),
        occurrenceId = v.occurrenceId?.toLong(),
        positionUs = v.positionUs,
        playRequested = v.playRequested,
        repeatEnabled = v.repeatEnabled,
        shuffleEnabled = v.shuffleEnabled,
        shuffleOrder = BoundedReadList(count(v.shuffleOrderLength)) { i -> v.shuffleOrder(i).toLong() },
        preferredBindingKey = v.preferredBindingKey?.toLong(),
        completed = v.completed,
        attemptId = v.attemptId?.toLong(),
        historyRecorded = v.historyRecorded,
    )

    private fun putBookmark(b: FlatBufferBuilder, v: BookmarkModel): Offset<Bookmark> {
        val labelOffset = b.createString(v.label)
        Bookmark.startBookmark(b)
        Bookmark.addLabel(b, labelOffset)
        Bookmark.addPositionUs(b, v.positionUs)
        v.occurrenceId?.let { Bookmark.addOccurrenceId(b, it.toULong()) }
        v.id?.let { Bookmark.addId(b, it.toULong()) }
        return Bookmark.endBookmark(b)
    }

    private fun readBookmark(v: Bookmark): BookmarkModel = BookmarkModel(
        id = v.id?.toLong(),
        occurrenceId = v.occurrenceId?.toLong(),
        positionUs = v.positionUs,
        label = checkNotNull(v.label),
    )

    private fun putQueueState(b: FlatBufferBuilder, v: QueueStateModel): Offset<QueueState> {
        val nameOffset = v.name?.let { b.createString(it) }
        val definitionOffset = putQueueRevision(b, v.definition)
        val executionOffset = putQueueRevision(b, v.execution)
        val checkpointOffset = putCheckpoint(b, v.checkpoint)
        val bookmarksOffset = b.createVectorOfTables(v.bookmarks.map { putBookmark(b, it) }.toTypedArray())
        QueueState.startQueueState(b)
        QueueState.addBookmarks(b, bookmarksOffset)
        QueueState.addCheckpoint(b, checkpointOffset)
        QueueState.addExecution(b, executionOffset)
        QueueState.addDefinition(b, definitionOffset)
        v.titleId?.let { QueueState.addTitleId(b, it.toULong()) }
        nameOffset?.let { QueueState.addName(b, it) }
        QueueState.addKind(b, ContentKind(v.kind.toUByte()))
        v.creationId?.let { QueueState.addCreationId(b, it.toULong()) }
        v.id?.let { QueueState.addId(b, it.toULong()) }
        return QueueState.endQueueState(b)
    }

    private fun readQueueState(v: QueueState): QueueStateModel = QueueStateModel(
        id = v.id?.toLong(),
        creationId = v.creationId?.toLong(),
        kind = v.kind.value.toInt(),
        name = v.name,
        titleId = v.titleId?.toLong(),
        definition = readQueueRevision(checkNotNull(v.definition)),
        execution = readQueueRevision(checkNotNull(v.execution)),
        checkpoint = readCheckpoint(checkNotNull(v.checkpoint)),
        bookmarks = BoundedReadList(count(v.bookmarksLength)) { i -> readBookmark(checkNotNull(v.bookmarks(i))) },
    )

    private fun putProfileState(b: FlatBufferBuilder, v: ProfileStateModel): Offset<ProfileState> {
        val settingsOffset = putProfileSettings(b, v.settings)
        val reactionsOffset = b.createVectorOfTables(v.reactions.map { putReaction(b, it) }.toTypedArray())
        val classificationsOffset = b.createVectorOfTables(v.classifications.map { putClassificationOverride(b, it) }.toTypedArray())
        val dynamicQueueOffset = putQueueState(b, v.dynamicQueue)
        val savedQueuesOffset = b.createVectorOfTables(v.savedQueues.map { putQueueState(b, it) }.toTypedArray())
        val lastQueueOffset = v.lastQueue?.let { putQueueRef(b, it) }
        ProfileState.startProfileState(b)
        lastQueueOffset?.let { ProfileState.addLastQueue(b, it) }
        ProfileState.addSavedQueues(b, savedQueuesOffset)
        ProfileState.addDynamicQueue(b, dynamicQueueOffset)
        ProfileState.addClassifications(b, classificationsOffset)
        ProfileState.addReactions(b, reactionsOffset)
        ProfileState.addSettings(b, settingsOffset)
        ProfileState.addHeader(b, putFileHeader(b, v.header))
        return ProfileState.endProfileState(b)
    }

    private fun readProfileState(v: ProfileState): ProfileStateModel = ProfileStateModel(
        header = readFileHeader(checkNotNull(v.header)),
        settings = readProfileSettings(checkNotNull(v.settings)),
        reactions = BoundedReadList(count(v.reactionsLength)) { i -> readReaction(checkNotNull(v.reactions(i))) },
        classifications = BoundedReadList(count(v.classificationsLength)) { i -> readClassificationOverride(checkNotNull(v.classifications(i))) },
        dynamicQueue = readQueueState(checkNotNull(v.dynamicQueue)),
        savedQueues = BoundedReadList(count(v.savedQueuesLength)) { i -> readQueueState(checkNotNull(v.savedQueues(i))) },
        lastQueue = v.lastQueue?.let(::readQueueRef),
    )

    private fun putMediaKey(b: FlatBufferBuilder, v: MediaKeyModel): Offset<MediaKey> {
        return MediaKey.createMediaKey(b, v.hi, v.lo, v.loPresent)
    }

    private fun readMediaKey(v: MediaKey): MediaKeyModel = MediaKeyModel(
        hi = v.hi,
        lo = v.lo,
        loPresent = v.loPresent,
    )

    private fun putWriteReceipt(b: FlatBufferBuilder, v: WriteReceiptModel): Offset<WriteReceipt> {
        return WriteReceipt.createWriteReceipt(b, v.writerId.toULong(), v.sequence.toULong())
    }

    private fun readWriteReceipt(v: WriteReceipt): WriteReceiptModel = WriteReceiptModel(
        writerId = v.writerId.toLong(),
        sequence = v.sequence.toLong(),
    )

    private fun putFileHeader(b: FlatBufferBuilder, v: FileHeaderModel): Offset<FileHeader> {
        return FileHeader.createFileHeader(b, v.generation.toULong(), v.receipt.writerId.toULong(), v.receipt.sequence.toULong(), v.formatVersion.toUInt(), v.profileSlot.toUByte())
    }

    private fun readFileHeader(v: FileHeader): FileHeaderModel = FileHeaderModel(
        generation = v.generation.toLong(),
        receipt = readWriteReceipt(checkNotNull(v.receipt)),
        formatVersion = v.formatVersion.toInt(),
        profileSlot = v.profileSlot.toInt(),
    )

    private fun putObjectKey(b: FlatBufferBuilder, v: ObjectKeyModel): Offset<ObjectKey> {
        ObjectKey.startObjectKey(b)
        v.mediaId?.let { ObjectKey.addMediaId(b, putMediaKey(b, it)) }
        v.objectId?.let { ObjectKey.addObjectId(b, it.toULong()) }
        ObjectKey.addKind(b, ObjectKind(v.kind.toUByte()))
        return ObjectKey.endObjectKey(b)
    }

    private fun readObjectKey(v: ObjectKey): ObjectKeyModel = ObjectKeyModel(
        kind = v.kind.value.toInt(),
        objectId = v.objectId?.toLong(),
        mediaId = v.mediaId?.let(::readMediaKey),
    )

    private fun putQueueRef(b: FlatBufferBuilder, v: QueueRefModel): Offset<QueueRef> {
        QueueRef.startQueueRef(b)
        v.id?.let { QueueRef.addId(b, it.toULong()) }
        return QueueRef.endQueueRef(b)
    }

    private fun readQueueRef(v: QueueRef): QueueRefModel = QueueRefModel(
        id = v.id?.toLong(),
    )

    private fun putFileRef(b: FlatBufferBuilder, v: FileRefModel): Offset<FileRef> {
        val xxh364Offset = b.createString(v.xxh364)
        FileRef.startFileRef(b)
        FileRef.addXxh364(b, xxh364Offset)
        FileRef.addByteLength(b, v.byteLength.toULong())
        v.objectId?.let { FileRef.addObjectId(b, it.toULong()) }
        FileRef.addGeneration(b, v.generation.toULong())
        FileRef.addProfileSlot(b, v.profileSlot.toUByte())
        FileRef.addKind(b, FileKind(v.kind.toUByte()))
        return FileRef.endFileRef(b)
    }

    private fun readFileRef(v: FileRef): FileRefModel = FileRefModel(
        kind = v.kind.value.toInt(),
        profileSlot = v.profileSlot.toInt(),
        generation = v.generation.toLong(),
        objectId = v.objectId?.toLong(),
        byteLength = v.byteLength.toLong(),
        xxh364 = checkNotNull(v.xxh364),
    )

    private fun putStateManifest(b: FlatBufferBuilder, v: StateManifestModel): Offset<StateManifest> {
        val filesOffset = b.createVectorOfTables(v.files.map { putFileRef(b, it) }.toTypedArray())
        StateManifest.startStateManifest(b)
        StateManifest.addFiles(b, filesOffset)
        v.rootId?.let { StateManifest.addRootId(b, it.toULong()) }
        StateManifest.addFormatVersion(b, v.formatVersion.toUInt())
        return StateManifest.endStateManifest(b)
    }

    private fun readStateManifest(v: StateManifest): StateManifestModel = StateManifestModel(
        formatVersion = v.formatVersion.toInt(),
        rootId = v.rootId?.toLong(),
        files = BoundedReadList(count(v.filesLength)) { i -> readFileRef(checkNotNull(v.files(i))) },
    )

    private fun putStatePointer(b: FlatBufferBuilder, v: StatePointerModel): Offset<StatePointer> {
        val xxh364Offset = b.createString(v.xxh364)
        StatePointer.startStatePointer(b)
        StatePointer.addXxh364(b, xxh364Offset)
        StatePointer.addByteLength(b, v.byteLength.toULong())
        v.manifestId?.let { StatePointer.addManifestId(b, it.toULong()) }
        StatePointer.addFormatVersion(b, v.formatVersion.toUInt())
        return StatePointer.endStatePointer(b)
    }

    private fun readStatePointer(v: StatePointer): StatePointerModel = StatePointerModel(
        formatVersion = v.formatVersion.toInt(),
        manifestId = v.manifestId?.toLong(),
        byteLength = v.byteLength.toLong(),
        xxh364 = checkNotNull(v.xxh364),
    )

    private fun putUserStateWrite(b: FlatBufferBuilder, v: UserStateWriteModel): Offset<UserStateWrite> {
        val profileOffset = v.profile?.let { putProfileState(b, it) }
        val installationOffset = v.installation?.let { putInstallationState(b, it) }
        UserStateWrite.startUserStateWrite(b)
        v.start?.let { UserStateWrite.addStart(b, putMediaKey(b, it)) }
        installationOffset?.let { UserStateWrite.addInstallation(b, it) }
        profileOffset?.let { UserStateWrite.addProfile(b, it) }
        UserStateWrite.addSequence(b, v.sequence.toULong())
        UserStateWrite.addProfileSlot(b, v.profileSlot.toUByte())
        UserStateWrite.addKind(b, UserStateWriteKind(v.kind.toUByte()))
        return UserStateWrite.endUserStateWrite(b)
    }

    private fun readUserStateWrite(v: UserStateWrite): UserStateWriteModel = UserStateWriteModel(
        kind = v.kind.value.toInt(),
        profileSlot = v.profileSlot.toInt(),
        sequence = v.sequence.toLong(),
        profile = v.profile?.let(::readProfileState),
        installation = v.installation?.let(::readInstallationState),
        start = v.start?.let(::readMediaKey),
    )

    private fun putUserStateCommand(b: FlatBufferBuilder, v: UserStateCommandModel): Offset<UserStateCommand> {
        val writesOffset = b.createVectorOfTables(v.writes.map { putUserStateWrite(b, it) }.toTypedArray())
        UserStateCommand.startUserStateCommand(b)
        UserStateCommand.addWrites(b, writesOffset)
        v.writerId?.let { UserStateCommand.addWriterId(b, it.toULong()) }
        v.rootId?.let { UserStateCommand.addRootId(b, it.toULong()) }
        UserStateCommand.addProtocolVersion(b, v.protocolVersion.toUInt())
        return UserStateCommand.endUserStateCommand(b)
    }

    private fun readUserStateCommand(v: UserStateCommand): UserStateCommandModel = UserStateCommandModel(
        protocolVersion = v.protocolVersion.toInt(),
        rootId = v.rootId?.toLong(),
        writerId = v.writerId?.toLong(),
        writes = BoundedReadList(count(v.writesLength)) { i -> readUserStateWrite(checkNotNull(v.writes(i))) },
    )

    fun encode(v: ProfileStateModel): ByteArray {
        val b = FlatBufferBuilder(1024)
        b.finish(putProfileState(b, v), "PFST")
        return b.sizedByteArray()
    }
    fun decodeProfileState(bytes: ByteArray): ProfileStateModel = readProfileState(ByteBuffer.wrap(bytes.copyOf()).asReadOnlyBuffer())
    fun readProfileState(bytes: ByteBuffer): ProfileStateModel {
        require(bytes.isReadOnly)
        val view = bytes.slice().asReadOnlyBuffer()
        link.roadio.riff.userstate.UserStateWireVerifier.verify(view, "ProfileState")
        val buffer = ReadOnlyByteBuffer(view)
        require(ProfileState.ProfileStateBufferHasIdentifier(buffer))
        return readProfileState(ProfileState.asRoot(buffer))
    }
    fun encode(v: ListeningHistoryModel): ByteArray {
        val b = FlatBufferBuilder(1024)
        b.finish(putListeningHistory(b, v), "PHST")
        return b.sizedByteArray()
    }
    fun decodeListeningHistory(bytes: ByteArray): ListeningHistoryModel = readListeningHistory(ByteBuffer.wrap(bytes.copyOf()).asReadOnlyBuffer())
    fun readListeningHistory(bytes: ByteBuffer): ListeningHistoryModel {
        require(bytes.isReadOnly)
        val view = bytes.slice().asReadOnlyBuffer()
        link.roadio.riff.userstate.UserStateWireVerifier.verify(view, "ListeningHistory")
        val buffer = ReadOnlyByteBuffer(view)
        require(ListeningHistory.ListeningHistoryBufferHasIdentifier(buffer))
        return readListeningHistory(ListeningHistory.asRoot(buffer))
    }
    fun encode(v: InstallationStateModel): ByteArray {
        val b = FlatBufferBuilder(1024)
        b.finish(putInstallationState(b, v), "INST")
        return b.sizedByteArray()
    }
    fun decodeInstallationState(bytes: ByteArray): InstallationStateModel = readInstallationState(ByteBuffer.wrap(bytes.copyOf()).asReadOnlyBuffer())
    fun readInstallationState(bytes: ByteBuffer): InstallationStateModel {
        require(bytes.isReadOnly)
        val view = bytes.slice().asReadOnlyBuffer()
        link.roadio.riff.userstate.UserStateWireVerifier.verify(view, "InstallationState")
        val buffer = ReadOnlyByteBuffer(view)
        require(InstallationState.InstallationStateBufferHasIdentifier(buffer))
        return readInstallationState(InstallationState.asRoot(buffer))
    }
    fun encode(v: StateManifestModel): ByteArray {
        val b = FlatBufferBuilder(1024)
        b.finish(putStateManifest(b, v), "SMNF")
        return b.sizedByteArray()
    }
    fun decodeStateManifest(bytes: ByteArray): StateManifestModel = readStateManifest(ByteBuffer.wrap(bytes.copyOf()).asReadOnlyBuffer())
    fun readStateManifest(bytes: ByteBuffer): StateManifestModel {
        require(bytes.isReadOnly)
        val view = bytes.slice().asReadOnlyBuffer()
        link.roadio.riff.userstate.UserStateWireVerifier.verify(view, "StateManifest")
        val buffer = ReadOnlyByteBuffer(view)
        require(StateManifest.StateManifestBufferHasIdentifier(buffer))
        return readStateManifest(StateManifest.asRoot(buffer))
    }
    fun encode(v: StatePointerModel): ByteArray {
        val b = FlatBufferBuilder(1024)
        b.finish(putStatePointer(b, v), "SPTR")
        return b.sizedByteArray()
    }
    fun decodeStatePointer(bytes: ByteArray): StatePointerModel = readStatePointer(ByteBuffer.wrap(bytes.copyOf()).asReadOnlyBuffer())
    fun readStatePointer(bytes: ByteBuffer): StatePointerModel {
        require(bytes.isReadOnly)
        val view = bytes.slice().asReadOnlyBuffer()
        link.roadio.riff.userstate.UserStateWireVerifier.verify(view, "StatePointer")
        val buffer = ReadOnlyByteBuffer(view)
        require(StatePointer.StatePointerBufferHasIdentifier(buffer))
        return readStatePointer(StatePointer.asRoot(buffer))
    }
    fun encode(v: UserStateCommandModel): ByteArray {
        val b = FlatBufferBuilder(1024)
        b.finish(putUserStateCommand(b, v), "UCMD")
        return b.sizedByteArray()
    }
    fun decodeUserStateCommand(bytes: ByteArray): UserStateCommandModel = readUserStateCommand(ByteBuffer.wrap(bytes.copyOf()).asReadOnlyBuffer())
    fun readUserStateCommand(bytes: ByteBuffer): UserStateCommandModel {
        require(bytes.isReadOnly)
        val view = bytes.slice().asReadOnlyBuffer()
        link.roadio.riff.userstate.UserStateWireVerifier.verify(view, "UserStateCommand")
        val buffer = ReadOnlyByteBuffer(view)
        require(UserStateCommand.UserStateCommandBufferHasIdentifier(buffer))
        return readUserStateCommand(UserStateCommand.asRoot(buffer))
    }
}