@nmtjs/protocol 0.12.4 → 0.12.6

package/dist/client/stream.d.ts

@@ -0,0 +1,28 @@
+import type { ProtocolBlobMetadata } from '../common/blob.ts';
+export declare class ProtocolClientBlobStream extends TransformStream<any, ArrayBuffer> {
+    #private;
+    readonly source: ReadableStream;
+    readonly id: number;
+    readonly metadata: ProtocolBlobMetadata;
+    constructor(source: ReadableStream, id: number, metadata: ProtocolBlobMetadata);
+    read(size: number): Promise<ArrayBuffer | null>;
+    abort(error?: Error): void;
+    end(): Promise<void>;
+}
+export interface ProtocolServerStreamInterface<T = any> {
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+    abort(error?: Error): void;
+}
+export declare class ProtocolServerStream<T = any> extends TransformStream<any, T> implements ProtocolServerStreamInterface<T> {
+    #private;
+    constructor(options?: Transformer<any, T>);
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown>;
+    push(chunk: T): Promise<void>;
+    end(): Promise<void>;
+    abort(error?: Error): Promise<void>;
+}
+export declare class ProtocolServerBlobStream extends ProtocolServerStream<ArrayBuffer> {
+    readonly id: number;
+    readonly metadata: ProtocolBlobMetadata;
+    constructor(id: number, metadata: ProtocolBlobMetadata, options?: Transformer<any, ArrayBuffer>);
+}

package/dist/client/stream.js

@@ -1,87 +1,95 @@
-import { defer } from "@nmtjs/common";
+import { defer } from '@nmtjs/common';
 import { concat, encodeText } from "../common/binary.js";
 export class ProtocolClientBlobStream extends TransformStream {
-	#queue;
-	#reader;
-	constructor(source, id, metadata) {
-		super({
-			start: () => {
-				defer(() => source.pipeThrough(this));
-			},
-			transform: (chunk, controller) => {
-				if (chunk instanceof ArrayBuffer) {
-					controller.enqueue(chunk);
-				} else if (chunk instanceof Uint8Array) {
-					controller.enqueue(chunk.buffer);
-				} else if (typeof chunk === "string") {
-					controller.enqueue(encodeText(chunk));
-				} else {
-					throw new Error("Invalid chunk data type. Expected ArrayBuffer, Uint8Array, or string.");
-				}
-			}
-		});
-		this.source = source;
-		this.id = id;
-		this.metadata = metadata;
-		this.#queue = new ArrayBuffer(0);
-		this.#reader = this.readable.getReader();
-	}
-	async read(size) {
-		while (this.#queue.byteLength < size) {
-			const { done, value } = await this.#reader.read();
-			if (done) {
-				if (this.#queue.byteLength > 0) {
-					const chunk = this.#queue;
-					this.#queue = new ArrayBuffer(0);
-					return chunk;
-				}
-				return null;
-			}
-			const buffer = value;
-			this.#queue = concat(this.#queue, buffer);
-		}
-		const chunk = this.#queue.slice(0, size);
-		this.#queue = this.#queue.slice(size);
-		return chunk;
-	}
-	abort(error = new Error("Stream aborted")) {
-		this.#reader.cancel(error);
-		this.source.cancel(error);
-	}
-	end() {
-		return this.source.cancel("Stream ended");
-	}
+    source;
+    id;
+    metadata;
+    #queue;
+    #reader;
+    constructor(source, id, metadata) {
+        super({
+            start: () => {
+                defer(() => source.pipeThrough(this));
+            },
+            transform: (chunk, controller) => {
+                if (chunk instanceof ArrayBuffer) {
+                    controller.enqueue(chunk);
+                }
+                else if (chunk instanceof Uint8Array) {
+                    controller.enqueue(chunk.buffer);
+                }
+                else if (typeof chunk === 'string') {
+                    controller.enqueue(encodeText(chunk));
+                }
+                else {
+                    throw new Error('Invalid chunk data type. Expected ArrayBuffer, Uint8Array, or string.');
+                }
+            },
+        });
+        this.source = source;
+        this.id = id;
+        this.metadata = metadata;
+        this.#queue = new ArrayBuffer(0);
+        this.#reader = this.readable.getReader();
+    }
+    async read(size) {
+        while (this.#queue.byteLength < size) {
+            const { done, value } = await this.#reader.read();
+            if (done) {
+                if (this.#queue.byteLength > 0) {
+                    const chunk = this.#queue;
+                    this.#queue = new ArrayBuffer(0);
+                    return chunk;
+                }
+                return null;
+            }
+            const buffer = value;
+            this.#queue = concat(this.#queue, buffer);
+        }
+        const chunk = this.#queue.slice(0, size);
+        this.#queue = this.#queue.slice(size);
+        return chunk;
+    }
+    abort(error = new Error('Stream aborted')) {
+        this.#reader.cancel(error);
+        this.source.cancel(error);
+    }
+    end() {
+        return this.source.cancel('Stream ended');
+    }
 }
 export class ProtocolServerStream extends TransformStream {
-	#writer;
-	constructor(options) {
-		super(options);
-		this.#writer = this.writable.getWriter();
-	}
-	async *[Symbol.asyncIterator]() {
-		const reader = this.readable.getReader();
-		while (true) {
-			const { done, value } = await reader.read();
-			if (!done) yield value;
-			else break;
-		}
-	}
-	async push(chunk) {
-		await this.#writer.write(chunk);
-	}
-	async end() {
-		await this.#writer.close();
-	}
-	async abort(error = new Error("Stream aborted")) {
-		await this.#writer.abort(error);
-	}
+    #writer;
+    constructor(options) {
+        super(options);
+        this.#writer = this.writable.getWriter();
+    }
+    async *[Symbol.asyncIterator]() {
+        const reader = this.readable.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (!done)
+                yield value;
+            else
+                break;
+        }
+    }
+    async push(chunk) {
+        await this.#writer.write(chunk);
+    }
+    async end() {
+        await this.#writer.close();
+    }
+    async abort(error = new Error('Stream aborted')) {
+        await this.#writer.abort(error);
+    }
 }
 export class ProtocolServerBlobStream extends ProtocolServerStream {
-	constructor(id, metadata, options) {
-		super(options);
-		this.id = id;
-		this.metadata = metadata;
-	}
+    id;
+    metadata;
+    constructor(id, metadata, options) {
+        super(options);
+        this.id = id;
+        this.metadata = metadata;
+    }
 }
-
-//# sourceMappingURL=stream.js.map

package/dist/client/types.d.ts

@@ -0,0 +1,8 @@
+import type { ProtocolBlob, ProtocolBlobInterface } from '../common/blob.ts';
+import type { ProtocolServerBlobStream } from './stream.ts';
+export type InputType<T> = T extends ProtocolBlobInterface ? ProtocolBlob : T extends object ? {
+    [K in keyof T]: InputType<T[K]>;
+} : T;
+export type OutputType<T> = T extends ProtocolBlobInterface ? ProtocolServerBlobStream : T extends object ? {
+    [K in keyof T]: OutputType<T[K]>;
+} : T;

package/dist/client/types.js

@@ -1,3 +1 @@
 export {};
-
-//# sourceMappingURL=types.js.map

package/dist/common/binary.d.ts

@@ -0,0 +1,19 @@
+declare const utf8decoder: TextDecoder;
+export type BinaryTypes = {
+    Int8: number;
+    Int16: number;
+    Int32: number;
+    Uint8: number;
+    Uint16: number;
+    Uint32: number;
+    Float32: number;
+    Float64: number;
+    BigInt64: bigint;
+    BigUint64: bigint;
+};
+export declare const encodeNumber: <T extends keyof BinaryTypes>(value: BinaryTypes[T], type: T, littleEndian?: boolean) => ArrayBuffer;
+export declare const decodeNumber: <T extends keyof BinaryTypes>(buffer: ArrayBuffer, type: T, offset?: number, littleEndian?: boolean) => BinaryTypes[T];
+export declare const encodeText: (text: string) => ArrayBuffer;
+export declare const decodeText: (buffer: Parameters<typeof utf8decoder.decode>[0]) => string;
+export declare const concat: (...buffers: ArrayBuffer[]) => ArrayBuffer;
+export {};

package/dist/common/binary.js

@@ -1,27 +1,27 @@
+// TODO: get rid of lib DOM somehow...
+/// <reference lib="dom" />
 const utf8decoder = new TextDecoder();
 const utf8encoder = new TextEncoder();
 export const encodeNumber = (value, type, littleEndian = false) => {
-	const bytesNeeded = globalThis[`${type}Array`].BYTES_PER_ELEMENT;
-	const ab = new ArrayBuffer(bytesNeeded);
-	const dv = new DataView(ab);
-	dv[`set${type}`](0, value, littleEndian);
-	return ab;
+    const bytesNeeded = globalThis[`${type}Array`].BYTES_PER_ELEMENT;
+    const ab = new ArrayBuffer(bytesNeeded);
+    const dv = new DataView(ab);
+    dv[`set${type}`](0, value, littleEndian);
+    return ab;
 };
 export const decodeNumber = (buffer, type, offset = 0, littleEndian = false) => {
-	const view = new DataView(buffer);
-	return view[`get${type}`](offset, littleEndian);
+    const view = new DataView(buffer);
+    return view[`get${type}`](offset, littleEndian);
 };
 export const encodeText = (text) => new Uint8Array(utf8encoder.encode(text)).buffer;
 export const decodeText = (buffer) => utf8decoder.decode(buffer);
 export const concat = (...buffers) => {
-	const totalLength = buffers.reduce((acc, buffer) => acc + buffer.byteLength, 0);
-	const view = new Uint8Array(totalLength);
-	let offset = 0;
-	for (const buffer of buffers) {
-		view.set(new Uint8Array(buffer), offset);
-		offset += buffer.byteLength;
-	}
-	return view.buffer;
+    const totalLength = buffers.reduce((acc, buffer) => acc + buffer.byteLength, 0);
+    const view = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const buffer of buffers) {
+        view.set(new Uint8Array(buffer), offset);
+        offset += buffer.byteLength;
+    }
+    return view.buffer;
 };
-
-//# sourceMappingURL=binary.js.map

package/dist/common/blob.d.ts

@@ -0,0 +1,22 @@
+export declare const BlobKey: unique symbol;
+export type BlobKey = typeof BlobKey;
+export type ProtocolBlobMetadata = {
+    type: string;
+    size?: number;
+    filename?: string;
+};
+export interface ProtocolBlobInterface {
+    readonly metadata: ProtocolBlobMetadata;
+    readonly [BlobKey]: true;
+}
+export declare class ProtocolBlob implements ProtocolBlobInterface {
+    readonly [BlobKey] = true;
+    readonly metadata: ProtocolBlobMetadata;
+    readonly source: any;
+    constructor(source: any, size?: number, type?: string, filename?: string);
+    static from(source: any, metadata?: {
+        size?: number;
+        type?: string;
+        filename?: string;
+    }): ProtocolBlob;
+}

package/dist/common/blob.js

@@ -1,42 +1,46 @@
-export const BlobKey = Symbol.for("neemata:BlobKey");
+export const BlobKey = Symbol.for('neemata:BlobKey');
 export class ProtocolBlob {
-	[BlobKey] = true;
-	metadata;
-	source;
-	constructor(source, size, type = "application/octet-stream", filename) {
-		if (typeof size !== "undefined" && size <= 0) throw new Error("Blob size is invalid");
-		this.source = source;
-		this.metadata = {
-			size,
-			type,
-			filename
-		};
-	}
-	static from(source, metadata = {}) {
-		let _source;
-		if (source instanceof globalThis.ReadableStream) {
-			_source = source;
-		} else if ("File" in globalThis && source instanceof globalThis.File) {
-			_source = source.stream();
-			metadata.size = source.size;
-			metadata.filename = source.name;
-		} else if (source instanceof globalThis.Blob) {
-			_source = source.stream();
-			metadata.size = source.size;
-		} else if (typeof source === "string") {
-			const blob = new Blob([source]);
-			_source = blob.stream();
-			metadata.size = blob.size;
-			metadata.type = metadata.type || "text/plain";
-		} else if (source instanceof globalThis.ArrayBuffer) {
-			const blob = new Blob([source]);
-			_source = blob.stream();
-			metadata.size = blob.size;
-		} else {
-			_source = source;
-		}
-		return new ProtocolBlob(_source, metadata.size, metadata.type, metadata.filename);
-	}
+    [BlobKey] = true;
+    metadata;
+    source;
+    constructor(source, size, type = 'application/octet-stream', filename) {
+        if (typeof size !== 'undefined' && size <= 0)
+            throw new Error('Blob size is invalid');
+        this.source = source;
+        this.metadata = {
+            size,
+            type,
+            filename,
+        };
+    }
+    static from(source, metadata = {}) {
+        let _source;
+        if (source instanceof globalThis.ReadableStream) {
+            _source = source;
+        }
+        else if ('File' in globalThis && source instanceof globalThis.File) {
+            _source = source.stream();
+            metadata.size = source.size;
+            metadata.filename = source.name;
+        }
+        else if (source instanceof globalThis.Blob) {
+            _source = source.stream();
+            metadata.size = source.size;
+        }
+        else if (typeof source === 'string') {
+            const blob = new Blob([source]);
+            _source = blob.stream();
+            metadata.size = blob.size;
+            metadata.type = metadata.type || 'text/plain';
+        }
+        else if (source instanceof globalThis.ArrayBuffer) {
+            const blob = new Blob([source]);
+            _source = blob.stream();
+            metadata.size = blob.size;
+        }
+        else {
+            _source = source;
+        }
+        return new ProtocolBlob(_source, metadata.size, metadata.type, metadata.filename);
+    }
 }
-
-//# sourceMappingURL=blob.js.map

package/dist/common/enums.d.ts

@@ -0,0 +1,41 @@
+export declare enum ClientMessageType {
+    Rpc = 10,
+    RpcAbort = 11,
+    RpcStreamAbort = 12,
+    ClientStreamPush = 20,
+    ClientStreamEnd = 21,
+    ClientStreamAbort = 22,
+    ServerStreamAbort = 23,
+    ServerStreamPull = 24
+}
+export declare enum ServerMessageType {
+    Event = 1,
+    RpcResponse = 10,
+    RpcStreamResponse = 11,
+    RpcStreamChunk = 12,
+    RpcStreamEnd = 13,
+    RpcStreamAbort = 14,
+    ServerStreamPush = 20,
+    ServerStreamEnd = 21,
+    ServerStreamAbort = 22,
+    ClientStreamAbort = 23,
+    ClientStreamPull = 24
+}
+export declare enum TransportType {
+    Bidirectional = "Bidirectional",
+    Unidirectional = "Unidirectional"
+}
+export declare enum ErrorCode {
+    ValidationError = "ValidationError",
+    BadRequest = "BadRequest",
+    NotFound = "NotFound",
+    Forbidden = "Forbidden",
+    Unauthorized = "Unauthorized",
+    InternalServerError = "InternalServerError",
+    NotAcceptable = "NotAcceptable",
+    RequestTimeout = "RequestTimeout",
+    GatewayTimeout = "GatewayTimeout",
+    ServiceUnavailable = "ServiceUnavailable",
+    ClientRequestError = "ClientRequestError",
+    ConnectionError = "ConnectionError"
+}

package/dist/common/enums.js

@@ -1,47 +1,45 @@
-export let ClientMessageType = /* @__PURE__ */ function(ClientMessageType) {
-	ClientMessageType[ClientMessageType["Rpc"] = 10] = "Rpc";
-	ClientMessageType[ClientMessageType["RpcAbort"] = 11] = "RpcAbort";
-	ClientMessageType[ClientMessageType["RpcStreamAbort"] = 12] = "RpcStreamAbort";
-	ClientMessageType[ClientMessageType["ClientStreamPush"] = 20] = "ClientStreamPush";
-	ClientMessageType[ClientMessageType["ClientStreamEnd"] = 21] = "ClientStreamEnd";
-	ClientMessageType[ClientMessageType["ClientStreamAbort"] = 22] = "ClientStreamAbort";
-	ClientMessageType[ClientMessageType["ServerStreamAbort"] = 23] = "ServerStreamAbort";
-	ClientMessageType[ClientMessageType["ServerStreamPull"] = 24] = "ServerStreamPull";
-	return ClientMessageType;
-}({});
-export let ServerMessageType = /* @__PURE__ */ function(ServerMessageType) {
-	ServerMessageType[ServerMessageType["Event"] = 1] = "Event";
-	ServerMessageType[ServerMessageType["RpcResponse"] = 10] = "RpcResponse";
-	ServerMessageType[ServerMessageType["RpcStreamResponse"] = 11] = "RpcStreamResponse";
-	ServerMessageType[ServerMessageType["RpcStreamChunk"] = 12] = "RpcStreamChunk";
-	ServerMessageType[ServerMessageType["RpcStreamEnd"] = 13] = "RpcStreamEnd";
-	ServerMessageType[ServerMessageType["RpcStreamAbort"] = 14] = "RpcStreamAbort";
-	ServerMessageType[ServerMessageType["ServerStreamPush"] = 20] = "ServerStreamPush";
-	ServerMessageType[ServerMessageType["ServerStreamEnd"] = 21] = "ServerStreamEnd";
-	ServerMessageType[ServerMessageType["ServerStreamAbort"] = 22] = "ServerStreamAbort";
-	ServerMessageType[ServerMessageType["ClientStreamAbort"] = 23] = "ClientStreamAbort";
-	ServerMessageType[ServerMessageType["ClientStreamPull"] = 24] = "ClientStreamPull";
-	return ServerMessageType;
-}({});
-export let TransportType = /* @__PURE__ */ function(TransportType) {
-	TransportType["Bidirectional"] = "Bidirectional";
-	TransportType["Unidirectional"] = "Unidirectional";
-	return TransportType;
-}({});
-export let ErrorCode = /* @__PURE__ */ function(ErrorCode) {
-	ErrorCode["ValidationError"] = "ValidationError";
-	ErrorCode["BadRequest"] = "BadRequest";
-	ErrorCode["NotFound"] = "NotFound";
-	ErrorCode["Forbidden"] = "Forbidden";
-	ErrorCode["Unauthorized"] = "Unauthorized";
-	ErrorCode["InternalServerError"] = "InternalServerError";
-	ErrorCode["NotAcceptable"] = "NotAcceptable";
-	ErrorCode["RequestTimeout"] = "RequestTimeout";
-	ErrorCode["GatewayTimeout"] = "GatewayTimeout";
-	ErrorCode["ServiceUnavailable"] = "ServiceUnavailable";
-	ErrorCode["ClientRequestError"] = "ClientRequestError";
-	ErrorCode["ConnectionError"] = "ConnectionError";
-	return ErrorCode;
-}({});
-
-//# sourceMappingURL=enums.js.map
+export var ClientMessageType;
+(function (ClientMessageType) {
+    ClientMessageType[ClientMessageType["Rpc"] = 10] = "Rpc";
+    ClientMessageType[ClientMessageType["RpcAbort"] = 11] = "RpcAbort";
+    ClientMessageType[ClientMessageType["RpcStreamAbort"] = 12] = "RpcStreamAbort";
+    ClientMessageType[ClientMessageType["ClientStreamPush"] = 20] = "ClientStreamPush";
+    ClientMessageType[ClientMessageType["ClientStreamEnd"] = 21] = "ClientStreamEnd";
+    ClientMessageType[ClientMessageType["ClientStreamAbort"] = 22] = "ClientStreamAbort";
+    ClientMessageType[ClientMessageType["ServerStreamAbort"] = 23] = "ServerStreamAbort";
+    ClientMessageType[ClientMessageType["ServerStreamPull"] = 24] = "ServerStreamPull";
+})(ClientMessageType || (ClientMessageType = {}));
+export var ServerMessageType;
+(function (ServerMessageType) {
+    ServerMessageType[ServerMessageType["Event"] = 1] = "Event";
+    ServerMessageType[ServerMessageType["RpcResponse"] = 10] = "RpcResponse";
+    ServerMessageType[ServerMessageType["RpcStreamResponse"] = 11] = "RpcStreamResponse";
+    ServerMessageType[ServerMessageType["RpcStreamChunk"] = 12] = "RpcStreamChunk";
+    ServerMessageType[ServerMessageType["RpcStreamEnd"] = 13] = "RpcStreamEnd";
+    ServerMessageType[ServerMessageType["RpcStreamAbort"] = 14] = "RpcStreamAbort";
+    ServerMessageType[ServerMessageType["ServerStreamPush"] = 20] = "ServerStreamPush";
+    ServerMessageType[ServerMessageType["ServerStreamEnd"] = 21] = "ServerStreamEnd";
+    ServerMessageType[ServerMessageType["ServerStreamAbort"] = 22] = "ServerStreamAbort";
+    ServerMessageType[ServerMessageType["ClientStreamAbort"] = 23] = "ClientStreamAbort";
+    ServerMessageType[ServerMessageType["ClientStreamPull"] = 24] = "ClientStreamPull";
+})(ServerMessageType || (ServerMessageType = {}));
+export var TransportType;
+(function (TransportType) {
+    TransportType["Bidirectional"] = "Bidirectional";
+    TransportType["Unidirectional"] = "Unidirectional";
+})(TransportType || (TransportType = {}));
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["ValidationError"] = "ValidationError";
+    ErrorCode["BadRequest"] = "BadRequest";
+    ErrorCode["NotFound"] = "NotFound";
+    ErrorCode["Forbidden"] = "Forbidden";
+    ErrorCode["Unauthorized"] = "Unauthorized";
+    ErrorCode["InternalServerError"] = "InternalServerError";
+    ErrorCode["NotAcceptable"] = "NotAcceptable";
+    ErrorCode["RequestTimeout"] = "RequestTimeout";
+    ErrorCode["GatewayTimeout"] = "GatewayTimeout";
+    ErrorCode["ServiceUnavailable"] = "ServiceUnavailable";
+    ErrorCode["ClientRequestError"] = "ClientRequestError";
+    ErrorCode["ConnectionError"] = "ConnectionError";
+})(ErrorCode || (ErrorCode = {}));

package/dist/common/index.d.ts

@@ -0,0 +1,4 @@
+export * from './binary.ts';
+export * from './blob.ts';
+export * from './enums.ts';
+export * from './types.ts';

package/dist/common/index.js

@@ -2,5 +2,3 @@ export * from "./binary.js";
 export * from "./blob.js";
 export * from "./enums.js";
 export * from "./types.js";
-
-//# sourceMappingURL=index.js.map

package/dist/common/types.d.ts

@@ -0,0 +1,34 @@
+import type { OneOf } from '@nmtjs/common';
+import type { ProtocolBlob, ProtocolBlobMetadata } from './blob.ts';
+type Stream = any;
+export interface BaseProtocolError {
+    code: string;
+    message: string;
+    data?: any;
+}
+export type ProtocolRPC = {
+    callId: number;
+    namespace: string;
+    procedure: string;
+    payload: any;
+};
+export type ProtocolRPCResponse<T = Stream> = OneOf<[
+    {
+        callId: number;
+        error: BaseProtocolError;
+    },
+    {
+        callId: number;
+        result: any;
+        streams: Record<number, T>;
+    }
+]>;
+export interface EncodeRPCContext<T = Stream> {
+    getStream: (id: number) => T;
+    addStream: (blob: ProtocolBlob) => T;
+}
+export interface DecodeRPCContext<T = Stream> {
+    getStream: (id: number, callId: number) => T;
+    addStream: (id: number, callId: number, metadata: ProtocolBlobMetadata) => T;
+}
+export {};

package/dist/common/types.js

@@ -1,3 +1 @@
 export {};
-
-//# sourceMappingURL=types.js.map

package/dist/server/api.d.ts

@@ -0,0 +1,34 @@
+import type { Async } from '@nmtjs/common';
+import type { Container, Hook, MetadataStore } from '@nmtjs/core';
+import type { Connection } from './connection.ts';
+import { kIterableResponse } from './constants.ts';
+export type ProtocolApiCallOptions = {
+    connection: Connection;
+    namespace: string;
+    procedure: string;
+    container: Container;
+    payload: any;
+    signal: AbortSignal;
+    metadata?: (metadata: MetadataStore) => void;
+};
+export type ProtocolAnyIterable<T> = ((signal: AbortSignal) => Async<AsyncIterable<T>>) | AsyncIterable<T>;
+export interface ProtocolApiCallBaseResult<T = unknown> {
+    output: T;
+}
+export interface ProtocolApiCallIterableResult<Y = unknown, O = unknown> extends ProtocolApiCallBaseResult<O> {
+    [kIterableResponse]: true;
+    iterable: ProtocolAnyIterable<Y>;
+    onFinish?: () => void;
+}
+export type ProtocolApiCallResult = ProtocolApiCallBaseResult | ProtocolApiCallIterableResult;
+export interface ProtocolApi {
+    call(options: ProtocolApiCallOptions): Promise<ProtocolApiCallResult>;
+}
+export declare function isIterableResult(value: ProtocolApiCallResult): value is ProtocolApiCallIterableResult;
+export declare function createStreamResponse<Y, O>(iterable: ProtocolAnyIterable<Y>, output?: O, onFinish?: () => void): ProtocolApiCallIterableResult<Y, O>;
+declare module '@nmtjs/core' {
+    interface HookType {
+        [Hook.OnConnect]: (connection: Connection) => any;
+        [Hook.OnDisconnect]: (connection: Connection) => any;
+    }
+}

package/dist/server/api.js

@@ -1,14 +1,12 @@
 import { kIterableResponse } from "./constants.js";
 export function isIterableResult(value) {
-	return value && value[kIterableResponse] === true;
+    return value && value[kIterableResponse] === true;
 }
 export function createStreamResponse(iterable, output = undefined, onFinish) {
-	return {
-		[kIterableResponse]: true,
-		iterable,
-		output,
-		onFinish
-	};
+    return {
+        [kIterableResponse]: true,
+        iterable,
+        output,
+        onFinish,
+    };
 }
-
-//# sourceMappingURL=api.js.map