kotlin-actions-artifact/actions.artifact/ZipUploadStream

ZipUploadStream

external class ZipUploadStream : Transform(source)

Constructors

ZipUploadStream

constructor(bufferSize: Number)

Properties

_construct

open override val _construct: (callback: (JsError?) -> Unit) -> Unit?

_writev

open val _writev: (ReadonlyArray<WritableWritevChunksItem>, callback: (JsError?) -> Unit) -> Unit?

allowHalfOpen

var allowHalfOpen: Boolean

closed

open override val closed: Boolean

closeEvent

open override val closeEvent: EventInstance<Tuple>

dataEvent

open override val dataEvent: EventInstance<Tuple1<Any?>>

destroyed

open override var destroyed: Boolean

drainEvent

open override val drainEvent: EventInstance<Tuple>

endEvent

open override val endEvent: EventInstance<Tuple>

errored

open override val errored: JsError?

errorEvent

open override val errorEvent: EventInstance<Tuple1<JsError>>

finishEvent

open override val finishEvent: EventInstance<Tuple>

pauseEvent

open override val pauseEvent: EventInstance<Tuple>

pipeEvent

open override val pipeEvent: EventInstance<Tuple1<Readable>>

readable

open var readable: Boolean

readableAborted

val readableAborted: Boolean

readableDidRead

val readableDidRead: Boolean

readableEncoding

val readableEncoding: BufferEncoding?

readableEnded

val readableEnded: Boolean

readableEvent

open override val readableEvent: EventInstance<Tuple>

readableFlowing

val readableFlowing: Boolean?

readableHighWaterMark

val readableHighWaterMark: Double

readableLength

val readableLength: Double

readableObjectMode

val readableObjectMode: Boolean

readonlyWritable

val readonlyWritable: Boolean

resumeEvent

open override val resumeEvent: EventInstance<Tuple>

unpipeEvent

open override val unpipeEvent: EventInstance<Tuple1<Readable>>

writable

open var writable: Boolean

writableAborted

val writableAborted: Boolean

writableCorked

open val writableCorked: Double

writableEnded

open val writableEnded: Boolean

writableFinished

open val writableFinished: Boolean

writableHighWaterMark

open val writableHighWaterMark: Double

writableLength

open val writableLength: Double

writableNeedDrain

open val writableNeedDrain: Boolean

writableObjectMode

open val writableObjectMode: Boolean

Functions

_destroy

open override fun _destroy(error: JsError?, callback: (JsError?) -> Unit)

_final

open fun _final(callback: (JsError?) -> Unit)

_flush

fun _flush(callback: TransformCallback)

_read

fun _read(size: Number)

_transform

fun _transform(chunk: Any?, enc: Any?, cb: Any?)

fun _transform(chunk: Any?, encoding: BufferEncoding, callback: TransformCallback)

_write

open fun _write(chunk: Any?, encoding: BufferEncoding, callback: (JsError?) -> Unit)

addListener

fun addListener(type: EventType, listener: EventListener)

open override fun addListener(event: Symbol, listener: Function<Unit>)

open override fun addListener(event: String, listener: Function<Unit>)

asIndexedPairs

fun asIndexedPairs(options: ArrayOptions): Readable

compose

fun <T : ReadableStream> compose(stream: T, options: StreamComposeOptions): T

fun <T : ReadableStream> compose(stream: AsyncIterable<T>, options: StreamComposeOptions): T

fun <T : ReadableStream> compose(stream: JsIterable<T>, options: StreamComposeOptions): T

fun <T : ReadableStream> compose(stream: ComposeFnParam, options: StreamComposeOptions): T

cork

open fun cork()

destroy

open override fun destroy()

open override fun destroy(error: JsError)

drop

fun drop(limit: Number, options: ArrayOptions): Readable

emit

fun emit(type: EventType, vararg args: Any?): Boolean

open override fun emit(event: Symbol, vararg args: Any?): Boolean

open override fun emit(event: String, vararg args: Any?): Boolean

end

open fun end(cb: () -> Unit)

open fun end(data: Uint8Array<*>, cb: () -> Unit)

open fun end(data: String, cb: () -> Unit)

open fun end(str: String, encoding: BufferEncoding, cb: () -> Unit)

open fun end(chunk: Any?, cb: () -> Unit)

open fun end(chunk: Any?, encoding: BufferEncoding, cb: () -> Unit)

eventNames

fun eventNames(): ReadonlyArray<EventType>

every

suspend fun every(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Boolean>, options: ArrayOptions): Boolean

everyAsync

fun everyAsync(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Boolean>, options: ArrayOptions): Promise<Boolean>

filter

fun filter(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Boolean>, options: ArrayOptions): Readable

find

suspend fun find(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Boolean>, options: ArrayOptions): Any?

suspend fun <T> find(fn: (data: Any?, options: ArrayOptions?) -> Boolean, options: ArrayOptions): T?

findAsync

fun findAsync(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Boolean>, options: ArrayOptions): Promise<Any?>

fun <T> findAsync(fn: (data: Any?, options: ArrayOptions?) -> Boolean, options: ArrayOptions): Promise<T?>

flatMap

fun flatMap(fn: (data: Any?, options: ArrayOptions?) -> Any?, options: ArrayOptions): Readable

forEach

suspend fun forEach(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Void>, options: ArrayOptions): Void

forEachAsync

fun forEachAsync(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Void>, options: ArrayOptions): Promise<Void>

getMaxListeners

fun getMaxListeners(): Double

isPaused

open fun isPaused(): Boolean

iterator

fun iterator(options: ReadableIteratorOptions): AsyncIterator<Any?>

listenerCount

fun listenerCount(type: EventType, listener: EventListener): Double

listeners

fun listeners(type: EventType): ReadonlyArray<EventListener>

map

fun map(fn: (data: Any?, options: ArrayOptions?) -> Any?, options: ArrayOptions): Readable

off

fun off(type: EventType, listener: EventListener)

fun on(type: EventType, listener: EventListener)

open override fun on(event: Symbol, listener: Function<Unit>)

open override fun on(event: String, listener: Function<Unit>)

once

fun once(type: EventType, listener: EventListener)

open override fun once(event: Symbol, listener: Function<Unit>)

open override fun once(event: String, listener: Function<Unit>)

pause

open fun pause()

pipe

open fun <T : WritableStream> pipe(destination: T, options: ReadableStreamPipeOptions): T

fun <T : WritableStream> pipe(destination: T, options: StreamPipeOptions): T

prependListener

fun prependListener(type: EventType, listener: EventListener)

open override fun prependListener(event: Symbol, listener: Function<Unit>)

open override fun prependListener(event: String, listener: Function<Unit>)

prependOnceListener

fun prependOnceListener(type: EventType, listener: EventListener)

open override fun prependOnceListener(event: Symbol, listener: Function<Unit>)

open override fun prependOnceListener(event: String, listener: Function<Unit>)

push

fun push(chunk: Any?, encoding: BufferEncoding): Boolean

rawListeners

fun rawListeners(type: EventType): ReadonlyArray<EventListener>

read

open fun read(size: Number): Any

readOrNull

open fun readOrNull(size: Number): Any?

reduce

suspend fun <T> reduce(fn: (previous: T, data: Any?, options: ArrayOptions?) -> T, initial: T, options: ArrayOptions): T

suspend fun <T> reduce(fn: (previous: Any?, data: Any?, options: ArrayOptions?) -> T, initial: Nothing?, options: ArrayOptions): T

reduceAsync

fun <T> reduceAsync(fn: (previous: T, data: Any?, options: ArrayOptions?) -> T, initial: T, options: ArrayOptions): Promise<T>

fun <T> reduceAsync(fn: (previous: Any?, data: Any?, options: ArrayOptions?) -> T, initial: Nothing?, options: ArrayOptions): Promise<T>

removeAllListeners

fun removeAllListeners(type: EventType)

removeListener

fun removeListener(type: EventType, listener: EventListener)

open override fun removeListener(event: Symbol, listener: Function<Unit>)

open override fun removeListener(event: String, listener: Function<Unit>)

resume

open fun resume()

setDefaultEncoding

open fun setDefaultEncoding(encoding: BufferEncoding)

setEncoding

open fun setEncoding(encoding: BufferEncoding)

setMaxListeners

fun setMaxListeners(n: Number)

some

suspend fun some(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Boolean>, options: ArrayOptions): Boolean

someAsync

fun someAsync(fn: (data: Any?, options: ArrayOptions?) -> PromiseResult<Boolean>, options: ArrayOptions): Promise<Boolean>

take

fun take(limit: Number, options: ArrayOptions): Readable

toArray

suspend fun toArray(options: ArrayOptions): ReadonlyArray<Any?>

toArrayAsync

fun toArrayAsync(options: ArrayOptions): Promise<ReadonlyArray<Any?>>

uncork

open fun uncork()

unpipe

open fun unpipe(destination: WritableStream)

unshift

open fun unshift(chunk: Uint8Array<*>, encoding: BufferEncoding)

open fun unshift(chunk: String, encoding: BufferEncoding)

fun unshift(chunk: Any?, encoding: BufferEncoding)

wrap

open fun wrap(stream: ReadableStream)

write

open fun write(buffer: Uint8Array<*>, cb: (JsError?) -> Unit): Boolean

open fun write(buffer: String, cb: (JsError?) -> Unit): Boolean

open fun write(str: String, encoding: BufferEncoding, cb: (JsError?) -> Unit): Boolean

open fun write(chunk: Any?, callback: (JsError?) -> Unit): Boolean

open fun write(chunk: Any?, encoding: BufferEncoding, callback: (JsError?) -> Unit): Boolean