// @generated - post-processed by compile-bare.ts
import * as bare from "@rivetkit/bare-ts"

const config = /* @__PURE__ */ bare.Config({})

export type u32 = number
export type u64 = bigint

export type Cbor = ArrayBuffer

export function readCbor(bc: bare.ByteCursor): Cbor {
    return bare.readData(bc)
}

export function writeCbor(bc: bare.ByteCursor, x: Cbor): void {
    bare.writeData(bc, x)
}

export type NameIndex = u32

export function readNameIndex(bc: bare.ByteCursor): NameIndex {
    return bare.readU32(bc)
}

export function writeNameIndex(bc: bare.ByteCursor, x: NameIndex): void {
    bare.writeU32(bc, x)
}

export type LoopIterationMarker = {
    readonly loop: NameIndex,
    readonly iteration: u32,
}

export function readLoopIterationMarker(bc: bare.ByteCursor): LoopIterationMarker {
    return {
        loop: readNameIndex(bc),
        iteration: bare.readU32(bc),
    }
}

export function writeLoopIterationMarker(bc: bare.ByteCursor, x: LoopIterationMarker): void {
    writeNameIndex(bc, x.loop)
    bare.writeU32(bc, x.iteration)
}

export type PathSegment =
    | { readonly tag: "NameIndex", readonly val: NameIndex }
    | { readonly tag: "LoopIterationMarker", readonly val: LoopIterationMarker }

export function readPathSegment(bc: bare.ByteCursor): PathSegment {
    const offset = bc.offset
    const tag = bare.readU8(bc)
    switch (tag) {
        case 0:
            return { tag: "NameIndex", val: readNameIndex(bc) }
        case 1:
            return { tag: "LoopIterationMarker", val: readLoopIterationMarker(bc) }
        default: {
            bc.offset = offset
            throw new bare.BareError(offset, "invalid tag")
        }
    }
}

export function writePathSegment(bc: bare.ByteCursor, x: PathSegment): void {
    switch (x.tag) {
        case "NameIndex": {
            bare.writeU8(bc, 0)
            writeNameIndex(bc, x.val)
            break
        }
        case "LoopIterationMarker": {
            bare.writeU8(bc, 1)
            writeLoopIterationMarker(bc, x.val)
            break
        }
    }
}

export type Location = readonly PathSegment[]

export function readLocation(bc: bare.ByteCursor): Location {
    const len = bare.readUintSafe(bc)
    if (len === 0) { return [] }
    const result = [readPathSegment(bc)]
    for (let i = 1; i < len; i++) {
        result[i] = readPathSegment(bc)
    }
    return result
}

export function writeLocation(bc: bare.ByteCursor, x: Location): void {
    bare.writeUintSafe(bc, x.length)
    for (let i = 0; i < x.length; i++) {
        writePathSegment(bc, x[i])
    }
}

export enum EntryStatus {
    PENDING = "PENDING",
    RUNNING = "RUNNING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED",
    EXHAUSTED = "EXHAUSTED",
}

export function readEntryStatus(bc: bare.ByteCursor): EntryStatus {
    const offset = bc.offset
    const tag = bare.readU8(bc)
    switch (tag) {
        case 0:
            return EntryStatus.PENDING
        case 1:
            return EntryStatus.RUNNING
        case 2:
            return EntryStatus.COMPLETED
        case 3:
            return EntryStatus.FAILED
        case 4:
            return EntryStatus.EXHAUSTED
        default: {
            bc.offset = offset
            throw new bare.BareError(offset, "invalid tag")
        }
    }
}

export function writeEntryStatus(bc: bare.ByteCursor, x: EntryStatus): void {
    switch (x) {
        case EntryStatus.PENDING: {
            bare.writeU8(bc, 0)
            break
        }
        case EntryStatus.RUNNING: {
            bare.writeU8(bc, 1)
            break
        }
        case EntryStatus.COMPLETED: {
            bare.writeU8(bc, 2)
            break
        }
        case EntryStatus.FAILED: {
            bare.writeU8(bc, 3)
            break
        }
        case EntryStatus.EXHAUSTED: {
            bare.writeU8(bc, 4)
            break
        }
    }
}

export enum SleepState {
    PENDING = "PENDING",
    COMPLETED = "COMPLETED",
    INTERRUPTED = "INTERRUPTED",
}

export function readSleepState(bc: bare.ByteCursor): SleepState {
    const offset = bc.offset
    const tag = bare.readU8(bc)
    switch (tag) {
        case 0:
            return SleepState.PENDING
        case 1:
            return SleepState.COMPLETED
        case 2:
            return SleepState.INTERRUPTED
        default: {
            bc.offset = offset
            throw new bare.BareError(offset, "invalid tag")
        }
    }
}

export function writeSleepState(bc: bare.ByteCursor, x: SleepState): void {
    switch (x) {
        case SleepState.PENDING: {
            bare.writeU8(bc, 0)
            break
        }
        case SleepState.COMPLETED: {
            bare.writeU8(bc, 1)
            break
        }
        case SleepState.INTERRUPTED: {
            bare.writeU8(bc, 2)
            break
        }
    }
}

export enum BranchStatusType {
    PENDING = "PENDING",
    RUNNING = "RUNNING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED",
    CANCELLED = "CANCELLED",
}

export function readBranchStatusType(bc: bare.ByteCursor): BranchStatusType {
    const offset = bc.offset
    const tag = bare.readU8(bc)
    switch (tag) {
        case 0:
            return BranchStatusType.PENDING
        case 1:
            return BranchStatusType.RUNNING
        case 2:
            return BranchStatusType.COMPLETED
        case 3:
            return BranchStatusType.FAILED
        case 4:
            return BranchStatusType.CANCELLED
        default: {
            bc.offset = offset
            throw new bare.BareError(offset, "invalid tag")
        }
    }
}

export function writeBranchStatusType(bc: bare.ByteCursor, x: BranchStatusType): void {
    switch (x) {
        case BranchStatusType.PENDING: {
            bare.writeU8(bc, 0)
            break
        }
        case BranchStatusType.RUNNING: {
            bare.writeU8(bc, 1)
            break
        }
        case BranchStatusType.COMPLETED: {
            bare.writeU8(bc, 2)
            break
        }
        case BranchStatusType.FAILED: {
            bare.writeU8(bc, 3)
            break
        }
        case BranchStatusType.CANCELLED: {
            bare.writeU8(bc, 4)
            break
        }
    }
}

function read0(bc: bare.ByteCursor): Cbor | null {
    return bare.readBool(bc)
        ? readCbor(bc)
        : null
}

function write0(bc: bare.ByteCursor, x: Cbor | null): void {
    bare.writeBool(bc, x !== null)
    if (x !== null) {
        writeCbor(bc, x)
    }
}

function read1(bc: bare.ByteCursor): string | null {
    return bare.readBool(bc)
        ? bare.readString(bc)
        : null
}

function write1(bc: bare.ByteCursor, x: string | null): void {
    bare.writeBool(bc, x !== null)
    if (x !== null) {
        bare.writeString(bc, x)
    }
}

export type StepEntry = {
    readonly output: Cbor | null,
    readonly error: string | null,
}

export function readStepEntry(bc: bare.ByteCursor): StepEntry {
    return {
        output: read0(bc),
        error: read1(bc),
    }
}

export function writeStepEntry(bc: bare.ByteCursor, x: StepEntry): void {
    write0(bc, x.output)
    write1(bc, x.error)
}

export type LoopEntry = {
    readonly state: Cbor,
    readonly iteration: u32,
    readonly output: Cbor | null,
}

export function readLoopEntry(bc: bare.ByteCursor): LoopEntry {
    return {
        state: readCbor(bc),
        iteration: bare.readU32(bc),
        output: read0(bc),
    }
}

export function writeLoopEntry(bc: bare.ByteCursor, x: LoopEntry): void {
    writeCbor(bc, x.state)
    bare.writeU32(bc, x.iteration)
    write0(bc, x.output)
}

export type SleepEntry = {
    readonly deadline: u64,
    readonly state: SleepState,
}

export function readSleepEntry(bc: bare.ByteCursor): SleepEntry {
    return {
        deadline: bare.readU64(bc),
        state: readSleepState(bc),
    }
}

export function writeSleepEntry(bc: bare.ByteCursor, x: SleepEntry): void {
    bare.writeU64(bc, x.deadline)
    writeSleepState(bc, x.state)
}

export type MessageEntry = {
    readonly name: string,
    readonly messageData: Cbor,
}

export function readMessageEntry(bc: bare.ByteCursor): MessageEntry {
    return {
        name: bare.readString(bc),
        messageData: readCbor(bc),
    }
}

export function writeMessageEntry(bc: bare.ByteCursor, x: MessageEntry): void {
    bare.writeString(bc, x.name)
    writeCbor(bc, x.messageData)
}

export type RollbackCheckpointEntry = {
    readonly name: string,
}

export function readRollbackCheckpointEntry(bc: bare.ByteCursor): RollbackCheckpointEntry {
    return {
        name: bare.readString(bc),
    }
}

export function writeRollbackCheckpointEntry(bc: bare.ByteCursor, x: RollbackCheckpointEntry): void {
    bare.writeString(bc, x.name)
}

export type BranchStatus = {
    readonly status: BranchStatusType,
    readonly output: Cbor | null,
    readonly error: string | null,
}

export function readBranchStatus(bc: bare.ByteCursor): BranchStatus {
    return {
        status: readBranchStatusType(bc),
        output: read0(bc),
        error: read1(bc),
    }
}

export function writeBranchStatus(bc: bare.ByteCursor, x: BranchStatus): void {
    writeBranchStatusType(bc, x.status)
    write0(bc, x.output)
    write1(bc, x.error)
}

function read2(bc: bare.ByteCursor): ReadonlyMap<string, BranchStatus> {
    const len = bare.readUintSafe(bc)
    const result = new Map<string, BranchStatus>()
    for (let i = 0; i < len; i++) {
        const offset = bc.offset
        const key = bare.readString(bc)
        if (result.has(key)) {
            bc.offset = offset
            throw new bare.BareError(offset, "duplicated key")
        }
        result.set(key, readBranchStatus(bc))
    }
    return result
}

function write2(bc: bare.ByteCursor, x: ReadonlyMap<string, BranchStatus>): void {
    bare.writeUintSafe(bc, x.size)
    for(const kv of x) {
        bare.writeString(bc, kv[0])
        writeBranchStatus(bc, kv[1])
    }
}

export type JoinEntry = {
    readonly branches: ReadonlyMap<string, BranchStatus>,
}

export function readJoinEntry(bc: bare.ByteCursor): JoinEntry {
    return {
        branches: read2(bc),
    }
}

export function writeJoinEntry(bc: bare.ByteCursor, x: JoinEntry): void {
    write2(bc, x.branches)
}

export type RaceEntry = {
    readonly winner: string | null,
    readonly branches: ReadonlyMap<string, BranchStatus>,
}

export function readRaceEntry(bc: bare.ByteCursor): RaceEntry {
    return {
        winner: read1(bc),
        branches: read2(bc),
    }
}

export function writeRaceEntry(bc: bare.ByteCursor, x: RaceEntry): void {
    write1(bc, x.winner)
    write2(bc, x.branches)
}

export type RemovedEntry = {
    readonly originalType: string,
    readonly originalName: string | null,
}

export function readRemovedEntry(bc: bare.ByteCursor): RemovedEntry {
    return {
        originalType: bare.readString(bc),
        originalName: read1(bc),
    }
}

export function writeRemovedEntry(bc: bare.ByteCursor, x: RemovedEntry): void {
    bare.writeString(bc, x.originalType)
    write1(bc, x.originalName)
}

export type VersionCheckEntry = {
    readonly resolved: u32,
    readonly latest: u32,
}

export function readVersionCheckEntry(bc: bare.ByteCursor): VersionCheckEntry {
    return {
        resolved: bare.readU32(bc),
        latest: bare.readU32(bc),
    }
}

export function writeVersionCheckEntry(bc: bare.ByteCursor, x: VersionCheckEntry): void {
    bare.writeU32(bc, x.resolved)
    bare.writeU32(bc, x.latest)
}

export type EntryKind =
    | { readonly tag: "StepEntry", readonly val: StepEntry }
    | { readonly tag: "LoopEntry", readonly val: LoopEntry }
    | { readonly tag: "SleepEntry", readonly val: SleepEntry }
    | { readonly tag: "MessageEntry", readonly val: MessageEntry }
    | { readonly tag: "RollbackCheckpointEntry", readonly val: RollbackCheckpointEntry }
    | { readonly tag: "JoinEntry", readonly val: JoinEntry }
    | { readonly tag: "RaceEntry", readonly val: RaceEntry }
    | { readonly tag: "RemovedEntry", readonly val: RemovedEntry }
    | { readonly tag: "VersionCheckEntry", readonly val: VersionCheckEntry }

export function readEntryKind(bc: bare.ByteCursor): EntryKind {
    const offset = bc.offset
    const tag = bare.readU8(bc)
    switch (tag) {
        case 0:
            return { tag: "StepEntry", val: readStepEntry(bc) }
        case 1:
            return { tag: "LoopEntry", val: readLoopEntry(bc) }
        case 2:
            return { tag: "SleepEntry", val: readSleepEntry(bc) }
        case 3:
            return { tag: "MessageEntry", val: readMessageEntry(bc) }
        case 4:
            return { tag: "RollbackCheckpointEntry", val: readRollbackCheckpointEntry(bc) }
        case 5:
            return { tag: "JoinEntry", val: readJoinEntry(bc) }
        case 6:
            return { tag: "RaceEntry", val: readRaceEntry(bc) }
        case 7:
            return { tag: "RemovedEntry", val: readRemovedEntry(bc) }
        case 8:
            return { tag: "VersionCheckEntry", val: readVersionCheckEntry(bc) }
        default: {
            bc.offset = offset
            throw new bare.BareError(offset, "invalid tag")
        }
    }
}

export function writeEntryKind(bc: bare.ByteCursor, x: EntryKind): void {
    switch (x.tag) {
        case "StepEntry": {
            bare.writeU8(bc, 0)
            writeStepEntry(bc, x.val)
            break
        }
        case "LoopEntry": {
            bare.writeU8(bc, 1)
            writeLoopEntry(bc, x.val)
            break
        }
        case "SleepEntry": {
            bare.writeU8(bc, 2)
            writeSleepEntry(bc, x.val)
            break
        }
        case "MessageEntry": {
            bare.writeU8(bc, 3)
            writeMessageEntry(bc, x.val)
            break
        }
        case "RollbackCheckpointEntry": {
            bare.writeU8(bc, 4)
            writeRollbackCheckpointEntry(bc, x.val)
            break
        }
        case "JoinEntry": {
            bare.writeU8(bc, 5)
            writeJoinEntry(bc, x.val)
            break
        }
        case "RaceEntry": {
            bare.writeU8(bc, 6)
            writeRaceEntry(bc, x.val)
            break
        }
        case "RemovedEntry": {
            bare.writeU8(bc, 7)
            writeRemovedEntry(bc, x.val)
            break
        }
        case "VersionCheckEntry": {
            bare.writeU8(bc, 8)
            writeVersionCheckEntry(bc, x.val)
            break
        }
    }
}

export type Entry = {
    readonly id: string,
    readonly location: Location,
    readonly kind: EntryKind,
}

export function readEntry(bc: bare.ByteCursor): Entry {
    return {
        id: bare.readString(bc),
        location: readLocation(bc),
        kind: readEntryKind(bc),
    }
}

export function writeEntry(bc: bare.ByteCursor, x: Entry): void {
    bare.writeString(bc, x.id)
    writeLocation(bc, x.location)
    writeEntryKind(bc, x.kind)
}

export function encodeEntry(x: Entry): Uint8Array {
    const bc = new bare.ByteCursor(
        new Uint8Array(config.initialBufferLength),
        config
    )
    writeEntry(bc, x)
    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
}

export function decodeEntry(bytes: Uint8Array): Entry {
    const bc = new bare.ByteCursor(bytes, config)
    const result = readEntry(bc)
    if (bc.offset < bc.view.byteLength) {
        throw new bare.BareError(bc.offset, "remaining bytes")
    }
    return result
}

function read3(bc: bare.ByteCursor): u64 | null {
    return bare.readBool(bc)
        ? bare.readU64(bc)
        : null
}

function write3(bc: bare.ByteCursor, x: u64 | null): void {
    bare.writeBool(bc, x !== null)
    if (x !== null) {
        bare.writeU64(bc, x)
    }
}

export type EntryMetadata = {
    readonly status: EntryStatus,
    readonly error: string | null,
    readonly attempts: u32,
    readonly lastAttemptAt: u64,
    readonly createdAt: u64,
    readonly completedAt: u64 | null,
    readonly rollbackCompletedAt: u64 | null,
    readonly rollbackError: string | null,
}

export function readEntryMetadata(bc: bare.ByteCursor): EntryMetadata {
    return {
        status: readEntryStatus(bc),
        error: read1(bc),
        attempts: bare.readU32(bc),
        lastAttemptAt: bare.readU64(bc),
        createdAt: bare.readU64(bc),
        completedAt: read3(bc),
        rollbackCompletedAt: read3(bc),
        rollbackError: read1(bc),
    }
}

export function writeEntryMetadata(bc: bare.ByteCursor, x: EntryMetadata): void {
    writeEntryStatus(bc, x.status)
    write1(bc, x.error)
    bare.writeU32(bc, x.attempts)
    bare.writeU64(bc, x.lastAttemptAt)
    bare.writeU64(bc, x.createdAt)
    write3(bc, x.completedAt)
    write3(bc, x.rollbackCompletedAt)
    write1(bc, x.rollbackError)
}

export function encodeEntryMetadata(x: EntryMetadata): Uint8Array {
    const bc = new bare.ByteCursor(
        new Uint8Array(config.initialBufferLength),
        config
    )
    writeEntryMetadata(bc, x)
    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
}

export function decodeEntryMetadata(bytes: Uint8Array): EntryMetadata {
    const bc = new bare.ByteCursor(bytes, config)
    const result = readEntryMetadata(bc)
    if (bc.offset < bc.view.byteLength) {
        throw new bare.BareError(bc.offset, "remaining bytes")
    }
    return result
}

export type Message = {
    readonly id: string,
    readonly name: string,
    readonly messageData: Cbor,
    readonly sentAt: u64,
}

export function readMessage(bc: bare.ByteCursor): Message {
    return {
        id: bare.readString(bc),
        name: bare.readString(bc),
        messageData: readCbor(bc),
        sentAt: bare.readU64(bc),
    }
}

export function writeMessage(bc: bare.ByteCursor, x: Message): void {
    bare.writeString(bc, x.id)
    bare.writeString(bc, x.name)
    writeCbor(bc, x.messageData)
    bare.writeU64(bc, x.sentAt)
}

export function encodeMessage(x: Message): Uint8Array {
    const bc = new bare.ByteCursor(
        new Uint8Array(config.initialBufferLength),
        config
    )
    writeMessage(bc, x)
    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
}

export function decodeMessage(bytes: Uint8Array): Message {
    const bc = new bare.ByteCursor(bytes, config)
    const result = readMessage(bc)
    if (bc.offset < bc.view.byteLength) {
        throw new bare.BareError(bc.offset, "remaining bytes")
    }
    return result
}

export enum WorkflowState {
    PENDING = "PENDING",
    RUNNING = "RUNNING",
    SLEEPING = "SLEEPING",
    FAILED = "FAILED",
    COMPLETED = "COMPLETED",
    ROLLING_BACK = "ROLLING_BACK",
}

export function readWorkflowState(bc: bare.ByteCursor): WorkflowState {
    const offset = bc.offset
    const tag = bare.readU8(bc)
    switch (tag) {
        case 0:
            return WorkflowState.PENDING
        case 1:
            return WorkflowState.RUNNING
        case 2:
            return WorkflowState.SLEEPING
        case 3:
            return WorkflowState.FAILED
        case 4:
            return WorkflowState.COMPLETED
        case 5:
            return WorkflowState.ROLLING_BACK
        default: {
            bc.offset = offset
            throw new bare.BareError(offset, "invalid tag")
        }
    }
}

export function writeWorkflowState(bc: bare.ByteCursor, x: WorkflowState): void {
    switch (x) {
        case WorkflowState.PENDING: {
            bare.writeU8(bc, 0)
            break
        }
        case WorkflowState.RUNNING: {
            bare.writeU8(bc, 1)
            break
        }
        case WorkflowState.SLEEPING: {
            bare.writeU8(bc, 2)
            break
        }
        case WorkflowState.FAILED: {
            bare.writeU8(bc, 3)
            break
        }
        case WorkflowState.COMPLETED: {
            bare.writeU8(bc, 4)
            break
        }
        case WorkflowState.ROLLING_BACK: {
            bare.writeU8(bc, 5)
            break
        }
    }
}

export type WorkflowMetadata = {
    readonly state: WorkflowState,
    readonly output: Cbor | null,
    readonly error: string | null,
    readonly version: string | null,
}

export function readWorkflowMetadata(bc: bare.ByteCursor): WorkflowMetadata {
    return {
        state: readWorkflowState(bc),
        output: read0(bc),
        error: read1(bc),
        version: read1(bc),
    }
}

export function writeWorkflowMetadata(bc: bare.ByteCursor, x: WorkflowMetadata): void {
    writeWorkflowState(bc, x.state)
    write0(bc, x.output)
    write1(bc, x.error)
    write1(bc, x.version)
}

export function encodeWorkflowMetadata(x: WorkflowMetadata): Uint8Array {
    const bc = new bare.ByteCursor(
        new Uint8Array(config.initialBufferLength),
        config
    )
    writeWorkflowMetadata(bc, x)
    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
}

export function decodeWorkflowMetadata(bytes: Uint8Array): WorkflowMetadata {
    const bc = new bare.ByteCursor(bytes, config)
    const result = readWorkflowMetadata(bc)
    if (bc.offset < bc.view.byteLength) {
        throw new bare.BareError(bc.offset, "remaining bytes")
    }
    return result
}


function assert(condition: boolean, message?: string): asserts condition {
    if (!condition) throw new Error(message ?? "Assertion failed")
}