kotlin-actions-toolkit/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 override val _writev: (chunks: Array<WritableWritevChunksItem>, callback: (JsError?) -> Unit) -> Unit?

allowHalfOpen

var allowHalfOpen: Boolean

closed

open override val closed: Boolean

closeEvent

open override val closeEvent: EventInstance<JsTuple>

dataEvent

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

destroyed

open override var destroyed: Boolean

drainEvent

open override val drainEvent: EventInstance<JsTuple>

duplexWritable

val duplexWritable: Boolean

endEvent

open override val endEvent: EventInstance<JsTuple>

errored

open override val errored: JsError?

errorEvent

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

finishEvent

open override val finishEvent: EventInstance<JsTuple>

pauseEvent

open override val pauseEvent: EventInstance<JsTuple>

pipeEvent

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

readable

open override 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<JsTuple>

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<JsTuple>

unpipeEvent

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

writable

open override var writable: Boolean

writableCorked

open override val writableCorked: Double

writableEnded

open override val writableEnded: Boolean

writableFinished

open override val writableFinished: Boolean

writableHighWaterMark

open override val writableHighWaterMark: Double

writableLength

open override val writableLength: Double

writableNeedDrain

open override val writableNeedDrain: Boolean

writableObjectMode

open override val writableObjectMode: Boolean

Functions

_destroy

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

_final

open override 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 override 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

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

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

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

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

cork

open override 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 override fun end(cb: () -> Unit)

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

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

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

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

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

eventNames

fun eventNames(): Array<EventType>

every

fun every(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

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

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

flatMap

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

forEach

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

getMaxListeners

fun getMaxListeners(): Double

isPaused

open override fun isPaused(): Boolean

iterator

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

listenerCount

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

listeners

fun listeners(type: EventType): Array<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 override fun pause()

pipe

open override 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): Array<EventListener>

read

open override fun read(size: Number): Any

readOrNull

open fun readOrNull(size: Number): Any?

reduce

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

fun <T> reduce(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 override fun resume()

setDefaultEncoding

open override fun setDefaultEncoding(encoding: BufferEncoding)

setEncoding

open override fun setEncoding(encoding: BufferEncoding)

setMaxListeners

fun setMaxListeners(n: Number)

some

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

take

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

toArray

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

uncork

open override fun uncork()

unpipe

open override fun unpipe(destination: WritableStream)

unshift

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

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

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

wrap

open override fun wrap(stream: ReadableStream)

write

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

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

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

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

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