kotlin-actions-toolkit/actions.artifact/ZipUploadStream

ZipUploadStream

external class ZipUploadStream : Transform(source)

Constructors

ZipUploadStream

constructor(bufferSize: Number)

Properties

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

open override val _writev: (chunks: Array<WritableWritevChunksItem>, callback: (JsError?) -> Unit) -> Unit?

var allowHalfOpen: Boolean

open override val closed: Boolean

open override var destroyed: Boolean

val duplexWritable: Boolean

open override val errored: JsError?

open override var readable: Boolean

readableAborted

val readableAborted: Boolean

readableDidRead

val readableDidRead: Boolean

readableEncoding

val readableEncoding: BufferEncoding?

val readableEnded: Boolean

readableFlowing

val readableFlowing: Boolean?

readableHighWaterMark

val readableHighWaterMark: Double

val readableLength: Double

readableObjectMode

val readableObjectMode: Boolean

readonlyWritable

val readonlyWritable: Boolean

open override var writable: Boolean

open override val writableCorked: Double

open override val writableEnded: Boolean

writableFinished

open override val writableFinished: Boolean

writableHighWaterMark

open override val writableHighWaterMark: Double

open override val writableLength: Double

writableNeedDrain

open override val writableNeedDrain: Boolean

writableObjectMode

open override val writableObjectMode: Boolean

Functions

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

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

fun _flush(callback: TransformCallback)

fun _read(size: Number)

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

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

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

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

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

fun addListener(event: DuplexEvent.CLOSE, listener: () -> Unit)

fun addListener(event: DuplexEvent.DATA, listener: (chunk: Any?) -> Unit)

fun addListener(event: DuplexEvent.DRAIN, listener: () -> Unit)

fun addListener(event: DuplexEvent.END, listener: () -> Unit)

fun addListener(event: DuplexEvent.ERROR, listener: (JsError) -> Unit)

fun addListener(event: DuplexEvent.FINISH, listener: () -> Unit)

fun addListener(event: DuplexEvent.PAUSE, listener: () -> Unit)

fun addListener(event: DuplexEvent.PIPE, listener: (src: Readable) -> Unit)

fun addListener(event: DuplexEvent.READABLE, listener: () -> Unit)

fun addListener(event: DuplexEvent.RESUME, listener: () -> Unit)

fun addListener(event: DuplexEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun addListener(event: ReadableEvent.CLOSE, listener: () -> Unit)

fun addListener(event: ReadableEvent.DATA, listener: (chunk: Any?) -> Unit)

fun addListener(event: ReadableEvent.END, listener: () -> Unit)

fun addListener(event: ReadableEvent.ERROR, listener: (JsError) -> Unit)

fun addListener(event: ReadableEvent.PAUSE, listener: () -> Unit)

fun addListener(event: ReadableEvent.READABLE, listener: () -> Unit)

fun addListener(event: ReadableEvent.RESUME, listener: () -> Unit)

fun addListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun addListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun addListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun addListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun addListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun addListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun asIndexedPairs(options: ArrayOptions): Readable

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

open override fun cork()

open override fun destroy()

open override fun destroy(error: JsError)

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

fun emit(event: DuplexEvent.CLOSE): Boolean

fun emit(event: DuplexEvent.DRAIN): Boolean

fun emit(event: DuplexEvent.END): Boolean

fun emit(event: DuplexEvent.FINISH): Boolean

fun emit(event: DuplexEvent.PAUSE): Boolean

fun emit(event: DuplexEvent.READABLE): Boolean

fun emit(event: DuplexEvent.RESUME): Boolean

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

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

fun emit(event: DuplexEvent.DATA, chunk: Any?): Boolean

fun emit(event: DuplexEvent.ERROR, err: JsError): Boolean

fun emit(event: DuplexEvent.PIPE, src: Readable): Boolean

fun emit(event: DuplexEvent.UNPIPE, src: Readable): Boolean

fun emit(event: ReadableEvent.CLOSE): Boolean

fun emit(event: ReadableEvent.END): Boolean

fun emit(event: ReadableEvent.PAUSE): Boolean

fun emit(event: ReadableEvent.READABLE): Boolean

fun emit(event: ReadableEvent.RESUME): Boolean

fun emit(event: ReadableEvent.DATA, chunk: Any?): Boolean

fun emit(event: ReadableEvent.ERROR, err: JsError): Boolean

fun emit(event: WritableEvent.CLOSE): Boolean

fun emit(event: WritableEvent.DRAIN): Boolean

fun emit(event: WritableEvent.FINISH): Boolean

fun emit(event: WritableEvent.ERROR, err: JsError): Boolean

fun emit(event: WritableEvent.PIPE, src: Readable): Boolean

fun emit(event: WritableEvent.UNPIPE, src: Readable): Boolean

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)

fun eventNames(): Array<Any>

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

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

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

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

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

getMaxListeners

fun getMaxListeners(): Double

open override fun isPaused(): Boolean

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

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

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

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

fun on(event: DuplexEvent.CLOSE, listener: () -> Unit)

fun on(event: DuplexEvent.DATA, listener: (chunk: Any?) -> Unit)

fun on(event: DuplexEvent.DRAIN, listener: () -> Unit)

fun on(event: DuplexEvent.END, listener: () -> Unit)

fun on(event: DuplexEvent.ERROR, listener: (JsError) -> Unit)

fun on(event: DuplexEvent.FINISH, listener: () -> Unit)

fun on(event: DuplexEvent.PAUSE, listener: () -> Unit)

fun on(event: DuplexEvent.PIPE, listener: (src: Readable) -> Unit)

fun on(event: DuplexEvent.READABLE, listener: () -> Unit)

fun on(event: DuplexEvent.RESUME, listener: () -> Unit)

fun on(event: DuplexEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun on(event: ReadableEvent.CLOSE, listener: () -> Unit)

fun on(event: ReadableEvent.DATA, listener: (chunk: Any?) -> Unit)

fun on(event: ReadableEvent.END, listener: () -> Unit)

fun on(event: ReadableEvent.ERROR, listener: (JsError) -> Unit)

fun on(event: ReadableEvent.PAUSE, listener: () -> Unit)

fun on(event: ReadableEvent.READABLE, listener: () -> Unit)

fun on(event: ReadableEvent.RESUME, listener: () -> Unit)

fun on(event: WritableEvent.CLOSE, listener: () -> Unit)

fun on(event: WritableEvent.DRAIN, listener: () -> Unit)

fun on(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun on(event: WritableEvent.FINISH, listener: () -> Unit)

fun on(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun on(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

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

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

fun once(event: DuplexEvent.CLOSE, listener: () -> Unit)

fun once(event: DuplexEvent.DATA, listener: (chunk: Any?) -> Unit)

fun once(event: DuplexEvent.DRAIN, listener: () -> Unit)

fun once(event: DuplexEvent.END, listener: () -> Unit)

fun once(event: DuplexEvent.ERROR, listener: (JsError) -> Unit)

fun once(event: DuplexEvent.FINISH, listener: () -> Unit)

fun once(event: DuplexEvent.PAUSE, listener: () -> Unit)

fun once(event: DuplexEvent.PIPE, listener: (src: Readable) -> Unit)

fun once(event: DuplexEvent.READABLE, listener: () -> Unit)

fun once(event: DuplexEvent.RESUME, listener: () -> Unit)

fun once(event: DuplexEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun once(event: ReadableEvent.CLOSE, listener: () -> Unit)

fun once(event: ReadableEvent.DATA, listener: (chunk: Any?) -> Unit)

fun once(event: ReadableEvent.END, listener: () -> Unit)

fun once(event: ReadableEvent.ERROR, listener: (JsError) -> Unit)

fun once(event: ReadableEvent.PAUSE, listener: () -> Unit)

fun once(event: ReadableEvent.READABLE, listener: () -> Unit)

fun once(event: ReadableEvent.RESUME, listener: () -> Unit)

fun once(event: WritableEvent.CLOSE, listener: () -> Unit)

fun once(event: WritableEvent.DRAIN, listener: () -> Unit)

fun once(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun once(event: WritableEvent.FINISH, listener: () -> Unit)

fun once(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun once(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

open override fun pause()

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

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

prependListener

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

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

fun prependListener(event: DuplexEvent.CLOSE, listener: () -> Unit)

fun prependListener(event: DuplexEvent.DATA, listener: (chunk: Any?) -> Unit)

fun prependListener(event: DuplexEvent.DRAIN, listener: () -> Unit)

fun prependListener(event: DuplexEvent.END, listener: () -> Unit)

fun prependListener(event: DuplexEvent.ERROR, listener: (JsError) -> Unit)

fun prependListener(event: DuplexEvent.FINISH, listener: () -> Unit)

fun prependListener(event: DuplexEvent.PAUSE, listener: () -> Unit)

fun prependListener(event: DuplexEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependListener(event: DuplexEvent.READABLE, listener: () -> Unit)

fun prependListener(event: DuplexEvent.RESUME, listener: () -> Unit)

fun prependListener(event: DuplexEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun prependListener(event: ReadableEvent.CLOSE, listener: () -> Unit)

fun prependListener(event: ReadableEvent.DATA, listener: (chunk: Any?) -> Unit)

fun prependListener(event: ReadableEvent.END, listener: () -> Unit)

fun prependListener(event: ReadableEvent.ERROR, listener: (JsError) -> Unit)

fun prependListener(event: ReadableEvent.PAUSE, listener: () -> Unit)

fun prependListener(event: ReadableEvent.READABLE, listener: () -> Unit)

fun prependListener(event: ReadableEvent.RESUME, listener: () -> Unit)

fun prependListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun prependListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun prependListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun prependListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun prependListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

prependOnceListener

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

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

fun prependOnceListener(event: DuplexEvent.CLOSE, listener: () -> Unit)

fun prependOnceListener(event: DuplexEvent.DATA, listener: (chunk: Any?) -> Unit)

fun prependOnceListener(event: DuplexEvent.DRAIN, listener: () -> Unit)

fun prependOnceListener(event: DuplexEvent.END, listener: () -> Unit)

fun prependOnceListener(event: DuplexEvent.ERROR, listener: (JsError) -> Unit)

fun prependOnceListener(event: DuplexEvent.FINISH, listener: () -> Unit)

fun prependOnceListener(event: DuplexEvent.PAUSE, listener: () -> Unit)

fun prependOnceListener(event: DuplexEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependOnceListener(event: DuplexEvent.READABLE, listener: () -> Unit)

fun prependOnceListener(event: DuplexEvent.RESUME, listener: () -> Unit)

fun prependOnceListener(event: DuplexEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun prependOnceListener(event: ReadableEvent.CLOSE, listener: () -> Unit)

fun prependOnceListener(event: ReadableEvent.DATA, listener: (chunk: Any?) -> Unit)

fun prependOnceListener(event: ReadableEvent.END, listener: () -> Unit)

fun prependOnceListener(event: ReadableEvent.ERROR, listener: (JsError) -> Unit)

fun prependOnceListener(event: ReadableEvent.PAUSE, listener: () -> Unit)

fun prependOnceListener(event: ReadableEvent.READABLE, listener: () -> Unit)

fun prependOnceListener(event: ReadableEvent.RESUME, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun prependOnceListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependOnceListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

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

open override fun read(size: Number): Any

open fun readOrNull(size: Number): Any?

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>

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

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

fun removeListener(event: DuplexEvent.CLOSE, listener: () -> Unit)

fun removeListener(event: DuplexEvent.DATA, listener: (chunk: Any?) -> Unit)

fun removeListener(event: DuplexEvent.DRAIN, listener: () -> Unit)

fun removeListener(event: DuplexEvent.END, listener: () -> Unit)

fun removeListener(event: DuplexEvent.ERROR, listener: (JsError) -> Unit)

fun removeListener(event: DuplexEvent.FINISH, listener: () -> Unit)

fun removeListener(event: DuplexEvent.PAUSE, listener: () -> Unit)

fun removeListener(event: DuplexEvent.PIPE, listener: (src: Readable) -> Unit)

fun removeListener(event: DuplexEvent.READABLE, listener: () -> Unit)

fun removeListener(event: DuplexEvent.RESUME, listener: () -> Unit)

fun removeListener(event: DuplexEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun removeListener(event: ReadableEvent.CLOSE, listener: () -> Unit)

fun removeListener(event: ReadableEvent.DATA, listener: (chunk: Any?) -> Unit)

fun removeListener(event: ReadableEvent.END, listener: () -> Unit)

fun removeListener(event: ReadableEvent.ERROR, listener: (JsError) -> Unit)

fun removeListener(event: ReadableEvent.PAUSE, listener: () -> Unit)

fun removeListener(event: ReadableEvent.READABLE, listener: () -> Unit)

fun removeListener(event: ReadableEvent.RESUME, listener: () -> Unit)

fun removeListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun removeListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun removeListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun removeListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun removeListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun removeListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

open override fun resume()

setDefaultEncoding

open override fun setDefaultEncoding(encoding: BufferEncoding)

open override fun setEncoding(encoding: BufferEncoding)

setMaxListeners

fun setMaxListeners(n: Number)

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

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

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

open override fun uncork()

open override fun unpipe(destination: WritableStream)

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

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

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

open override fun wrap(stream: ReadableStream)

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