SkStream = ref object of SkObject[sk_stream_t]

SkWStream = ref object of SkObject[sk_wstream_t]

SkStreamRewindable = ref object of SkStream

SkStreamSeekable = ref object of SkStreamRewindable

SkStreamAsset = ref object of SkStreamSeekable

SkFileStream = ref object of SkStreamAsset

SkMemoryStream = ref object of SkStreamAsset

SkFileWStream = ref object of SkWStream

proc isAtEnd(s: SkStream): bool {...}{.raises: [], tags: [].}

proc hasPosition(s: SkStreamSeekable): bool {...}{.raises: [], tags: [].}

proc hasLength(s: SkStreamAsset): bool {...}{.raises: [], tags: [].}

proc getPosition(s: SkStreamSeekable): int {...}{.raises: [], tags: [].}

proc getLength(s: SkStreamAsset): int {...}{.raises: [], tags: [].}

proc read(s: SkStream; buffer: pointer; size: int): int {...}{.raises: [], tags: [].}

proc peek(s: SkStream; buffer: pointer; size: int): int {...}{.raises: [], tags: [].}

proc readByte(s: SkStream; buffer: var int8): bool {...}{.raises: [], tags: [].}

proc readInt16(s: SkStream; buffer: var int16): bool {...}{.raises: [], tags: [].}

proc readInt32(s: SkStream; buffer: var int32): bool {...}{.raises: [], tags: [].}

proc readUByte(s: SkStream; buffer: var uint8): bool {...}{.raises: [], tags: [].}

proc readUInt16(s: SkStream; buffer: var uint16): bool {...}{.raises: [], tags: [].}

proc readUInt32(s: SkStream; buffer: var uint32): bool {...}{.raises: [], tags: [].}

proc readBool(s: SkStream; buffer: var bool): bool {...}{.raises: [], tags: [].}

proc readByte(s: SkStream): int8 {...}{.raises: [], tags: [].}

proc readInt16(s: SkStream): int16 {...}{.raises: [], tags: [].}

proc readInt32(s: SkStream): int32 {...}{.raises: [], tags: [].}

proc readUByte(s: SkStream): uint8 {...}{.raises: [], tags: [].}

proc readUInt16(s: SkStream): uint16 {...}{.raises: [], tags: [].}

proc readUInt32(s: SkStream): uint32 {...}{.raises: [], tags: [].}

proc readBool(s: SkStream): bool {...}{.raises: [], tags: [].}

proc skip(s: SkStream; size: int): int {...}{.raises: [], tags: [].}

proc rewind(s: SkStreamRewindable): bool {...}{.raises: [], tags: [].}

proc seek(s: SkStreamSeekable; position: int): bool {...}{.raises: [], tags: [].}

proc move(s: SkStreamSeekable; offset: int): bool {...}{.raises: [], tags: [].}

proc fork(s: SkStreamSeekable): SkStreamSeekable {...}{.raises: [], tags: [].}

proc duplicate(s: SkStreamRewindable): SkStreamRewindable {...}{.raises: [], tags: [].}

proc dispose(s: SkStream) {...}{.raises: [], tags: [].}

proc dispose(s: SkFileStream) {...}{.raises: [], tags: [].}

proc isValid(s: SkFileStream): bool {...}{.raises: [], tags: [].}

proc newSkFileStream(path: string): SkFileStream {...}{.raises: [], tags: [].}

proc openSkFileStream(path: string): SkFileStream {...}{.raises: [], tags: [].}

proc newSkMemoryStream(): SkMemoryStream {...}{.raises: [UnsupportedOperationError],
                                        tags: [].}

proc newSkMemoryStream(length: int): SkMemoryStream {...}{.
    raises: [UnsupportedOperationError], tags: [].}

proc newSkMemoryStream(data: pointer; length: int; copyData: bool): SkMemoryStream {...}{.
    raises: [UnsupportedOperationError], tags: [].}

proc newSkMemoryStream(data: SkData): SkMemoryStream {...}{.
    raises: [UnsupportedOperationError], tags: [].}

proc dispose(s: SkMemoryStream) {...}{.raises: [], tags: [].}

proc setMemory(s: SkMemoryStream; data: pointer; length: int; copyData: bool = false) {...}{.
    raises: [], tags: [].}

proc setMemory(s: SkMemoryStream; data: seq[byte]; copyData: bool = false) {...}{.raises: [],
    tags: [].}

proc newSkMemoryStream(data: seq[byte]): SkMemoryStream {...}{.
    raises: [UnsupportedOperationError], tags: [].}

proc write8(s: SkWStream; value: uint8): bool {...}{.raises: [], tags: [].}

proc write16(s: SkWStream; value: uint16): bool {...}{.raises: [], tags: [].}

proc write32(s: SkWStream; value: uint32): bool {...}{.raises: [], tags: [].}

proc writeText(s: SkWStream; value: string): bool {...}{.raises: [], tags: [].}

proc writeDecimalAsText(s: SkWStream; value: int32): bool {...}{.raises: [], tags: [].}

proc writeBigDecimalAsText(s: SkWStream; value: int64; digits: int32): bool {...}{.
    raises: [], tags: [].}

proc writeHexAsText(s: SkWStream; value: uint32; digits: int32): bool {...}{.raises: [],
    tags: [].}

proc writeScalarAsText(s: SkWStream; value: float): bool {...}{.raises: [], tags: [].}

proc writeBool(s: SkWStream; value: bool): bool {...}{.raises: [], tags: [].}

proc writeScalar(s: SkWStream; value: float): bool {...}{.raises: [], tags: [].}

proc writeStream(s: SkWStream; input: SkStream; length: int): bool {...}{.raises: [], tags: [].}

proc newSkFileWStream(path: string): SkFileWStream {...}{.
    raises: [UnsupportedOperationError], tags: [].}

proc dispose(s: SkFileWStream) {...}{.raises: [], tags: [].}

proc openSkFileWStream(path: string): SkFileWStream {...}{.
    raises: [UnsupportedOperationError], tags: [].}

template isValid(s: SkFileWStream): bool