@vampgg/utils 1.0.0-beta.1

package/dist/extension-channel.mjs

@@ -0,0 +1,377 @@
+import { Message } from "./bebop.mjs";
+import { createEventIterator } from "./create-event-iterator.mjs";
+import { createDuplexIterator } from "./create-duplex-iterator.mjs";
+import { ConsoleLogger, ExecutionEnvironment, Metadata, TempoError, TempoStatusCode, TempoUtil, TempoVersion } from "@tempojs/common";
+import { BaseChannel } from "@tempojs/client";
+import { EventEmitter } from "tseep";
+import * as browser from "webextension-polyfill";
+//#region src/extension-channel.ts
+/**
+* Represents a Tempo channel for communication with a remote server.
+*/
+var TempoExtensionChannel = class TempoExtensionChannel extends BaseChannel {
+	static defaultMaxRetryAttempts = 5;
+	static defaultMaxReceiveMessageSize = 1024 * 1024 * 4;
+	static defaultMaxSendMessageSize = 1024 * 1024 * 4;
+	static defaultContentType = "bebop";
+	events = new EventEmitter();
+	userAgent;
+	pending = /* @__PURE__ */ new Map();
+	closed = false;
+	onMessage = (msg) => {
+		let message;
+		try {
+			message = Message(Message.decode(new Uint8Array(msg)));
+		} catch (e) {
+			this.logger.warn("dropping undecodable runtime message", {}, e);
+			return Promise.resolve();
+		}
+		if (message.messageId) {
+			this.events.emit(message.messageId, message);
+			this.logger.debug(`received new message ${message.messageId}`);
+		}
+		return Promise.resolve();
+	};
+	/**
+	* Constructs a new TempoChannel instance.
+	*
+	* @param {URL} target - The target URL for the channel.
+	* @param {TempoWSChannelOptions} options - The configuration options for the channel.
+	* @protected
+	*/
+	constructor(options = {}) {
+		super(new URL("runtime://"), options.logger ?? new ConsoleLogger("TempoExtensionChannel"), options.contentType ?? TempoExtensionChannel.defaultContentType);
+		this.logger.trace("creating new TempoExtensionChannel");
+		this.userAgent = TempoUtil.buildUserAgent("javascript", TempoVersion, void 0, { runtime: TempoUtil.getEnvironmentName() });
+		browser.runtime.onMessage.addListener(this.onMessage);
+		this.logger.debug(`created new TempoExtensionChannel`);
+	}
+	/**
+	* Tear down the channel: remove the runtime message listener, reject every
+	* in-flight call, and clear all event listeners. Idempotent.
+	*/
+	close(reason) {
+		if (this.closed) return;
+		this.closed = true;
+		try {
+			browser.runtime.onMessage.removeListener(this.onMessage);
+		} catch {}
+		const err = reason ?? new TempoError(TempoStatusCode.CANCELLED, "channel disposed");
+		for (const reject of this.pending.values()) reject(err);
+		this.pending.clear();
+		this.events.removeAllListeners();
+	}
+	async removeCredential() {}
+	async getCredential() {}
+	/**
+	* Executes a function with retries according to the provided retry policy.
+	* The function will be retried if it fails with a TempoError and its status code is included in the retryableStatusCodes of the retry policy.
+	* If a deadline is provided, the deadline for each attempt will be managed by the provided deadline, but the deadline will not be reset upon each retry.
+	*
+	* @template T - The type of the result returned by the function.
+	* @param {((retryAttempt: number) => Promise<T>)} func - A function that returns a Promise with a result. The function will receive a number indicating the current retry attempt.
+	* @param {RetryPolicy} retryPolicy - An object defining the retry policy, including maxAttempts, initialBackoff, maxBackoff, backoffMultiplier, and retryableStatusCodes.
+	* @param {Deadline} [deadline] - An optional deadline object that manages the timeout for each attempt.
+	* @param {AbortController} [abortController] - An optional AbortController instance to cancel the function execution.
+	* @returns {Promise<T>} - A Promise that resolves with the result of the function if it completes within the deadline and retry policy constraints.
+	* @throws {Error} - If the function execution fails and the error does not match the retry policy, or if the maximum number of attempts is reached without a successful result.
+	*/
+	async executeWithRetry(func, retryPolicy, deadline, abortController) {
+		let attempt = 0;
+		let lastError;
+		const execute = deadline ? (retryAttempt) => deadline.executeWithinDeadline(async () => await func(retryAttempt), abortController) : (retryAttempt) => func(retryAttempt);
+		while (attempt < retryPolicy.maxAttempts) try {
+			return await execute(attempt);
+		} catch (error) {
+			if (!(error instanceof Error)) throw new TempoError(TempoStatusCode.UNKNOWN, `unexpected error`, { data: error });
+			lastError = error;
+			if (!(error instanceof TempoError) || !retryPolicy.retryableStatusCodes.includes(error.status)) throw error;
+			const backoffWithJitter = Math.min(retryPolicy.initialBackoff.multiply(Math.pow(retryPolicy.backoffMultiplier, attempt)).totalMilliseconds, retryPolicy.maxBackoff.totalMilliseconds) * (Math.random() * .5 + .75);
+			await new Promise((resolve) => setTimeout(resolve, backoffWithJitter));
+			attempt++;
+		}
+		if (abortController && lastError !== void 0 && !(lastError instanceof Error && lastError.name === "AbortError") && !(lastError instanceof TempoError && lastError.status === TempoStatusCode.ABORTED)) abortController.abort();
+		return Promise.reject(lastError || new TempoError(TempoStatusCode.DEADLINE_EXCEEDED, "Failed to execute function with retry policy"));
+	}
+	async fetchUnary(init, options) {
+		const messageId = init.messageId;
+		let listener;
+		let onAbort;
+		const cleanup = () => {
+			this.events.off(messageId, listener);
+			if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+			this.pending.delete(messageId);
+		};
+		return await new Promise((resolve, reject) => {
+			listener = (message) => resolve(message);
+			this.pending.set(messageId, reject);
+			if (options?.controller) {
+				onAbort = () => reject(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, listener);
+			this.sendMessage(init).catch(reject);
+		}).finally(cleanup);
+	}
+	async fetchClientStream(init, method, generator, options) {
+		const messageId = init.messageId;
+		let listener;
+		let onAbort;
+		const cleanup = () => {
+			this.events.off(messageId, listener);
+			if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+			this.pending.delete(messageId);
+		};
+		return await new Promise((resolve, reject) => {
+			listener = (message) => resolve(message);
+			this.pending.set(messageId, reject);
+			if (options?.controller) {
+				onAbort = () => reject(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, listener);
+			runGenerator.call(this).catch(reject);
+			async function runGenerator() {
+				for await (const value of generator()) await this.sendMessage(Message({
+					...init,
+					data: method.serialize(value)
+				}));
+				await this.sendMessage(Message({
+					...init,
+					status: TempoStatusCode.CANCELLED,
+					data: new Uint8Array()
+				}));
+			}
+		}).finally(cleanup);
+	}
+	fetchServerStream(init, context, method, options) {
+		const messageId = init.messageId;
+		return createEventIterator(({ emit, cancel, error }) => {
+			let terminated = false;
+			let onAbort;
+			const eventHandler = async (message) => {
+				try {
+					if (message.status === TempoStatusCode.CANCELLED) {
+						terminated = true;
+						cancel();
+						return;
+					}
+					this.processResponseHeaders(message, context, method.type);
+					const responseData = message.data;
+					const record = method.deserialize(responseData);
+					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+					emit(record);
+				} catch (e) {
+					error(e);
+				}
+			};
+			if (options?.controller) {
+				onAbort = () => error(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, eventHandler);
+			this.sendMessage(init);
+			return () => {
+				this.events.off(messageId, eventHandler);
+				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+				if (terminated || this.closed) return;
+				this.sendMessage(Message({
+					messageId,
+					methodId: init.methodId,
+					status: TempoStatusCode.CANCELLED,
+					data: new Uint8Array(),
+					timestamp: /* @__PURE__ */ new Date()
+				}));
+			};
+		});
+	}
+	fetchDuplexStream(init, context, method, generator, options) {
+		const messageId = init.messageId;
+		return createDuplexIterator(generator(), (value) => {
+			this.sendMessage(Message({
+				...init,
+				data: method.serialize(value)
+			}));
+		}, ({ emit, cancel, error }) => {
+			let onAbort;
+			const eventHandler = async (message) => {
+				try {
+					if (message.status === TempoStatusCode.CANCELLED) {
+						cancel();
+						return;
+					}
+					this.processResponseHeaders(message, context, method.type);
+					const requestData = message.data;
+					const record = method.deserialize(requestData);
+					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+					emit(record);
+				} catch (e) {
+					error(e);
+				}
+			};
+			if (options?.controller) {
+				onAbort = () => error(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
+				options.controller.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			this.events.on(messageId, eventHandler);
+			return () => {
+				this.events.off(messageId, eventHandler);
+				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
+			};
+		});
+	}
+	/**
+	* Creates a `RequestInit` object for a given payload, context, method and optional call options.
+	* This object can be used to make an HTTP request using the Fetch API.
+	*
+	* @private
+	* @param {Uint8Array} payload - The payload to be sent in the request.
+	* @param {ClientContext} context - The context of the client making the request.
+	* @param {MethodInfo<BebopRecord, BebopRecord>} method - Information about the method being called.
+	* @param {CallOptions | undefined} options - Optional configuration for the call.
+	* @returns {Promise<RequestInit>} A Promise resolving to the created `RequestInit` object.
+	* @throws {TempoError} Throws an error if there's a problem while getting the credential header.
+	*/
+	createRequest(payload, _context, method, options) {
+		const customMetadata = new Metadata();
+		customMetadata.set("path", `/${method.service}/${method.name}`);
+		customMetadata.set("service-name", method.service);
+		if (ExecutionEnvironment.isBrowser || ExecutionEnvironment.isWebWorker) customMetadata.set("x-user-agent", this.userAgent);
+		else customMetadata.set("user-agent", this.userAgent);
+		const requestInit = {
+			messageId: crypto.randomUUID(),
+			methodId: method.id,
+			data: new Uint8Array(payload),
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		if (options?.deadline) requestInit.deadline = new Date(options.deadline.toUnixTimestamp());
+		return requestInit;
+	}
+	/**
+	* Processes the headers of the response from the server, validating their integrity and correctness.
+	* Also sets the incoming metadata from the response headers to the provided context.
+	*
+	* @private
+	* @param {Response} response - The response received from the server.
+	* @param {ClientContext} context - The context of the client making the request.
+	* @param {MethodType} methodType - The type of method being called.
+	* @throws {TempoError} Throws an error if any validation checks fail or if there's a problem parsing or storing credentials.
+	*/
+	processResponseHeaders(response, _context, _methodType) {
+		const statusCode = response.status;
+		if (statusCode === void 0) throw new TempoError(TempoStatusCode.UNKNOWN, "tempo-status missing from response.");
+		if (statusCode !== TempoStatusCode.OK && statusCode !== TempoStatusCode.CANCELLED) {
+			let tempoMessage = response.msg;
+			if (!tempoMessage) tempoMessage = "unknown error";
+			throw new TempoError(statusCode, tempoMessage);
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startUnary}
+	*/
+	async startUnary(request, context, method, options) {
+		try {
+			const requestData = method.serialize(request);
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(requestData, context, method, options);
+			let response;
+			if (options?.retryPolicy) response = await this.executeWithRetry(async (retryAttempt) => {
+				if (retryAttempt > 0) requestInit.previousAttempts = retryAttempt;
+				return await this.fetchUnary(requestInit);
+			}, options.retryPolicy, options.deadline, options.controller);
+			else if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return await this.fetchUnary(requestInit, options);
+			}, options.controller);
+			else response = await this.fetchUnary(requestInit, options);
+			this.processResponseHeaders(response, context, method.type);
+			if (this.hooks !== void 0) await this.hooks.executeResponseHooks(context);
+			const responseData = response.data;
+			const record = method.deserialize(responseData);
+			if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+			return record;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startClientStream}
+	*/
+	async startClientStream(generator, context, method, options) {
+		try {
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(new Uint8Array(), context, method, options);
+			let response;
+			if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return await this.fetchClientStream(requestInit, method, generator, options);
+			}, options.controller);
+			else response = await this.fetchClientStream(requestInit, method, generator, options);
+			this.processResponseHeaders(response, context, method.type);
+			const responseData = response.data;
+			const record = this.deserializeResponse(responseData, method);
+			if (this.hooks !== void 0) this.hooks.executeDecodeHooks(context, record);
+			return record;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startServerStream}
+	*/
+	async startServerStream(request, context, method, options) {
+		try {
+			const requestData = method.serialize(request);
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(requestData, context, method, options);
+			let response;
+			if (options?.retryPolicy) response = await this.executeWithRetry(async (retryAttempt) => {
+				if (retryAttempt > 0) requestInit.previousAttempts = retryAttempt;
+				return this.fetchServerStream(requestInit, context, method, options);
+			}, options.retryPolicy, options.deadline, options.controller);
+			else if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return this.fetchServerStream(requestInit, context, method, options);
+			}, options.controller);
+			else response = this.fetchServerStream(requestInit, context, method, options);
+			return response;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+	/**
+	* {@inheritDoc BaseChannel.startDuplexStream}
+	*/
+	async startDuplexStream(generator, context, method, options) {
+		try {
+			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+			const requestInit = this.createRequest(new Uint8Array(), context, method, options);
+			let response;
+			if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
+				return this.fetchDuplexStream(requestInit, context, method, generator, options);
+			}, options.controller);
+			else response = this.fetchDuplexStream(requestInit, context, method, generator, options);
+			return response;
+		} catch (e) {
+			if (this.hooks !== void 0 && e instanceof Error) this.hooks.executeErrorHooks(context, e);
+			if (e instanceof TempoError) throw e;
+			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
+			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
+			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
+		}
+	}
+	sendMessage(message) {
+		return browser.runtime.sendMessage(Array.apply(null, Message.encode(message)));
+	}
+};
+//#endregion
+export { TempoExtensionChannel };

package/dist/extension-router.d.mts

@@ -0,0 +1,154 @@
+import { Message } from "./bebop.mjs";
+import { BebopRecord } from "bebop";
+import { BebopContentType, HookRegistry, Metadata, TempoLogger } from "@tempojs/common";
+import { Runtime } from "webextension-polyfill";
+import { AuthInterceptor, BebopMethodAny, ServerContext, ServiceRegistry, TempoRouterConfiguration } from "@tempojs/server";
+
+//#region src/extension-router.d.ts
+/**
+ * Interface defining the configuration options for a TempoRouter instance.
+ */
+declare class TempoExtensionRouterConfiguration {
+  static readonly defaultMaxRetryAttempts: number;
+  static readonly defaultMaxReceiveMessageSize: number;
+  static readonly defaultMaxSendMessageSize: number;
+  /**
+   * Optional flag to enable CORS (Cross-Origin Resource Sharing) support.
+   */
+  enableCors?: boolean;
+  /**
+   * Optional list of allowed origins for CORS. Ignored if enableCors is false.
+   */
+  allowedOrigins?: string[];
+  /**
+   * Optional flag to indicate whether internal errors should be transmitted
+   * in the API response. Defaults to false, meaning internal errors are
+   * masked and not exposed to clients.
+   */
+  transmitInternalErrors?: boolean;
+  /**
+   * The maximum size of the message that can be received. Defaults to the value in `TempoRouterConfiguration.defaultMaxReceiveMessageSize`.
+   */
+  maxReceiveMessageSize?: number;
+  /**
+   * The maximum size of the message that can be sent.
+   */
+  maxSendMessageSize?: number;
+  /**
+   * The maximum number of retry attempts for failed requests. Defaults to the value in `TempoRouterConfiguration.defaultMaxRetryAttempts`.
+   */
+  maxRetryAttempts?: number;
+  /**
+   * Constructs a new instance of TempoRouterConfiguration with default values.
+   */
+  constructor();
+}
+/**
+ * Represents an abstract base class for a router that handles incoming requests, performs validation, and routes
+ * them to the appropriate services and methods in a Tempo application.
+ *
+ * @template TRequest - The type of the request object.
+ * @template TEnvironment - The type of the environment/context object.
+ * @template TResponse - The type of the response object.
+ */
+declare abstract class ExtensionBaseRouter<TRequest, TEnvironment, TResponse> {
+  protected readonly logger: TempoLogger;
+  protected readonly registry: ServiceRegistry;
+  protected readonly configuration: TempoRouterConfiguration;
+  protected readonly authInterceptor?: AuthInterceptor | undefined;
+  protected readonly corsEnabled: boolean;
+  protected readonly allowedCorsOrigins: string[] | undefined;
+  protected readonly transmitInternalErrors: boolean;
+  protected readonly maxReceiveMessageSize: number;
+  protected readonly maxSendMessageSize?: number;
+  protected readonly maxRetryAttempts: number;
+  protected readonly exposeTempo: boolean;
+  protected hooks?: HookRegistry<ServerContext, TEnvironment>;
+  protected poweredByHeader: string;
+  protected poweredByHeaderValue?: string;
+  /**
+   * Constructs a new BaseRouter instance.
+   * @param logger - The logger to use for logging router-related information.
+   * @param registry - The service registry instance that manages services and methods for this router.
+   * @param authInterceptor - The interceptor (if any) that will be used for authenticating the peer of an incoming requests.
+   */
+  constructor(logger: TempoLogger, registry: ServiceRegistry, configuration: TempoRouterConfiguration, authInterceptor?: AuthInterceptor | undefined);
+  /**
+   * Handles an incoming request by routing it to the appropriate service and method, applying any necessary
+   * validation and processing and returns a response.
+   *
+   * @param request - The incoming request object.
+   * @param env - The environment/context object associated with the request.
+   * @returns A promise that resolves to the response object.
+   */
+  abstract handle(request: TRequest, env: TEnvironment): Promise<TResponse>;
+  /**
+   * Processes an incoming request by routing it to the appropriate service and method, applying any necessary
+   * validation and processing, in place on the provided response object.
+   *
+   * @param request - The incoming request object.
+   * @param response - The outgoing response object.
+   * @param env - The environment/context object associated with the request.
+   */
+  abstract process(request: TRequest, response: TResponse, env: TEnvironment): Promise<void>;
+  /**
+   * Private function that retrieves custom metadata from the header.
+   *
+   * @private
+   * @function
+   * @param {string | null} value The custom metadata value from the request.
+   * @returns {Metadata} The metadata object.
+   */
+  protected getCustomMetaData(value: string | null | undefined): Metadata;
+  /**
+   * Defines a hook registry for the router.
+   * @param hooks - The hook registry to be used.
+   */
+  useHooks(hooks: HookRegistry<ServerContext, TEnvironment>): void;
+  protected definePoweredByHeader(variant: string): void;
+  /**
+   * Deserializes an incoming request based on its content type.
+   *
+   * @param requestData - The incoming request data as a Uint8Array.
+   * @param method - The Bebop method to use for deserialization.
+   * @param contentType - The content type of the incoming request.
+   * @returns The deserialized request record.
+   * @throws {TempoError} When the content type is not valid.
+   * @throws {BebopRuntimeError} When the request data cannot be deserialized.
+   */
+  protected deserializeRequest(requestData: Uint8Array, method: BebopMethodAny, contentType: BebopContentType): BebopRecord;
+  /**
+   * Serializes a response record based on its content type.
+   *
+   * @param response - The response record to be serialized.
+   * @param method - The Bebop method to use for serialization.
+   * @param contentType - The content type of the response.
+   * @returns The serialized response as a Uint8Array.
+   * @throws {TempoError} When the content type is not valid.
+   * @throws {BebopRuntimeError} When the response record cannot be serialized.
+   */
+  protected serializeResponse(response: BebopRecord, method: BebopMethodAny, contentType: BebopContentType): Uint8Array;
+}
+declare class TempoExtensionRouter<Ctx extends {
+  sender: Runtime.MessageSender;
+}> extends ExtensionBaseRouter<Message, Ctx, Message> {
+  private readonly events;
+  private readonly clientStreams;
+  constructor(logger: TempoLogger, registry: ServiceRegistry, configuration?: TempoRouterConfiguration, authInterceptor?: AuthInterceptor);
+  private setAuthContext;
+  private invokeUnaryMethod;
+  private invokeClientStreamMethod;
+  private invokeServerStreamMethod;
+  private invokeDuplexStreamMethod;
+  /**
+   * Tear down all open streams for this connection. Emits a synthetic CANCELLED
+   * to each in-flight client/duplex stream so its generator ends, then clears
+   * all listeners.
+   */
+  closeConnection(): Promise<void>;
+  process(req: Message, response: Message, ctx: Ctx): Promise<void>;
+  private send;
+  handle(_req: Message, _ctx: Ctx): Promise<Message>;
+}
+//#endregion
+export { ExtensionBaseRouter, TempoExtensionRouter, TempoExtensionRouterConfiguration };