@sortsys/v2-client 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -1,9 +1,1768 @@
 // Generated by dts-bundle-generator v9.5.1
 
-import { TRPCClient, TRPCClientError } from '@trpc/client';
-import { Request as Request$1, Response as Response$1 } from 'express-serve-static-core';
-import { Observable } from 'rxjs';
+import { EventEmitter } from 'events';
+import * as http from 'http';
+import { SendOptions } from 'send';
 
+interface ConnectionStateBase<TError> {
+	type: "state";
+	data?: never;
+	error: TError | null;
+}
+interface ConnectionIdleState extends ConnectionStateBase<null> {
+	state: "idle";
+}
+interface ConnectionConnectingState<TError> extends ConnectionStateBase<TError | null> {
+	state: "connecting";
+}
+interface ConnectionPendingState extends ConnectionStateBase<null> {
+	state: "pending";
+}
+type TRPCConnectionState<TError> = ConnectionIdleState | ConnectionConnectingState<TError> | ConnectionPendingState;
+interface Unsubscribable {
+	unsubscribe(): void;
+}
+interface Subscribable<TValue, TError> {
+	subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
+}
+interface Observable<TValue, TError> extends Subscribable<TValue, TError> {
+	pipe(): Observable<TValue, TError>;
+	pipe<TValue1, TError1>(op1: OperatorFunction<TValue, TError, TValue1, TError1>): Observable<TValue1, TError1>;
+	pipe<TValue1, TError1, TValue2, TError2>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>): Observable<TValue2, TError2>;
+	pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>): Observable<TValue2, TError2>;
+	pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>): Observable<TValue2, TError2>;
+	pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4, TValue5, TError5>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>, op5: OperatorFunction<TValue4, TError4, TValue5, TError5>): Observable<TValue2, TError2>;
+}
+interface Observer<TValue, TError> {
+	next: (value: TValue) => void;
+	error: (err: TError) => void;
+	complete: () => void;
+}
+type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
+type OperatorFunction<TValueBefore, TErrorBefore, TValueAfter, TErrorAfter> = UnaryFunction<Subscribable<TValueBefore, TErrorBefore>, Subscribable<TValueAfter, TErrorAfter>>;
+type Maybe<TType> = TType | null | undefined;
+type Simplify<TType> = TType extends any[] | Date ? TType : {
+	[K in keyof TType]: TType[K];
+};
+type MaybePromise<TType> = Promise<TType> | TType;
+type WithoutIndexSignature<TObj> = {
+	[K in keyof TObj as string extends K ? never : number extends K ? never : K]: TObj[K];
+};
+type GetRawInputFn = () => Promise<unknown>;
+declare const _errorSymbol: unique symbol;
+type TypeError$1<TMessage extends string> = TMessage & {
+	_: typeof _errorSymbol;
+};
+type ValueOf<TObj> = TObj[keyof TObj];
+type inferAsyncIterableYield<T> = T extends AsyncIterable<infer U> ? U : T;
+declare const TRPC_ERROR_CODES_BY_KEY: {
+	/**
+	 * Invalid JSON was received by the server.
+	 * An error occurred on the server while parsing the JSON text.
+	 */
+	readonly PARSE_ERROR: -32700;
+	/**
+	 * The JSON sent is not a valid Request object.
+	 */
+	readonly BAD_REQUEST: -32600;
+	readonly INTERNAL_SERVER_ERROR: -32603;
+	readonly NOT_IMPLEMENTED: -32603;
+	readonly BAD_GATEWAY: -32603;
+	readonly SERVICE_UNAVAILABLE: -32603;
+	readonly GATEWAY_TIMEOUT: -32603;
+	readonly UNAUTHORIZED: -32001;
+	readonly PAYMENT_REQUIRED: -32002;
+	readonly FORBIDDEN: -32003;
+	readonly NOT_FOUND: -32004;
+	readonly METHOD_NOT_SUPPORTED: -32005;
+	readonly TIMEOUT: -32008;
+	readonly CONFLICT: -32009;
+	readonly PRECONDITION_FAILED: -32012;
+	readonly PAYLOAD_TOO_LARGE: -32013;
+	readonly UNSUPPORTED_MEDIA_TYPE: -32015;
+	readonly UNPROCESSABLE_CONTENT: -32022;
+	readonly PRECONDITION_REQUIRED: -32028;
+	readonly TOO_MANY_REQUESTS: -32029;
+	readonly CLIENT_CLOSED_REQUEST: -32099;
+};
+type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
+type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;
+declare class TRPCError extends Error {
+	readonly cause?: Error;
+	readonly code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
+	constructor(opts: {
+		message?: string;
+		code: TRPC_ERROR_CODE_KEY;
+		cause?: unknown;
+	});
+}
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+	/** The Standard Schema properties. */
+	readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+	/** The Standard Schema properties interface. */
+	interface Props<Input = unknown, Output = Input> {
+		/** The version number of the standard. */
+		readonly version: 1;
+		/** The vendor name of the schema library. */
+		readonly vendor: string;
+		/** Validates unknown input values. */
+		readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+		/** Inferred types associated with the schema. */
+		readonly types?: Types<Input, Output> | undefined;
+	}
+	/** The result interface of the validate function. */
+	type Result<Output> = SuccessResult<Output> | FailureResult;
+	/** The result interface if validation succeeds. */
+	interface SuccessResult<Output> {
+		/** The typed output value. */
+		readonly value: Output;
+		/** The non-existent issues. */
+		readonly issues?: undefined;
+	}
+	/** The result interface if validation fails. */
+	interface FailureResult {
+		/** The issues of failed validation. */
+		readonly issues: ReadonlyArray<Issue>;
+	}
+	/** The issue interface of the failure output. */
+	interface Issue {
+		/** The error message of the issue. */
+		readonly message: string;
+		/** The path of the issue, if any. */
+		readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+	}
+	/** The path segment interface of the issue. */
+	interface PathSegment {
+		/** The key representing a path segment. */
+		readonly key: PropertyKey;
+	}
+	/** The Standard Schema types interface. */
+	interface Types<Input = unknown, Output = Input> {
+		/** The input type of the schema. */
+		readonly input: Input;
+		/** The output type of the schema. */
+		readonly output: Output;
+	}
+	/** Infers the input type of a Standard Schema. */
+	type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+	/** Infers the output type of a Standard Schema. */
+	type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+type ParserZodEsque<TInput, TParsedInput> = {
+	_input: TInput;
+	_output: TParsedInput;
+};
+type ParserValibotEsque<TInput, TParsedInput> = {
+	schema: {
+		_types?: {
+			input: TInput;
+			output: TParsedInput;
+		};
+	};
+};
+type ParserArkTypeEsque<TInput, TParsedInput> = {
+	inferIn: TInput;
+	infer: TParsedInput;
+};
+type ParserStandardSchemaEsque<TInput, TParsedInput> = StandardSchemaV1<TInput, TParsedInput>;
+type ParserMyZodEsque<TInput> = {
+	parse: (input: any) => TInput;
+};
+type ParserSuperstructEsque<TInput> = {
+	create: (input: unknown) => TInput;
+};
+type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
+type ParserYupEsque<TInput> = {
+	validateSync: (input: unknown) => TInput;
+};
+type ParserScaleEsque<TInput> = {
+	assert(value: unknown): asserts value is TInput;
+};
+type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
+type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput> | ParserArkTypeEsque<TInput, TParsedInput> | ParserStandardSchemaEsque<TInput, TParsedInput>;
+type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+interface ProcedureCallOptions<TContext> {
+	ctx: TContext;
+	getRawInput: GetRawInputFn;
+	input?: unknown;
+	path: string;
+	type: ProcedureType;
+	signal: AbortSignal | undefined;
+}
+declare const procedureTypes: readonly [
+	"query",
+	"mutation",
+	"subscription"
+];
+type ProcedureType = (typeof procedureTypes)[number];
+interface BuiltProcedureDef {
+	meta: unknown;
+	input: unknown;
+	output: unknown;
+}
+interface Procedure<TType extends ProcedureType, TDef extends BuiltProcedureDef> {
+	_def: {
+		/**
+		 * These are just types, they can't be used at runtime
+		 * @internal
+		 */
+		$types: {
+			input: TDef["input"];
+			output: TDef["output"];
+		};
+		procedure: true;
+		type: TType;
+		/**
+		 * @internal
+		 * Meta is not inferrable on individual procedures, only on the router
+		 */
+		meta: unknown;
+		experimental_caller: boolean;
+		/**
+		 * The input parsers for the procedure
+		 */
+		inputs: Parser[];
+	};
+	meta: TDef["meta"];
+	/**
+	 * @internal
+	 */
+	(opts: ProcedureCallOptions<unknown>): Promise<TDef["output"]>;
+}
+interface QueryProcedure<TDef extends BuiltProcedureDef> extends Procedure<"query", TDef> {
+}
+interface MutationProcedure<TDef extends BuiltProcedureDef> extends Procedure<"mutation", TDef> {
+}
+interface SubscriptionProcedure<TDef extends BuiltProcedureDef> extends Procedure<"subscription", TDef> {
+}
+interface LegacyObservableSubscriptionProcedure<TDef extends BuiltProcedureDef> extends SubscriptionProcedure<TDef> {
+	_observable: true;
+}
+type AnyQueryProcedure = QueryProcedure<any>;
+type AnyMutationProcedure = MutationProcedure<any>;
+type AnySubscriptionProcedure = SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
+type AnyProcedure = AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
+type inferProcedureInput<TProcedure extends AnyProcedure> = undefined extends inferProcedureParams<TProcedure>["$types"]["input"] ? void | inferProcedureParams<TProcedure>["$types"]["input"] : inferProcedureParams<TProcedure>["$types"]["input"];
+type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure ? TProcedure["_def"] : never;
+type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>["$types"]["output"];
+interface ErrorHandlerOptions<TContext> {
+	error: TRPCError;
+	type: ProcedureType | "unknown";
+	path: string | undefined;
+	input: unknown;
+	ctx: TContext | undefined;
+}
+interface TRPCErrorShape<TData extends object = object> {
+	code: TRPC_ERROR_CODE_NUMBER;
+	message: string;
+	data: TData;
+}
+declare namespace JSONRPC2 {
+	type RequestId = number | string | null;
+	/**
+	 * All requests/responses extends this shape
+	 */
+	interface BaseEnvelope {
+		id?: RequestId;
+		jsonrpc?: "2.0";
+	}
+	interface BaseRequest<TMethod extends string = string> extends BaseEnvelope {
+		method: TMethod;
+	}
+	interface Request<TMethod extends string = string, TParams = unknown> extends BaseRequest<TMethod> {
+		params: TParams;
+	}
+	interface ResultResponse<TResult = unknown> extends BaseEnvelope {
+		result: TResult;
+	}
+	interface ErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape> extends BaseEnvelope {
+		error: TError;
+	}
+}
+interface TRPCResult<TData = unknown> {
+	data: TData;
+	type?: "data";
+	/**
+	 * The id of the message to keep track of in case of a reconnect
+	 */
+	id?: string;
+}
+interface TRPCSuccessResponse<TData> extends JSONRPC2.ResultResponse<TRPCResult<TData>> {
+}
+interface TRPCErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape> extends JSONRPC2.ErrorResponse<TError> {
+}
+interface TRPCResultMessage<TData> extends JSONRPC2.ResultResponse<{
+	type: "started";
+	data?: never;
+} | {
+	type: "stopped";
+	data?: never;
+} | TRPCResult<TData>> {
+}
+interface DataTransformer {
+	serialize(object: any): any;
+	deserialize(object: any): any;
+}
+interface InputDataTransformer extends DataTransformer {
+	/**
+	 * This function runs **on the client** before sending the data to the server.
+	 */
+	serialize(object: any): any;
+	/**
+	 * This function runs **on the server** to transform the data before it is passed to the resolver
+	 */
+	deserialize(object: any): any;
+}
+interface OutputDataTransformer extends DataTransformer {
+	/**
+	 * This function runs **on the server** before sending the data to the client.
+	 */
+	serialize(object: any): any;
+	/**
+	 * This function runs **only on the client** to transform the data sent from the server.
+	 */
+	deserialize(object: any): any;
+}
+interface CombinedDataTransformer {
+	/**
+	 * Specify how the data sent from the client to the server should be transformed.
+	 */
+	input: InputDataTransformer;
+	/**
+	 * Specify how the data sent from the server to the client should be transformed.
+	 */
+	output: OutputDataTransformer;
+}
+type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: {
+	error: TRPCError;
+	type: ProcedureType | "unknown";
+	path: string | undefined;
+	input: unknown;
+	ctx: TContext | undefined;
+	shape: DefaultErrorShape;
+}) => TShape;
+type DefaultErrorData = {
+	code: TRPC_ERROR_CODE_KEY;
+	httpStatus: number;
+	/**
+	 * Path to the procedure that threw the error
+	 */
+	path?: string;
+	/**
+	 * Stack trace of the error (only in development)
+	 */
+	stack?: string;
+};
+interface DefaultErrorShape extends TRPCErrorShape<DefaultErrorData> {
+	message: string;
+	code: TRPC_ERROR_CODE_NUMBER;
+}
+type Serialize$2 = (value: any) => any;
+type PathArray = readonly (string | number)[];
+type ProducerOnError = (opts: {
+	error: unknown;
+	path: PathArray;
+}) => void;
+interface JSONLProducerOptions {
+	serialize?: Serialize$2;
+	data: Record<string, unknown> | unknown[];
+	onError?: ProducerOnError;
+	formatError?: (opts: {
+		error: unknown;
+		path: PathArray;
+	}) => unknown;
+	maxDepth?: number;
+	/**
+	 * Interval in milliseconds to send a ping to the client to keep the connection alive
+	 * This will be sent as a whitespace character
+	 * @default undefined
+	 */
+	pingMs?: number;
+}
+type Serialize$1 = (value: any) => any;
+interface SSEPingOptions {
+	/**
+	 * Enable ping comments sent from the server
+	 * @default false
+	 */
+	enabled: boolean;
+	/**
+	 * Interval in milliseconds
+	 * @default 1000
+	 */
+	intervalMs?: number;
+}
+interface SSEClientOptions {
+	/**
+	 * Timeout and reconnect after inactivity in milliseconds
+	 * @default undefined
+	 */
+	reconnectAfterInactivityMs?: number;
+}
+interface SSEStreamProducerOptions<TValue = unknown> {
+	serialize?: Serialize$1;
+	data: AsyncIterable<TValue>;
+	maxDepth?: number;
+	ping?: SSEPingOptions;
+	/**
+	 * Maximum duration in milliseconds for the request before ending the stream
+	 * @default undefined
+	 */
+	maxDurationMs?: number;
+	/**
+	 * End the request immediately after data is sent
+	 * Only useful for serverless runtimes that do not support streaming responses
+	 * @default false
+	 */
+	emitAndEndImmediately?: boolean;
+	formatError?: (opts: {
+		error: unknown;
+	}) => unknown;
+	/**
+	 * Client-specific options - these will be sent to the client as part of the first message
+	 * @default {}
+	 */
+	client?: SSEClientOptions;
+}
+interface RootTypes {
+	ctx: object;
+	meta: object;
+	errorShape: DefaultErrorShape;
+	transformer: boolean;
+}
+interface RootConfig<TTypes extends RootTypes> {
+	/**
+	 * The types that are used in the config
+	 * @internal
+	 */
+	$types: TTypes;
+	/**
+	 * Use a data transformer
+	 * @see https://trpc.io/docs/v11/data-transformers
+	 */
+	transformer: CombinedDataTransformer;
+	/**
+	 * Use custom error formatting
+	 * @see https://trpc.io/docs/v11/error-formatting
+	 */
+	errorFormatter: ErrorFormatter<TTypes["ctx"], TTypes["errorShape"]>;
+	/**
+	 * Allow `@trpc/server` to run in non-server environments
+	 * @warning **Use with caution**, this should likely mainly be used within testing.
+	 * @default false
+	 */
+	allowOutsideOfServer: boolean;
+	/**
+	 * Is this a server environment?
+	 * @warning **Use with caution**, this should likely mainly be used within testing.
+	 * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
+	 */
+	isServer: boolean;
+	/**
+	 * Is this development?
+	 * Will be used to decide if the API should return stack traces
+	 * @default process.env.NODE_ENV !== 'production'
+	 */
+	isDev: boolean;
+	defaultMeta?: TTypes["meta"] extends object ? TTypes["meta"] : never;
+	/**
+	 * Options for server-sent events (SSE) subscriptions
+	 * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+	 */
+	sse?: {
+		/**
+		 * Enable server-sent events (SSE) subscriptions
+		 * @default true
+		 */
+		enabled?: boolean;
+	} & Pick<SSEStreamProducerOptions, "ping" | "emitAndEndImmediately" | "maxDurationMs" | "client">;
+	/**
+	 * Options for batch stream
+	 * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+	 */
+	jsonl?: Pick<JSONLProducerOptions, "pingMs">;
+	experimental?: {};
+}
+type CreateRootTypes<TGenerics extends RootTypes> = TGenerics;
+type AnyRootTypes = CreateRootTypes<{
+	ctx: any;
+	meta: any;
+	errorShape: any;
+	transformer: any;
+}>;
+interface RouterRecord {
+	[key: string]: AnyProcedure | RouterRecord;
+}
+type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedureInput<TProcedure>) => Promise<TProcedure["_def"]["type"] extends "subscription" ? TProcedure extends LegacyObservableSubscriptionProcedure<any> ? Observable<inferProcedureOutput<TProcedure>, TRPCError> : inferProcedureOutput<TProcedure> : inferProcedureOutput<TProcedure>>;
+type DecorateRouterRecord<TRecord extends RouterRecord> = {
+	[TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never;
+};
+type RouterCallerErrorHandler<TContext> = (opts: ErrorHandlerOptions<TContext>) => void;
+type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
+/**
+ * @note
+ * If passing a function, we recommend it's a cached function
+ * e.g. wrapped in `React.cache` to avoid unnecessary computations
+ */
+ctx: TRoot["ctx"] | (() => MaybePromise<TRoot["ctx"]>), options?: {
+	onError?: RouterCallerErrorHandler<TRoot["ctx"]>;
+	signal?: AbortSignal;
+}) => DecorateRouterRecord<TRecord>;
+type Lazy<TAny> = (() => Promise<TAny>) & {};
+type LazyLoader<TAny> = {
+	load: () => Promise<void>;
+	ref: Lazy<TAny>;
+};
+interface RouterDef<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+	_config: RootConfig<TRoot>;
+	router: true;
+	procedure?: never;
+	procedures: TRecord;
+	record: TRecord;
+	lazy: Record<string, LazyLoader<AnyRouter>>;
+}
+interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+	_def: RouterDef<TRoot, TRecord>;
+	/**
+	 * @see https://trpc.io/docs/v11/server/server-side-calls
+	 */
+	createCaller: RouterCaller<TRoot, TRecord>;
+}
+type BuiltRouter<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = Router<TRoot, TRecord> & TRecord;
+type AnyRouter = Router<any, any>;
+type CreateRouterOptions = {
+	[key: string]: AnyProcedure | AnyRouter | CreateRouterOptions | Lazy<AnyRouter>;
+};
+type DecorateCreateRouterOptions<TRouterOptions extends CreateRouterOptions> = {
+	[K in keyof TRouterOptions]: TRouterOptions[K] extends infer $Value ? $Value extends AnyProcedure ? $Value : $Value extends Router<any, infer TRecord> ? TRecord : $Value extends Lazy<Router<any, infer TRecord>> ? TRecord : $Value extends CreateRouterOptions ? DecorateCreateRouterOptions<$Value> : never : never;
+};
+type AnyClientTypes = Pick<AnyRootTypes, "errorShape" | "transformer">;
+type InitLike = {
+	_config: {
+		$types: AnyClientTypes;
+	};
+};
+type RouterLike = {
+	_def: InitLike;
+};
+type RootConfigLike = {
+	$types: AnyClientTypes;
+};
+type InferrableClientTypes = RouterLike | InitLike | RootConfigLike | AnyClientTypes;
+type PickTypes<T extends AnyClientTypes> = {
+	transformer: T["transformer"];
+	errorShape: T["errorShape"];
+};
+type inferClientTypes<TInferrable extends InferrableClientTypes> = TInferrable extends AnyClientTypes ? PickTypes<TInferrable> : TInferrable extends RootConfigLike ? PickTypes<TInferrable["$types"]> : TInferrable extends InitLike ? PickTypes<TInferrable["_config"]["$types"]> : TInferrable extends RouterLike ? PickTypes<TInferrable["_def"]["_config"]["$types"]> : never;
+type JsonPrimitive = boolean | number | string | null;
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonObject = {
+	readonly [key: string | number]: JsonValue;
+	[key: symbol]: never;
+};
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type IsJson<T> = T extends JsonValue ? true : false;
+type NonJsonPrimitive = Function | symbol | undefined;
+type IsAny<T> = 0 extends T & 1 ? true : false;
+type JsonReturnable = JsonPrimitive | undefined;
+type IsRecord<T extends object> = keyof WithoutIndexSignature<T> extends never ? true : false;
+type Serialize<T> = IsAny<T> extends true ? any : unknown extends T ? unknown : IsJson<T> extends true ? T : T extends AsyncIterable<infer $T, infer $Return, infer $Next> ? AsyncIterable<Serialize<$T>, Serialize<$Return>, Serialize<$Next>> : T extends PromiseLike<infer $T> ? Promise<Serialize<$T>> : T extends JsonReturnable ? T : T extends Map<any, any> | Set<any> ? object : T extends NonJsonPrimitive ? never : T extends {
+	toJSON(): infer U;
+} ? U : T extends [
+] ? [
+] : T extends [
+	unknown,
+	...unknown[]
+] ? SerializeTuple<T> : T extends readonly (infer U)[] ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] : T extends object ? IsRecord<T> extends true ? Record<keyof T, Serialize<T[keyof T]>> : Simplify<SerializeObject<UndefinedToOptional<T>>> : never;
+type SerializeTuple<T extends [
+	unknown,
+	...unknown[]
+]> = {
+	[K in keyof T]: T[K] extends NonJsonPrimitive ? null : Serialize<T[K]>;
+};
+type SerializeObjectKey<T extends Record<any, any>, K> = K extends symbol ? never : IsAny<T[K]> extends true ? K : unknown extends T[K] ? K : T[K] extends NonJsonPrimitive ? never : K;
+type SerializeObject<T extends object> = {
+	[K in keyof T as SerializeObjectKey<T, K>]: Serialize<T[K]>;
+};
+type FilterDefinedKeys<T extends object> = Exclude<{
+	[K in keyof T]: undefined extends T[K] ? never : K;
+}[keyof T], undefined>;
+type ExactOptionalPropertyTypes = {
+	a?: 0 | undefined;
+} extends {
+	a?: 0;
+} ? false : true;
+type HasIndexSignature<T extends object> = string extends keyof T ? true : false;
+type HandleIndexSignature<T extends object> = {
+	[K in keyof Omit<T, keyof WithoutIndexSignature<T>>]: Exclude<T[K], undefined>;
+};
+type HandleUndefined<T extends object> = {
+	[K in keyof Omit<T, FilterDefinedKeys<T>>]?: Exclude<T[K], undefined>;
+};
+type UndefinedToOptional<T extends object> = Pick<WithoutIndexSignature<T>, FilterDefinedKeys<WithoutIndexSignature<T>>> & (ExactOptionalPropertyTypes extends true ? HandleIndexSignature<T> & HandleUndefined<WithoutIndexSignature<T>> : HasIndexSignature<T> extends true ? HandleIndexSignature<T> : HandleUndefined<T>);
+type inferTransformedProcedureOutput<TInferrable extends InferrableClientTypes, TProcedure extends AnyProcedure> = inferClientTypes<TInferrable>["transformer"] extends false ? Serialize<inferProcedureOutput<TProcedure>> : inferProcedureOutput<TProcedure>;
+type ClientContext = Record<string, unknown>;
+interface TRPCProcedureOptions {
+	/**
+	 * Client-side context
+	 */
+	context?: ClientContext;
+	signal?: AbortSignal;
+}
+type inferErrorShape<TInferrable extends InferrableClientTypes> = inferClientTypes<TInferrable>["errorShape"];
+interface TRPCClientErrorBase<TShape extends DefaultErrorShape> {
+	readonly message: string;
+	readonly shape: Maybe<TShape>;
+	readonly data: Maybe<TShape["data"]>;
+}
+declare class TRPCClientError<TRouterOrProcedure extends InferrableClientTypes> extends Error implements TRPCClientErrorBase<inferErrorShape<TRouterOrProcedure>> {
+	readonly cause: Error | undefined;
+	readonly shape: Maybe<inferErrorShape<TRouterOrProcedure>>;
+	readonly data: Maybe<inferErrorShape<TRouterOrProcedure>["data"]>;
+	/**
+	 * Additional meta data about the error
+	 * In the case of HTTP-errors, we'll have `response` and potentially `responseJSON` here
+	 */
+	meta: Record<string, unknown> | undefined;
+	constructor(message: string, opts?: {
+		result?: Maybe<TRPCErrorResponse<inferErrorShape<TRouterOrProcedure>>>;
+		cause?: Error;
+		meta?: Record<string, unknown>;
+	});
+	static from<TRouterOrProcedure extends InferrableClientTypes>(_cause: Error | TRPCErrorResponse<any> | object, opts?: {
+		meta?: Record<string, unknown>;
+	}): TRPCClientError<TRouterOrProcedure>;
+}
+interface OperationContext extends Record<string, unknown> {
+}
+type Operation<TInput = unknown> = {
+	id: number;
+	type: "mutation" | "query" | "subscription";
+	input: TInput;
+	path: string;
+	context: OperationContext;
+	signal: Maybe<AbortSignal>;
+};
+interface TRPCClientRuntime {
+}
+interface OperationResultEnvelope<TOutput, TError> {
+	result: TRPCResultMessage<TOutput>["result"] | TRPCSuccessResponse<TOutput>["result"] | TRPCConnectionState<TError>;
+	context?: OperationContext;
+}
+type OperationResultObservable<TInferrable extends InferrableClientTypes, TOutput> = Observable<OperationResultEnvelope<TOutput, TRPCClientError<TInferrable>>, TRPCClientError<TInferrable>>;
+type OperationLink<TInferrable extends InferrableClientTypes, TInput = unknown, TOutput = unknown> = (opts: {
+	op: Operation<TInput>;
+	next: (op: Operation<TInput>) => OperationResultObservable<TInferrable, TOutput>;
+}) => OperationResultObservable<TInferrable, TOutput>;
+type TRPCLink<TInferrable extends InferrableClientTypes> = (opts: TRPCClientRuntime) => OperationLink<TInferrable>;
+interface TRPCRequestOptions {
+	/**
+	 * Pass additional context to links
+	 */
+	context?: OperationContext;
+	signal?: AbortSignal;
+}
+interface TRPCSubscriptionObserver<TValue, TError> {
+	onStarted: (opts: {
+		context: OperationContext | undefined;
+	}) => void;
+	onData: (value: inferAsyncIterableYield<TValue>) => void;
+	onError: (err: TError) => void;
+	onStopped: () => void;
+	onComplete: () => void;
+	onConnectionStateChange: (state: TRPCConnectionState<TError>) => void;
+}
+type CreateTRPCClientOptions<TRouter extends InferrableClientTypes> = {
+	links: TRPCLink<TRouter>[];
+	transformer?: TypeError$1<"The transformer property has moved to httpLink/httpBatchLink/wsLink">;
+};
+declare class TRPCUntypedClient<TInferrable extends InferrableClientTypes> {
+	private readonly links;
+	readonly runtime: TRPCClientRuntime;
+	private requestId;
+	constructor(opts: CreateTRPCClientOptions<TInferrable>);
+	private $request;
+	private requestAsPromise;
+	query(path: string, input?: unknown, opts?: TRPCRequestOptions): Promise<unknown>;
+	mutation(path: string, input?: unknown, opts?: TRPCRequestOptions): Promise<unknown>;
+	subscription(path: string, input: unknown, opts: Partial<TRPCSubscriptionObserver<unknown, TRPCClientError<AnyRouter>>> & TRPCRequestOptions): Unsubscribable;
+}
+declare const untypedClientSymbol: unique symbol;
+type TRPCClient<TRouter extends AnyRouter> = DecoratedProcedureRecord<{
+	transformer: TRouter["_def"]["_config"]["$types"]["transformer"];
+	errorShape: TRouter["_def"]["_config"]["$types"]["errorShape"];
+}, TRouter["_def"]["record"]> & {
+	[untypedClientSymbol]: TRPCUntypedClient<TRouter>;
+};
+type ResolverDef = {
+	input: any;
+	output: any;
+	transformer: boolean;
+	errorShape: any;
+};
+type coerceAsyncGeneratorToIterable<T> = T extends AsyncGenerator<infer $T, infer $Return, infer $Next> ? AsyncIterable<$T, $Return, $Next> : T;
+type Resolver<TDef extends ResolverDef> = (input: TDef["input"], opts?: TRPCProcedureOptions) => Promise<coerceAsyncGeneratorToIterable<TDef["output"]>>;
+type SubscriptionResolver<TDef extends ResolverDef> = (input: TDef["input"], opts: Partial<TRPCSubscriptionObserver<TDef["output"], TRPCClientError<TDef>>> & TRPCProcedureOptions) => Unsubscribable;
+type DecorateProcedure$1<TType extends ProcedureType, TDef extends ResolverDef> = TType extends "query" ? {
+	query: Resolver<TDef>;
+} : TType extends "mutation" ? {
+	mutate: Resolver<TDef>;
+} : TType extends "subscription" ? {
+	subscribe: SubscriptionResolver<TDef>;
+} : never;
+type DecoratedProcedureRecord<TRoot extends InferrableClientTypes, TRecord extends RouterRecord> = {
+	[TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure$1<$Value["_def"]["type"], {
+		input: inferProcedureInput<$Value>;
+		output: inferTransformedProcedureOutput<inferClientTypes<TRoot>, $Value>;
+		errorShape: inferClientTypes<TRoot>["errorShape"];
+		transformer: inferClientTypes<TRoot>["transformer"];
+	}> : $Value extends RouterRecord ? DecoratedProcedureRecord<TRoot, $Value> : never : never;
+};
+declare namespace QueryString {
+	type defaultEncoder = (str: any, defaultEncoder?: any, charset?: string) => string;
+	type defaultDecoder = (str: string, decoder?: any, charset?: string) => string;
+	type BooleanOptional = boolean | undefined;
+	interface IStringifyBaseOptions {
+		delimiter?: string | undefined;
+		strictNullHandling?: boolean | undefined;
+		skipNulls?: boolean | undefined;
+		encode?: boolean | undefined;
+		encoder?: ((str: any, defaultEncoder: defaultEncoder, charset: string, type: "key" | "value") => string) | undefined;
+		filter?: Array<string | number> | ((prefix: string, value: any) => any) | undefined;
+		arrayFormat?: "indices" | "brackets" | "repeat" | "comma" | undefined;
+		indices?: boolean | undefined;
+		sort?: ((a: string, b: string) => number) | undefined;
+		serializeDate?: ((d: Date) => string) | undefined;
+		format?: "RFC1738" | "RFC3986" | undefined;
+		encodeValuesOnly?: boolean | undefined;
+		addQueryPrefix?: boolean | undefined;
+		charset?: "utf-8" | "iso-8859-1" | undefined;
+		charsetSentinel?: boolean | undefined;
+		allowEmptyArrays?: boolean | undefined;
+		commaRoundTrip?: boolean | undefined;
+	}
+	type IStringifyDynamicOptions<AllowDots extends BooleanOptional> = AllowDots extends true ? {
+		allowDots?: AllowDots;
+		encodeDotInKeys?: boolean;
+	} : {
+		allowDots?: boolean;
+		encodeDotInKeys?: false;
+	};
+	type IStringifyOptions<AllowDots extends BooleanOptional = undefined> = IStringifyBaseOptions & IStringifyDynamicOptions<AllowDots>;
+	interface IParseBaseOptions {
+		comma?: boolean | undefined;
+		delimiter?: string | RegExp | undefined;
+		depth?: number | false | undefined;
+		decoder?: ((str: string, defaultDecoder: defaultDecoder, charset: string, type: "key" | "value") => any) | undefined;
+		arrayLimit?: number | undefined;
+		parseArrays?: boolean | undefined;
+		plainObjects?: boolean | undefined;
+		allowPrototypes?: boolean | undefined;
+		allowSparse?: boolean | undefined;
+		parameterLimit?: number | undefined;
+		strictNullHandling?: boolean | undefined;
+		ignoreQueryPrefix?: boolean | undefined;
+		charset?: "utf-8" | "iso-8859-1" | undefined;
+		charsetSentinel?: boolean | undefined;
+		interpretNumericEntities?: boolean | undefined;
+		allowEmptyArrays?: boolean | undefined;
+		duplicates?: "combine" | "first" | "last" | undefined;
+		strictDepth?: boolean | undefined;
+		throwOnLimitExceeded?: boolean | undefined;
+	}
+	type IParseDynamicOptions<AllowDots extends BooleanOptional> = AllowDots extends true ? {
+		allowDots?: AllowDots;
+		decodeDotInKeys?: boolean;
+	} : {
+		allowDots?: boolean;
+		decodeDotInKeys?: false;
+	};
+	type IParseOptions<AllowDots extends BooleanOptional = undefined> = IParseBaseOptions & IParseDynamicOptions<AllowDots>;
+	interface ParsedQs {
+		[key: string]: undefined | string | ParsedQs | (string | ParsedQs)[];
+	}
+	function stringify(obj: any, options?: IStringifyOptions<BooleanOptional>): string;
+	function parse(str: string, options?: IParseOptions<BooleanOptional> & {
+		decoder?: never | undefined;
+	}): ParsedQs;
+	function parse(str: string | Record<string, string>, options?: IParseOptions<BooleanOptional>): {
+		[key: string]: unknown;
+	};
+}
+declare function RangeParser(size: number, str: string, options?: RangeParser.Options): RangeParser.Result | RangeParser.Ranges;
+declare namespace RangeParser {
+	interface Ranges extends Array<Range> {
+		type: string;
+	}
+	interface Range {
+		start: number;
+		end: number;
+	}
+	interface Options {
+		/**
+		 * The "combine" option can be set to `true` and overlapping & adjacent ranges
+		 * will be combined into a single range.
+		 */
+		combine?: boolean | undefined;
+	}
+	type ResultUnsatisfiable = -1;
+	type ResultInvalid = -2;
+	type Result = ResultUnsatisfiable | ResultInvalid;
+}
+interface NextFunction {
+	(err?: any): void;
+	/**
+	 * "Break-out" of a router by calling {next('router')};
+	 * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.router}
+	 */
+	(deferToNext: "router"): void;
+	/**
+	 * "Break-out" of a route by calling {next('route')};
+	 * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.application}
+	 */
+	(deferToNext: "route"): void;
+}
+interface ParamsDictionary {
+	[key: string]: string;
+}
+interface Locals extends Express.Locals {
+}
+interface RequestHandler<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> {
+	// tslint:disable-next-line callable-types (This is extended from and can't extend from a type alias in ts<2.2)
+	(req: Request$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response$1<ResBody, LocalsObj>, next: NextFunction): unknown;
+}
+type ErrorRequestHandler<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> = (err: any, req: Request$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response$1<ResBody, LocalsObj>, next: NextFunction) => unknown;
+type PathParams = string | RegExp | Array<string | RegExp>;
+type RequestHandlerParams<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> = RequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj> | ErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj> | Array<RequestHandler<P> | ErrorRequestHandler<P>>;
+type RemoveTail<S extends string, Tail extends string> = S extends `${infer P}${Tail}` ? P : S;
+type GetRouteParameter<S extends string> = RemoveTail<RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>, `.${string}`>;
+type RouteParameters<Route extends string> = Route extends `${infer Required}{${infer Optional}}${infer Next}` ? ParseRouteParameters<Required> & Partial<ParseRouteParameters<Optional>> & RouteParameters<Next> : ParseRouteParameters<Route>;
+type ParseRouteParameters<Route extends string> = string extends Route ? ParamsDictionary : Route extends `${string}(${string}` ? ParamsDictionary // TODO: handling for regex parameters
+ : Route extends `${string}:${infer Rest}` ? (GetRouteParameter<Rest> extends never ? ParamsDictionary : GetRouteParameter<Rest> extends `${infer ParamName}?` ? {
+	[P in ParamName]?: string;
+} // TODO: Remove old `?` handling when Express 5 is promoted to "latest"
+ : {
+	[P in GetRouteParameter<Rest>]: string;
+}) & (Rest extends `${GetRouteParameter<Rest>}${infer Next}` ? RouteParameters<Next> : unknown) : {};
+interface IRouterMatcher<T, Method extends "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head" = any> {
+	<Route extends string, P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+	// (it's used as the default type parameter for P)
+	path: Route, 
+	// (This generic is meant to be passed explicitly.)
+	...handlers: Array<RequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+	<Path extends string, P = RouteParameters<Path>, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+	// (it's used as the default type parameter for P)
+	path: Path, 
+	// (This generic is meant to be passed explicitly.)
+	...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+	<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(path: PathParams, 
+	// (This generic is meant to be passed explicitly.)
+	...handlers: Array<RequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+	<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(path: PathParams, 
+	// (This generic is meant to be passed explicitly.)
+	...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+	(path: PathParams, subApplication: Application): T;
+}
+interface IRouterHandler<T, Route extends string = string> {
+	(...handlers: Array<RequestHandler<RouteParameters<Route>>>): T;
+	(...handlers: Array<RequestHandlerParams<RouteParameters<Route>>>): T;
+	<P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+	// (This generic is meant to be passed explicitly.)
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+	...handlers: Array<RequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+	<P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+	// (This generic is meant to be passed explicitly.)
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+	...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+	<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+	// (This generic is meant to be passed explicitly.)
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+	...handlers: Array<RequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+	<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+	// (This generic is meant to be passed explicitly.)
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+	...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+}
+interface IRouter extends RequestHandler {
+	/**
+	 * Map the given param placeholder `name`(s) to the given callback(s).
+	 *
+	 * Parameter mapping is used to provide pre-conditions to routes
+	 * which use normalized placeholders. For example a _:user_id_ parameter
+	 * could automatically load a user's information from the database without
+	 * any additional code,
+	 *
+	 * The callback uses the samesignature as middleware, the only differencing
+	 * being that the value of the placeholder is passed, in this case the _id_
+	 * of the user. Once the `next()` function is invoked, just like middleware
+	 * it will continue on to execute the route, or subsequent parameter functions.
+	 *
+	 *      app.param('user_id', function(req, res, next, id){
+	 *        User.find(id, function(err, user){
+	 *          if (err) {
+	 *            next(err);
+	 *          } else if (user) {
+	 *            req.user = user;
+	 *            next();
+	 *          } else {
+	 *            next(new Error('failed to load user'));
+	 *          }
+	 *        });
+	 *      });
+	 */
+	param(name: string, handler: RequestParamHandler): this;
+	/**
+	 * Special-cased "all" method, applying the given route `path`,
+	 * middleware, and callback to _every_ HTTP method.
+	 */
+	all: IRouterMatcher<this, "all">;
+	get: IRouterMatcher<this, "get">;
+	post: IRouterMatcher<this, "post">;
+	put: IRouterMatcher<this, "put">;
+	delete: IRouterMatcher<this, "delete">;
+	patch: IRouterMatcher<this, "patch">;
+	options: IRouterMatcher<this, "options">;
+	head: IRouterMatcher<this, "head">;
+	checkout: IRouterMatcher<this>;
+	connect: IRouterMatcher<this>;
+	copy: IRouterMatcher<this>;
+	lock: IRouterMatcher<this>;
+	merge: IRouterMatcher<this>;
+	mkactivity: IRouterMatcher<this>;
+	mkcol: IRouterMatcher<this>;
+	move: IRouterMatcher<this>;
+	"m-search": IRouterMatcher<this>;
+	notify: IRouterMatcher<this>;
+	propfind: IRouterMatcher<this>;
+	proppatch: IRouterMatcher<this>;
+	purge: IRouterMatcher<this>;
+	report: IRouterMatcher<this>;
+	search: IRouterMatcher<this>;
+	subscribe: IRouterMatcher<this>;
+	trace: IRouterMatcher<this>;
+	unlock: IRouterMatcher<this>;
+	unsubscribe: IRouterMatcher<this>;
+	link: IRouterMatcher<this>;
+	unlink: IRouterMatcher<this>;
+	use: IRouterHandler<this> & IRouterMatcher<this>;
+	route<T extends string>(prefix: T): IRoute<T>;
+	route(prefix: PathParams): IRoute;
+	/**
+	 * Stack of configured routes
+	 */
+	stack: ILayer[];
+}
+interface ILayer {
+	route?: IRoute;
+	name: string | "<anonymous>";
+	params?: Record<string, any>;
+	keys: string[];
+	path?: string;
+	method: string;
+	regexp: RegExp;
+	handle: (req: Request$1, res: Response$1, next: NextFunction) => any;
+}
+interface IRoute<Route extends string = string> {
+	path: string;
+	stack: ILayer[];
+	all: IRouterHandler<this, Route>;
+	get: IRouterHandler<this, Route>;
+	post: IRouterHandler<this, Route>;
+	put: IRouterHandler<this, Route>;
+	delete: IRouterHandler<this, Route>;
+	patch: IRouterHandler<this, Route>;
+	options: IRouterHandler<this, Route>;
+	head: IRouterHandler<this, Route>;
+	checkout: IRouterHandler<this, Route>;
+	copy: IRouterHandler<this, Route>;
+	lock: IRouterHandler<this, Route>;
+	merge: IRouterHandler<this, Route>;
+	mkactivity: IRouterHandler<this, Route>;
+	mkcol: IRouterHandler<this, Route>;
+	move: IRouterHandler<this, Route>;
+	"m-search": IRouterHandler<this, Route>;
+	notify: IRouterHandler<this, Route>;
+	purge: IRouterHandler<this, Route>;
+	report: IRouterHandler<this, Route>;
+	search: IRouterHandler<this, Route>;
+	subscribe: IRouterHandler<this, Route>;
+	trace: IRouterHandler<this, Route>;
+	unlock: IRouterHandler<this, Route>;
+	unsubscribe: IRouterHandler<this, Route>;
+}
+interface Router$1 extends IRouter {
+}
+interface CookieOptions {
+	/** Convenient option for setting the expiry time relative to the current time in **milliseconds**. */
+	maxAge?: number | undefined;
+	/** Indicates if the cookie should be signed. */
+	signed?: boolean | undefined;
+	/** Expiry date of the cookie in GMT. If not specified (undefined), creates a session cookie. */
+	expires?: Date | undefined;
+	/** Flags the cookie to be accessible only by the web server. */
+	httpOnly?: boolean | undefined;
+	/** Path for the cookie. Defaults to “/”. */
+	path?: string | undefined;
+	/** Domain name for the cookie. Defaults to the domain name of the app. */
+	domain?: string | undefined;
+	/** Marks the cookie to be used with HTTPS only. */
+	secure?: boolean | undefined;
+	/** A synchronous function used for cookie value encoding. Defaults to encodeURIComponent. */
+	encode?: ((val: string) => string) | undefined;
+	/**
+	 * Value of the “SameSite” Set-Cookie attribute.
+	 * @link https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00#section-4.1.1.
+	 */
+	sameSite?: boolean | "lax" | "strict" | "none" | undefined;
+	/**
+	 * Value of the “Priority” Set-Cookie attribute.
+	 * @link https://datatracker.ietf.org/doc/html/draft-west-cookie-priority-00#section-4.3
+	 */
+	priority?: "low" | "medium" | "high";
+	/** Marks the cookie to use partioned storage. */
+	partitioned?: boolean | undefined;
+}
+type Errback = (err: Error) => void;
+interface Request$1<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = QueryString.ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> extends http.IncomingMessage, Express.Request {
+	/**
+	 * Return request header.
+	 *
+	 * The `Referrer` header field is special-cased,
+	 * both `Referrer` and `Referer` are interchangeable.
+	 *
+	 * Examples:
+	 *
+	 *     req.get('Content-Type');
+	 *     // => "text/plain"
+	 *
+	 *     req.get('content-type');
+	 *     // => "text/plain"
+	 *
+	 *     req.get('Something');
+	 *     // => undefined
+	 *
+	 * Aliased as `req.header()`.
+	 */
+	get(name: "set-cookie"): string[] | undefined;
+	get(name: string): string | undefined;
+	header(name: "set-cookie"): string[] | undefined;
+	header(name: string): string | undefined;
+	/**
+	 * Check if the given `type(s)` is acceptable, returning
+	 * the best match when true, otherwise `undefined`, in which
+	 * case you should respond with 406 "Not Acceptable".
+	 *
+	 * The `type` value may be a single mime type string
+	 * such as "application/json", the extension name
+	 * such as "json", a comma-delimted list such as "json, html, text/plain",
+	 * or an array `["json", "html", "text/plain"]`. When a list
+	 * or array is given the _best_ match, if any is returned.
+	 *
+	 * Examples:
+	 *
+	 *     // Accept: text/html
+	 *     req.accepts('html');
+	 *     // => "html"
+	 *
+	 *     // Accept: text/*, application/json
+	 *     req.accepts('html');
+	 *     // => "html"
+	 *     req.accepts('text/html');
+	 *     // => "text/html"
+	 *     req.accepts('json, text');
+	 *     // => "json"
+	 *     req.accepts('application/json');
+	 *     // => "application/json"
+	 *
+	 *     // Accept: text/*, application/json
+	 *     req.accepts('image/png');
+	 *     req.accepts('png');
+	 *     // => false
+	 *
+	 *     // Accept: text/*;q=.5, application/json
+	 *     req.accepts(['html', 'json']);
+	 *     req.accepts('html, json');
+	 *     // => "json"
+	 */
+	accepts(): string[];
+	accepts(type: string): string | false;
+	accepts(type: string[]): string | false;
+	accepts(...type: string[]): string | false;
+	/**
+	 * Returns the first accepted charset of the specified character sets,
+	 * based on the request's Accept-Charset HTTP header field.
+	 * If none of the specified charsets is accepted, returns false.
+	 *
+	 * For more information, or if you have issues or concerns, see accepts.
+	 */
+	acceptsCharsets(): string[];
+	acceptsCharsets(charset: string): string | false;
+	acceptsCharsets(charset: string[]): string | false;
+	acceptsCharsets(...charset: string[]): string | false;
+	/**
+	 * Returns the first accepted encoding of the specified encodings,
+	 * based on the request's Accept-Encoding HTTP header field.
+	 * If none of the specified encodings is accepted, returns false.
+	 *
+	 * For more information, or if you have issues or concerns, see accepts.
+	 */
+	acceptsEncodings(): string[];
+	acceptsEncodings(encoding: string): string | false;
+	acceptsEncodings(encoding: string[]): string | false;
+	acceptsEncodings(...encoding: string[]): string | false;
+	/**
+	 * Returns the first accepted language of the specified languages,
+	 * based on the request's Accept-Language HTTP header field.
+	 * If none of the specified languages is accepted, returns false.
+	 *
+	 * For more information, or if you have issues or concerns, see accepts.
+	 */
+	acceptsLanguages(): string[];
+	acceptsLanguages(lang: string): string | false;
+	acceptsLanguages(lang: string[]): string | false;
+	acceptsLanguages(...lang: string[]): string | false;
+	/**
+	 * Parse Range header field, capping to the given `size`.
+	 *
+	 * Unspecified ranges such as "0-" require knowledge of your resource length. In
+	 * the case of a byte range this is of course the total number of bytes.
+	 * If the Range header field is not given `undefined` is returned.
+	 * If the Range header field is given, return value is a result of range-parser.
+	 * See more ./types/range-parser/index.d.ts
+	 *
+	 * NOTE: remember that ranges are inclusive, so for example "Range: users=0-3"
+	 * should respond with 4 users when available, not 3.
+	 */
+	range(size: number, options?: RangeParser.RangeParserOptions): RangeParser.RangeParserRanges | RangeParser.RangeParserResult | undefined;
+	/**
+	 * Return an array of Accepted media types
+	 * ordered from highest quality to lowest.
+	 */
+	accepted: MediaType[];
+	/**
+	 * Check if the incoming request contains the "Content-Type"
+	 * header field, and it contains the give mime `type`.
+	 *
+	 * Examples:
+	 *
+	 *      // With Content-Type: text/html; charset=utf-8
+	 *      req.is('html');
+	 *      req.is('text/html');
+	 *      req.is('text/*');
+	 *      // => true
+	 *
+	 *      // When Content-Type is application/json
+	 *      req.is('json');
+	 *      req.is('application/json');
+	 *      req.is('application/*');
+	 *      // => true
+	 *
+	 *      req.is('html');
+	 *      // => false
+	 */
+	is(type: string | string[]): string | false | null;
+	/**
+	 * Return the protocol string "http" or "https"
+	 * when requested with TLS. When the "trust proxy"
+	 * setting is enabled the "X-Forwarded-Proto" header
+	 * field will be trusted. If you're running behind
+	 * a reverse proxy that supplies https for you this
+	 * may be enabled.
+	 */
+	readonly protocol: string;
+	/**
+	 * Short-hand for:
+	 *
+	 *    req.protocol == 'https'
+	 */
+	readonly secure: boolean;
+	/**
+	 * Return the remote address, or when
+	 * "trust proxy" is `true` return
+	 * the upstream addr.
+	 *
+	 * Value may be undefined if the `req.socket` is destroyed
+	 * (for example, if the client disconnected).
+	 */
+	readonly ip: string | undefined;
+	/**
+	 * When "trust proxy" is `true`, parse
+	 * the "X-Forwarded-For" ip address list.
+	 *
+	 * For example if the value were "client, proxy1, proxy2"
+	 * you would receive the array `["client", "proxy1", "proxy2"]`
+	 * where "proxy2" is the furthest down-stream.
+	 */
+	readonly ips: string[];
+	/**
+	 * Return subdomains as an array.
+	 *
+	 * Subdomains are the dot-separated parts of the host before the main domain of
+	 * the app. By default, the domain of the app is assumed to be the last two
+	 * parts of the host. This can be changed by setting "subdomain offset".
+	 *
+	 * For example, if the domain is "tobi.ferrets.example.com":
+	 * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
+	 * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
+	 */
+	readonly subdomains: string[];
+	/**
+	 * Short-hand for `url.parse(req.url).pathname`.
+	 */
+	readonly path: string;
+	/**
+	 * Contains the hostname derived from the `Host` HTTP header.
+	 */
+	readonly hostname: string;
+	/**
+	 * Contains the host derived from the `Host` HTTP header.
+	 */
+	readonly host: string;
+	/**
+	 * Check if the request is fresh, aka
+	 * Last-Modified and/or the ETag
+	 * still match.
+	 */
+	readonly fresh: boolean;
+	/**
+	 * Check if the request is stale, aka
+	 * "Last-Modified" and / or the "ETag" for the
+	 * resource has changed.
+	 */
+	readonly stale: boolean;
+	/**
+	 * Check if the request was an _XMLHttpRequest_.
+	 */
+	readonly xhr: boolean;
+	// body: { username: string; password: string; remember: boolean; title: string; };
+	body: ReqBody;
+	// cookies: { string; remember: boolean; };
+	cookies: any;
+	method: string;
+	params: P;
+	query: ReqQuery;
+	route: any;
+	signedCookies: any;
+	originalUrl: string;
+	url: string;
+	baseUrl: string;
+	app: Application;
+	/**
+	 * After middleware.init executed, Request will contain res and next properties
+	 * See: express/lib/middleware/init.js
+	 */
+	res?: Response$1<ResBody, LocalsObj> | undefined;
+	next?: NextFunction | undefined;
+}
+interface MediaType {
+	value: string;
+	quality: number;
+	type: string;
+	subtype: string;
+}
+type Send<ResBody = any, T = Response$1<ResBody>> = (body?: ResBody) => T;
+interface SendFileOptions extends SendOptions {
+	/** Object containing HTTP headers to serve with the file. */
+	headers?: Record<string, unknown>;
+}
+interface DownloadOptions extends SendOptions {
+	/** Object containing HTTP headers to serve with the file. The header `Content-Disposition` will be overridden by the filename argument. */
+	headers?: Record<string, unknown>;
+}
+interface Response$1<ResBody = any, LocalsObj extends Record<string, any> = Record<string, any>, StatusCode extends number = number> extends http.ServerResponse, Express.Response {
+	/**
+	 * Set status `code`.
+	 */
+	status(code: StatusCode): this;
+	/**
+	 * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
+	 * @link http://expressjs.com/4x/api.html#res.sendStatus
+	 *
+	 * Examples:
+	 *
+	 *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
+	 *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
+	 *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
+	 *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
+	 */
+	sendStatus(code: StatusCode): this;
+	/**
+	 * Set Link header field with the given `links`.
+	 *
+	 * Examples:
+	 *
+	 *    res.links({
+	 *      next: 'http://api.example.com/users?page=2',
+	 *      last: 'http://api.example.com/users?page=5'
+	 *    });
+	 */
+	links(links: any): this;
+	/**
+	 * Send a response.
+	 *
+	 * Examples:
+	 *
+	 *     res.send(new Buffer('wahoo'));
+	 *     res.send({ some: 'json' });
+	 *     res.send('<p>some html</p>');
+	 *     res.status(404).send('Sorry, cant find that');
+	 */
+	send: Send<ResBody, this>;
+	/**
+	 * Send JSON response.
+	 *
+	 * Examples:
+	 *
+	 *     res.json(null);
+	 *     res.json({ user: 'tj' });
+	 *     res.status(500).json('oh noes!');
+	 *     res.status(404).json('I dont have that');
+	 */
+	json: Send<ResBody, this>;
+	/**
+	 * Send JSON response with JSONP callback support.
+	 *
+	 * Examples:
+	 *
+	 *     res.jsonp(null);
+	 *     res.jsonp({ user: 'tj' });
+	 *     res.status(500).jsonp('oh noes!');
+	 *     res.status(404).jsonp('I dont have that');
+	 */
+	jsonp: Send<ResBody, this>;
+	/**
+	 * Transfer the file at the given `path`.
+	 *
+	 * Automatically sets the _Content-Type_ response header field.
+	 * The callback `fn(err)` is invoked when the transfer is complete
+	 * or when an error occurs. Be sure to check `res.headersSent`
+	 * if you wish to attempt responding, as the header and some data
+	 * may have already been transferred.
+	 *
+	 * Options:
+	 *
+	 *   - `maxAge`   defaulting to 0 (can be string converted by `ms`)
+	 *   - `root`     root directory for relative filenames
+	 *   - `headers`  object of headers to serve with file
+	 *   - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them
+	 *
+	 * Other options are passed along to `send`.
+	 *
+	 * Examples:
+	 *
+	 *  The following example illustrates how `res.sendFile()` may
+	 *  be used as an alternative for the `static()` middleware for
+	 *  dynamic situations. The code backing `res.sendFile()` is actually
+	 *  the same code, so HTTP cache support etc is identical.
+	 *
+	 *     app.get('/user/:uid/photos/:file', function(req, res){
+	 *       var uid = req.params.uid
+	 *         , file = req.params.file;
+	 *
+	 *       req.user.mayViewFilesFrom(uid, function(yes){
+	 *         if (yes) {
+	 *           res.sendFile('/uploads/' + uid + '/' + file);
+	 *         } else {
+	 *           res.send(403, 'Sorry! you cant see that.');
+	 *         }
+	 *       });
+	 *     });
+	 *
+	 * @api public
+	 */
+	sendFile(path: string, fn?: Errback): void;
+	sendFile(path: string, options: SendFileOptions, fn?: Errback): void;
+	/**
+	 * Transfer the file at the given `path` as an attachment.
+	 *
+	 * Optionally providing an alternate attachment `filename`,
+	 * and optional callback `fn(err)`. The callback is invoked
+	 * when the data transfer is complete, or when an error has
+	 * ocurred. Be sure to check `res.headersSent` if you plan to respond.
+	 *
+	 * The optional options argument passes through to the underlying
+	 * res.sendFile() call, and takes the exact same parameters.
+	 *
+	 * This method uses `res.sendFile()`.
+	 */
+	download(path: string, fn?: Errback): void;
+	download(path: string, filename: string, fn?: Errback): void;
+	download(path: string, filename: string, options: DownloadOptions, fn?: Errback): void;
+	/**
+	 * Set _Content-Type_ response header with `type` through `mime.lookup()`
+	 * when it does not contain "/", or set the Content-Type to `type` otherwise.
+	 *
+	 * Examples:
+	 *
+	 *     res.type('.html');
+	 *     res.type('html');
+	 *     res.type('json');
+	 *     res.type('application/json');
+	 *     res.type('png');
+	 */
+	contentType(type: string): this;
+	/**
+	 * Set _Content-Type_ response header with `type` through `mime.lookup()`
+	 * when it does not contain "/", or set the Content-Type to `type` otherwise.
+	 *
+	 * Examples:
+	 *
+	 *     res.type('.html');
+	 *     res.type('html');
+	 *     res.type('json');
+	 *     res.type('application/json');
+	 *     res.type('png');
+	 */
+	type(type: string): this;
+	/**
+	 * Respond to the Acceptable formats using an `obj`
+	 * of mime-type callbacks.
+	 *
+	 * This method uses `req.accepted`, an array of
+	 * acceptable types ordered by their quality values.
+	 * When "Accept" is not present the _first_ callback
+	 * is invoked, otherwise the first match is used. When
+	 * no match is performed the server responds with
+	 * 406 "Not Acceptable".
+	 *
+	 * Content-Type is set for you, however if you choose
+	 * you may alter this within the callback using `res.type()`
+	 * or `res.set('Content-Type', ...)`.
+	 *
+	 *    res.format({
+	 *      'text/plain': function(){
+	 *        res.send('hey');
+	 *      },
+	 *
+	 *      'text/html': function(){
+	 *        res.send('<p>hey</p>');
+	 *      },
+	 *
+	 *      'appliation/json': function(){
+	 *        res.send({ message: 'hey' });
+	 *      }
+	 *    });
+	 *
+	 * In addition to canonicalized MIME types you may
+	 * also use extnames mapped to these types:
+	 *
+	 *    res.format({
+	 *      text: function(){
+	 *        res.send('hey');
+	 *      },
+	 *
+	 *      html: function(){
+	 *        res.send('<p>hey</p>');
+	 *      },
+	 *
+	 *      json: function(){
+	 *        res.send({ message: 'hey' });
+	 *      }
+	 *    });
+	 *
+	 * By default Express passes an `Error`
+	 * with a `.status` of 406 to `next(err)`
+	 * if a match is not made. If you provide
+	 * a `.default` callback it will be invoked
+	 * instead.
+	 */
+	format(obj: any): this;
+	/**
+	 * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+	 */
+	attachment(filename?: string): this;
+	/**
+	 * Set header `field` to `val`, or pass
+	 * an object of header fields.
+	 *
+	 * Examples:
+	 *
+	 *    res.set('Foo', ['bar', 'baz']);
+	 *    res.set('Accept', 'application/json');
+	 *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+	 *
+	 * Aliased as `res.header()`.
+	 */
+	set(field: any): this;
+	set(field: string, value?: string | string[]): this;
+	header(field: any): this;
+	header(field: string, value?: string | string[]): this;
+	// Property indicating if HTTP headers has been sent for the response.
+	headersSent: boolean;
+	/** Get value for header `field`. */
+	get(field: string): string | undefined;
+	/** Clear cookie `name`. */
+	clearCookie(name: string, options?: CookieOptions): this;
+	/**
+	 * Set cookie `name` to `val`, with the given `options`.
+	 *
+	 * Options:
+	 *
+	 *    - `maxAge`   max-age in milliseconds, converted to `expires`
+	 *    - `signed`   sign the cookie
+	 *    - `path`     defaults to "/"
+	 *
+	 * Examples:
+	 *
+	 *    // "Remember Me" for 15 minutes
+	 *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+	 *
+	 *    // save as above
+	 *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+	 */
+	cookie(name: string, val: string, options: CookieOptions): this;
+	cookie(name: string, val: any, options: CookieOptions): this;
+	cookie(name: string, val: any): this;
+	/**
+	 * Set the location header to `url`.
+	 *
+	 * Examples:
+	 *
+	 *    res.location('/foo/bar').;
+	 *    res.location('http://example.com');
+	 *    res.location('../login'); // /blog/post/1 -> /blog/login
+	 *
+	 * Mounting:
+	 *
+	 *   When an application is mounted and `res.location()`
+	 *   is given a path that does _not_ lead with "/" it becomes
+	 *   relative to the mount-point. For example if the application
+	 *   is mounted at "/blog", the following would become "/blog/login".
+	 *
+	 *      res.location('login');
+	 *
+	 *   While the leading slash would result in a location of "/login":
+	 *
+	 *      res.location('/login');
+	 */
+	location(url: string): this;
+	/**
+	 * Redirect to the given `url` with optional response `status`
+	 * defaulting to 302.
+	 *
+	 * The resulting `url` is determined by `res.location()`, so
+	 * it will play nicely with mounted apps, relative paths, etc.
+	 *
+	 * Examples:
+	 *
+	 *    res.redirect('/foo/bar');
+	 *    res.redirect('http://example.com');
+	 *    res.redirect(301, 'http://example.com');
+	 *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+	 */
+	redirect(url: string): void;
+	redirect(status: number, url: string): void;
+	/**
+	 * Render `view` with the given `options` and optional callback `fn`.
+	 * When a callback function is given a response will _not_ be made
+	 * automatically, otherwise a response of _200_ and _text/html_ is given.
+	 *
+	 * Options:
+	 *
+	 *  - `cache`     boolean hinting to the engine it should cache
+	 *  - `filename`  filename of the view being rendered
+	 */
+	render(view: string, options?: object, callback?: (err: Error, html: string) => void): void;
+	render(view: string, callback?: (err: Error, html: string) => void): void;
+	locals: LocalsObj & Locals;
+	charset: string;
+	/**
+	 * Adds the field to the Vary response header, if it is not there already.
+	 * Examples:
+	 *
+	 *     res.vary('User-Agent').render('docs');
+	 */
+	vary(field: string): this;
+	app: Application;
+	/**
+	 * Appends the specified value to the HTTP response header field.
+	 * If the header is not already set, it creates the header with the specified value.
+	 * The value parameter can be a string or an array.
+	 *
+	 * Note: calling res.set() after res.append() will reset the previously-set header value.
+	 *
+	 * @since 4.11.0
+	 */
+	append(field: string, value?: string[] | string): this;
+	/**
+	 * After middleware.init executed, Response will contain req property
+	 * See: express/lib/middleware/init.js
+	 */
+	req: Request$1;
+}
+type RequestParamHandler = (req: Request$1, res: Response$1, next: NextFunction, value: any, name: string) => any;
+type ApplicationRequestHandler<T> = IRouterHandler<T> & IRouterMatcher<T> & ((...handlers: RequestHandlerParams[]) => T);
+interface Application<LocalsObj extends Record<string, any> = Record<string, any>> extends EventEmitter, IRouter, Express.Application {
+	/**
+	 * Express instance itself is a request handler, which could be invoked without
+	 * third argument.
+	 */
+	(req: Request$1 | http.IncomingMessage, res: Response$1 | http.ServerResponse): any;
+	/**
+	 * Initialize the server.
+	 *
+	 *   - setup default configuration
+	 *   - setup default middleware
+	 *   - setup route reflection methods
+	 */
+	init(): void;
+	/**
+	 * Initialize application configuration.
+	 */
+	defaultConfiguration(): void;
+	/**
+	 * Register the given template engine callback `fn`
+	 * as `ext`.
+	 *
+	 * By default will `require()` the engine based on the
+	 * file extension. For example if you try to render
+	 * a "foo.jade" file Express will invoke the following internally:
+	 *
+	 *     app.engine('jade', require('jade').__express);
+	 *
+	 * For engines that do not provide `.__express` out of the box,
+	 * or if you wish to "map" a different extension to the template engine
+	 * you may use this method. For example mapping the EJS template engine to
+	 * ".html" files:
+	 *
+	 *     app.engine('html', require('ejs').renderFile);
+	 *
+	 * In this case EJS provides a `.renderFile()` method with
+	 * the same signature that Express expects: `(path, options, callback)`,
+	 * though note that it aliases this method as `ejs.__express` internally
+	 * so if you're using ".ejs" extensions you dont need to do anything.
+	 *
+	 * Some template engines do not follow this convention, the
+	 * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
+	 * library was created to map all of node's popular template
+	 * engines to follow this convention, thus allowing them to
+	 * work seamlessly within Express.
+	 */
+	engine(ext: string, fn: (path: string, options: object, callback: (e: any, rendered?: string) => void) => void): this;
+	/**
+	 * Assign `setting` to `val`, or return `setting`'s value.
+	 *
+	 *    app.set('foo', 'bar');
+	 *    app.get('foo');
+	 *    // => "bar"
+	 *    app.set('foo', ['bar', 'baz']);
+	 *    app.get('foo');
+	 *    // => ["bar", "baz"]
+	 *
+	 * Mounted servers inherit their parent server's settings.
+	 */
+	set(setting: string, val: any): this;
+	get: ((name: string) => any) & IRouterMatcher<this>;
+	param(name: string | string[], handler: RequestParamHandler): this;
+	/**
+	 * Return the app's absolute pathname
+	 * based on the parent(s) that have
+	 * mounted it.
+	 *
+	 * For example if the application was
+	 * mounted as "/admin", which itself
+	 * was mounted as "/blog" then the
+	 * return value would be "/blog/admin".
+	 */
+	path(): string;
+	/**
+	 * Check if `setting` is enabled (truthy).
+	 *
+	 *    app.enabled('foo')
+	 *    // => false
+	 *
+	 *    app.enable('foo')
+	 *    app.enabled('foo')
+	 *    // => true
+	 */
+	enabled(setting: string): boolean;
+	/**
+	 * Check if `setting` is disabled.
+	 *
+	 *    app.disabled('foo')
+	 *    // => true
+	 *
+	 *    app.enable('foo')
+	 *    app.disabled('foo')
+	 *    // => false
+	 */
+	disabled(setting: string): boolean;
+	/** Enable `setting`. */
+	enable(setting: string): this;
+	/** Disable `setting`. */
+	disable(setting: string): this;
+	/**
+	 * Render the given view `name` name with `options`
+	 * and a callback accepting an error and the
+	 * rendered template string.
+	 *
+	 * Example:
+	 *
+	 *    app.render('email', { name: 'Tobi' }, function(err, html){
+	 *      // ...
+	 *    })
+	 */
+	render(name: string, options?: object, callback?: (err: Error, html: string) => void): void;
+	render(name: string, callback: (err: Error, html: string) => void): void;
+	/**
+	 * Listen for connections.
+	 *
+	 * A node `http.Server` is returned, with this
+	 * application (which is a `Function`) as its
+	 * callback. If you wish to create both an HTTP
+	 * and HTTPS server you may do so with the "http"
+	 * and "https" modules as shown here:
+	 *
+	 *    var http = require('http')
+	 *      , https = require('https')
+	 *      , express = require('express')
+	 *      , app = express();
+	 *
+	 *    http.createServer(app).listen(80);
+	 *    https.createServer({ ... }, app).listen(443);
+	 */
+	listen(port: number, hostname: string, backlog: number, callback?: (error?: Error) => void): http.Server;
+	listen(port: number, hostname: string, callback?: (error?: Error) => void): http.Server;
+	listen(port: number, callback?: (error?: Error) => void): http.Server;
+	listen(callback?: (error?: Error) => void): http.Server;
+	listen(path: string, callback?: (error?: Error) => void): http.Server;
+	listen(handle: any, listeningListener?: (error?: Error) => void): http.Server;
+	router: Router$1;
+	settings: any;
+	resource: any;
+	map: any;
+	locals: LocalsObj & Locals;
+	/**
+	 * The app.routes object houses all of the routes defined mapped by the
+	 * associated HTTP verb. This object may be used for introspection
+	 * capabilities, for example Express uses this internally not only for
+	 * routing but to provide default OPTIONS behaviour unless app.options()
+	 * is used. Your application or framework may also remove routes by
+	 * simply by removing them from this object.
+	 */
+	routes: any;
+	/**
+	 * Used to get all registered routes in Express Application
+	 */
+	_router: any;
+	use: ApplicationRequestHandler<this>;
+	/**
+	 * The mount event is fired on a sub-app, when it is mounted on a parent app.
+	 * The parent app is passed to the callback function.
+	 *
+	 * NOTE:
+	 * Sub-apps will:
+	 *  - Not inherit the value of settings that have a default value. You must set the value in the sub-app.
+	 *  - Inherit the value of settings with no default value.
+	 */
+	on: (event: "mount", callback: (parent: Application) => void) => this;
+	/**
+	 * The app.mountpath property contains one or more path patterns on which a sub-app was mounted.
+	 */
+	mountpath: string | string[];
+}
 declare const ROLES: readonly [
 	":admin",
 	"view:users",
@@ -43,7 +1802,7 @@ declare const ROLES: readonly [
 	"manage:customers",
 	"delete:customers"
 ];
-export type Role = (typeof ROLES)[number];
+type Role = (typeof ROLES)[number];
 declare namespace auth {
 	const JWT_ALG: "HS512";
 	class AuthResult {
@@ -253,50 +2012,50 @@ declare namespace error {
 		function statusCodeText(statusCode: StatusCode): string;
 	}
 }
-export type TrpcContext = {
+type TrpcContext = {
 	req: Request$1;
 	res: Response$1;
 	authResult?: auth.AuthResult;
 	adminFor?: "+all" | string;
 };
-declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
+declare const appRouter: BuiltRouter<{
 	ctx: TrpcContext;
 	meta: object;
-	errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+	errorShape: DefaultErrorShape | {
 		message: string;
 		data: {
 			httpCode: error.http.StatusCodeCode;
-			code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+			code: TRPC_ERROR_CODE_KEY;
 			httpStatus: number;
 			path?: string;
 			stack?: string;
 		};
-		code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+		code: TRPC_ERROR_CODE_NUMBER;
 	};
 	transformer: true;
-}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-	ping: import("@trpc/server").TRPCQueryProcedure<{
+}, DecorateCreateRouterOptions<{
+	ping: QueryProcedure<{
 		input: void;
 		output: string;
 		meta: object;
 	}>;
-	auth: import("@trpc/server").TRPCBuiltRouter<{
+	auth: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		login: import("@trpc/server").TRPCMutationProcedure<{
+	}, DecorateCreateRouterOptions<{
+		login: MutationProcedure<{
 			input: {
 				tenant: string;
 				username: string;
@@ -307,21 +2066,21 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		logout: import("@trpc/server").TRPCMutationProcedure<{
+		logout: MutationProcedure<{
 			input: void;
 			output: {
 				success: true;
 			};
 			meta: object;
 		}>;
-		check: import("@trpc/server").TRPCQueryProcedure<{
+		check: QueryProcedure<{
 			input: void;
 			output: {
 				success: true;
 			};
 			meta: object;
 		}>;
-		sessionInfo: import("@trpc/server").TRPCQueryProcedure<{
+		sessionInfo: QueryProcedure<{
 			input: void;
 			output: {
 				user: {
@@ -345,7 +2104,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		setPassword: import("@trpc/server").TRPCMutationProcedure<{
+		setPassword: MutationProcedure<{
 			input: {
 				username: string;
 				password: string;
@@ -356,23 +2115,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			meta: object;
 		}>;
 	}>>;
-	admin: import("@trpc/server").TRPCBuiltRouter<{
+	admin: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		login: import("@trpc/server").TRPCMutationProcedure<{
+	}, DecorateCreateRouterOptions<{
+		login: MutationProcedure<{
 			input: {
 				password: string;
 				tenant?: string | null | undefined;
@@ -382,23 +2141,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		tenants: import("@trpc/server").TRPCBuiltRouter<{
+		tenants: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: void;
 				output: {
 					name: string;
@@ -434,7 +2193,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			create: import("@trpc/server").TRPCMutationProcedure<{
+			create: MutationProcedure<{
 				input: {
 					name: string;
 					contact_details: {
@@ -469,7 +2228,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			get: import("@trpc/server").TRPCQueryProcedure<{
+			get: QueryProcedure<{
 				input: {
 					name: string;
 				};
@@ -507,7 +2266,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			update: import("@trpc/server").TRPCMutationProcedure<{
+			update: MutationProcedure<{
 				input: {
 					name: string;
 					data: {
@@ -544,7 +2303,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			activate: import("@trpc/server").TRPCMutationProcedure<{
+			activate: MutationProcedure<{
 				input: {
 					name: string;
 				};
@@ -553,7 +2312,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			deactivate: import("@trpc/server").TRPCMutationProcedure<{
+			deactivate: MutationProcedure<{
 				input: {
 					name: string;
 				};
@@ -562,7 +2321,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			delete: import("@trpc/server").TRPCMutationProcedure<{
+			delete: MutationProcedure<{
 				input: {
 					name: string;
 				};
@@ -571,7 +2330,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			deleteForever: import("@trpc/server").TRPCMutationProcedure<{
+			deleteForever: MutationProcedure<{
 				input: {
 					name: string;
 				};
@@ -580,7 +2339,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			lock: import("@trpc/server").TRPCMutationProcedure<{
+			lock: MutationProcedure<{
 				input: {
 					name: string;
 				};
@@ -589,7 +2348,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			unlock: import("@trpc/server").TRPCMutationProcedure<{
+			unlock: MutationProcedure<{
 				input: {
 					name: string;
 				};
@@ -598,7 +2357,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			undelete: import("@trpc/server").TRPCMutationProcedure<{
+			undelete: MutationProcedure<{
 				input: {
 					name: string;
 				};
@@ -609,23 +2368,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}>;
 		}>>;
 	}>>;
-	customers: import("@trpc/server").TRPCBuiltRouter<{
+	customers: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		list: import("@trpc/server").TRPCQueryProcedure<{
+	}, DecorateCreateRouterOptions<{
+		list: QueryProcedure<{
 			input: {
 				search?: string | null | undefined;
 			};
@@ -644,7 +2403,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}[];
 			meta: object;
 		}>;
-		get: import("@trpc/server").TRPCQueryProcedure<{
+		get: QueryProcedure<{
 			input: {
 				id: string;
 			};
@@ -663,7 +2422,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		create: import("@trpc/server").TRPCMutationProcedure<{
+		create: MutationProcedure<{
 			input: {
 				name: string;
 				salutation?: string | null | undefined;
@@ -679,7 +2438,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		update: import("@trpc/server").TRPCMutationProcedure<{
+		update: MutationProcedure<{
 			input: {
 				id: string;
 				data: {
@@ -698,7 +2457,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		delete: import("@trpc/server").TRPCMutationProcedure<{
+		delete: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -707,23 +2466,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		contacts: import("@trpc/server").TRPCBuiltRouter<{
+		contacts: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					customerId: string;
 				};
@@ -744,7 +2503,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			add: import("@trpc/server").TRPCMutationProcedure<{
+			add: MutationProcedure<{
 				input: {
 					customerId: string;
 					contactId: string;
@@ -754,7 +2513,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			remove: import("@trpc/server").TRPCMutationProcedure<{
+			remove: MutationProcedure<{
 				input: {
 					customerId: string;
 					contactId: string;
@@ -766,23 +2525,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}>;
 		}>>;
 	}>>;
-	projects: import("@trpc/server").TRPCBuiltRouter<{
+	projects: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		list: import("@trpc/server").TRPCQueryProcedure<{
+	}, DecorateCreateRouterOptions<{
+		list: QueryProcedure<{
 			input: {
 				search?: string | null | undefined;
 				finished?: boolean | null | undefined;
@@ -803,7 +2562,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}[];
 			meta: object;
 		}>;
-		get: import("@trpc/server").TRPCQueryProcedure<{
+		get: QueryProcedure<{
 			input: {
 				id: string;
 			};
@@ -823,7 +2582,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		create: import("@trpc/server").TRPCMutationProcedure<{
+		create: MutationProcedure<{
 			input: {
 				title: string;
 				address?: {
@@ -839,7 +2598,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		update: import("@trpc/server").TRPCMutationProcedure<{
+		update: MutationProcedure<{
 			input: {
 				id: string;
 				data: {
@@ -858,7 +2617,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		finish: import("@trpc/server").TRPCMutationProcedure<{
+		finish: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -867,7 +2626,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		resume: import("@trpc/server").TRPCMutationProcedure<{
+		resume: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -876,7 +2635,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		delete: import("@trpc/server").TRPCMutationProcedure<{
+		delete: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -885,23 +2644,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		deployments: import("@trpc/server").TRPCBuiltRouter<{
+		deployments: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					projectId?: string | null | undefined;
 					userId?: string | null | undefined;
@@ -924,7 +2683,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			create: import("@trpc/server").TRPCMutationProcedure<{
+			create: MutationProcedure<{
 				input: {
 					projectId: string;
 					userId: string;
@@ -937,7 +2696,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			update: import("@trpc/server").TRPCMutationProcedure<{
+			update: MutationProcedure<{
 				input: {
 					id: string;
 					data: {
@@ -953,7 +2712,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			delete: import("@trpc/server").TRPCMutationProcedure<{
+			delete: MutationProcedure<{
 				input: {
 					id: string;
 				};
@@ -963,23 +2722,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				meta: object;
 			}>;
 		}>>;
-		contacts: import("@trpc/server").TRPCBuiltRouter<{
+		contacts: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					projectId: string;
 				};
@@ -1000,7 +2759,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			add: import("@trpc/server").TRPCMutationProcedure<{
+			add: MutationProcedure<{
 				input: {
 					projectId: string;
 					contactId: string;
@@ -1010,7 +2769,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			remove: import("@trpc/server").TRPCMutationProcedure<{
+			remove: MutationProcedure<{
 				input: {
 					projectId: string;
 					contactId: string;
@@ -1022,23 +2781,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}>;
 		}>>;
 	}>>;
-	contacts: import("@trpc/server").TRPCBuiltRouter<{
+	contacts: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		list: import("@trpc/server").TRPCQueryProcedure<{
+	}, DecorateCreateRouterOptions<{
+		list: QueryProcedure<{
 			input: {
 				search?: string | null | undefined;
 			};
@@ -1059,7 +2818,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}[];
 			meta: object;
 		}>;
-		get: import("@trpc/server").TRPCQueryProcedure<{
+		get: QueryProcedure<{
 			input: {
 				id: string;
 			};
@@ -1080,7 +2839,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		create: import("@trpc/server").TRPCMutationProcedure<{
+		create: MutationProcedure<{
 			input: {
 				firstName: string;
 				lastName?: string | null | undefined;
@@ -1098,7 +2857,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		update: import("@trpc/server").TRPCMutationProcedure<{
+		update: MutationProcedure<{
 			input: {
 				id: string;
 				data: {
@@ -1119,7 +2878,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		delete: import("@trpc/server").TRPCMutationProcedure<{
+		delete: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1129,23 +2888,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			meta: object;
 		}>;
 	}>>;
-	products: import("@trpc/server").TRPCBuiltRouter<{
+	products: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		list: import("@trpc/server").TRPCQueryProcedure<{
+	}, DecorateCreateRouterOptions<{
+		list: QueryProcedure<{
 			input: {
 				category?: string | null | undefined;
 				search?: string | null | undefined;
@@ -1162,7 +2921,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}[];
 			meta: object;
 		}>;
-		get: import("@trpc/server").TRPCQueryProcedure<{
+		get: QueryProcedure<{
 			input: {
 				id: string;
 			};
@@ -1178,7 +2937,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		create: import("@trpc/server").TRPCMutationProcedure<{
+		create: MutationProcedure<{
 			input: {
 				customId: number;
 				name: string;
@@ -1192,7 +2951,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		update: import("@trpc/server").TRPCMutationProcedure<{
+		update: MutationProcedure<{
 			input: {
 				id: string;
 				data: {
@@ -1209,7 +2968,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		delete: import("@trpc/server").TRPCMutationProcedure<{
+		delete: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1218,28 +2977,28 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		categories: import("@trpc/server").TRPCBuiltRouter<{
+		categories: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: void;
 				output: string[];
 				meta: object;
 			}>;
-			tag: import("@trpc/server").TRPCMutationProcedure<{
+			tag: MutationProcedure<{
 				input: {
 					id: string;
 					category: string;
@@ -1249,7 +3008,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			untag: import("@trpc/server").TRPCMutationProcedure<{
+			untag: MutationProcedure<{
 				input: {
 					id: string;
 					category: string;
@@ -1260,45 +3019,45 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				meta: object;
 			}>;
 		}>>;
-		units: import("@trpc/server").TRPCBuiltRouter<{
+		units: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: void;
 				output: string[];
 				meta: object;
 			}>;
 		}>>;
-		vendors: import("@trpc/server").TRPCBuiltRouter<{
+		vendors: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					search?: string | null | undefined;
 				};
@@ -1311,7 +3070,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			get: import("@trpc/server").TRPCQueryProcedure<{
+			get: QueryProcedure<{
 				input: {
 					id: string;
 				};
@@ -1324,7 +3083,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			create: import("@trpc/server").TRPCMutationProcedure<{
+			create: MutationProcedure<{
 				input: {
 					name: string;
 					description?: string | null | undefined;
@@ -1334,7 +3093,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			update: import("@trpc/server").TRPCMutationProcedure<{
+			update: MutationProcedure<{
 				input: {
 					id: string;
 					data: {
@@ -1347,7 +3106,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			delete: import("@trpc/server").TRPCMutationProcedure<{
+			delete: MutationProcedure<{
 				input: {
 					id: string;
 				};
@@ -1357,23 +3116,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				meta: object;
 			}>;
 		}>>;
-		priceRecords: import("@trpc/server").TRPCBuiltRouter<{
+		priceRecords: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					productId?: string | null | undefined;
 					vendorId?: string | null | undefined;
@@ -1390,7 +3149,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			create: import("@trpc/server").TRPCMutationProcedure<{
+			create: MutationProcedure<{
 				input: {
 					productId: string;
 					price: number;
@@ -1403,7 +3162,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			update: import("@trpc/server").TRPCMutationProcedure<{
+			update: MutationProcedure<{
 				input: {
 					id: string;
 					data: {
@@ -1419,7 +3178,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			delete: import("@trpc/server").TRPCMutationProcedure<{
+			delete: MutationProcedure<{
 				input: {
 					id: string;
 				};
@@ -1429,23 +3188,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				meta: object;
 			}>;
 		}>>;
-		deliveryNotes: import("@trpc/server").TRPCBuiltRouter<{
+		deliveryNotes: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					projectId?: string | null | undefined;
 					createdByUserId?: string | null | undefined;
@@ -1465,7 +3224,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			create: import("@trpc/server").TRPCMutationProcedure<{
+			create: MutationProcedure<{
 				input: {
 					projectId: string;
 					records: {
@@ -1480,7 +3239,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			get: import("@trpc/server").TRPCQueryProcedure<{
+			get: QueryProcedure<{
 				input: {
 					id: string;
 				};
@@ -1499,7 +3258,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			delete: import("@trpc/server").TRPCMutationProcedure<{
+			delete: MutationProcedure<{
 				input: {
 					id: string;
 				};
@@ -1509,29 +3268,29 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				meta: object;
 			}>;
 		}>>;
-		suggestNextCustomId: import("@trpc/server").TRPCQueryProcedure<{
+		suggestNextCustomId: QueryProcedure<{
 			input: void;
 			output: number;
 			meta: object;
 		}>;
 	}>>;
-	users: import("@trpc/server").TRPCBuiltRouter<{
+	users: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		list: import("@trpc/server").TRPCQueryProcedure<{
+	}, DecorateCreateRouterOptions<{
+		list: QueryProcedure<{
 			input: {
 				search?: string | null | undefined;
 				deactivated?: boolean | null | undefined;
@@ -1552,7 +3311,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}[];
 			meta: object;
 		}>;
-		get: import("@trpc/server").TRPCQueryProcedure<{
+		get: QueryProcedure<{
 			input: {
 				id: string;
 			};
@@ -1571,7 +3330,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		create: import("@trpc/server").TRPCMutationProcedure<{
+		create: MutationProcedure<{
 			input: {
 				username: string;
 				firstName: string;
@@ -1585,7 +3344,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		update: import("@trpc/server").TRPCMutationProcedure<{
+		update: MutationProcedure<{
 			input: {
 				id: string;
 				data: {
@@ -1602,7 +3361,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		delete: import("@trpc/server").TRPCMutationProcedure<{
+		delete: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1611,7 +3370,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		archive: import("@trpc/server").TRPCMutationProcedure<{
+		archive: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1620,7 +3379,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		unarchive: import("@trpc/server").TRPCMutationProcedure<{
+		unarchive: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1629,7 +3388,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		activate: import("@trpc/server").TRPCMutationProcedure<{
+		activate: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1638,7 +3397,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		deactivate: import("@trpc/server").TRPCMutationProcedure<{
+		deactivate: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1647,12 +3406,12 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		roles: import("@trpc/server").TRPCQueryProcedure<{
+		roles: QueryProcedure<{
 			input: void;
 			output: (":admin" | "view:users" | "manage:users" | "delete:users" | "view:projects" | "manage:projects" | "delete:projects" | "view:projectDeployments" | "manage:projectDeployments" | "delete:projectDeployments" | "view:tools" | "manage:tools" | "delete:tools" | "view:toolTrackings" | "manage:toolTrackings" | "delete:toolTrackings" | "view:toolInventories" | "manage:toolInventories" | "delete:toolInventories" | "view:products" | "manage:products" | "delete:products" | "view:deliveryNotes" | "manage:deliveryNotes" | "delete:deliveryNotes" | "view:productVendors" | "manage:productVendors" | "delete:productVendors" | "view:contacts" | "manage:contacts" | "delete:contacts" | "view:productPriceRecords" | "manage:productPriceRecords" | "delete:productPriceRecords" | "view:customers" | "manage:customers" | "delete:customers")[];
 			meta: object;
 		}>;
-		setRoles: import("@trpc/server").TRPCMutationProcedure<{
+		setRoles: MutationProcedure<{
 			input: {
 				userId: string;
 				assignments: Record<":admin" | "view:users" | "manage:users" | "delete:users" | "view:projects" | "manage:projects" | "delete:projects" | "view:projectDeployments" | "manage:projectDeployments" | "delete:projectDeployments" | "view:tools" | "manage:tools" | "delete:tools" | "view:toolTrackings" | "manage:toolTrackings" | "delete:toolTrackings" | "view:toolInventories" | "manage:toolInventories" | "delete:toolInventories" | "view:products" | "manage:products" | "delete:products" | "view:deliveryNotes" | "manage:deliveryNotes" | "delete:deliveryNotes" | "view:productVendors" | "manage:productVendors" | "delete:productVendors" | "view:contacts" | "manage:contacts" | "delete:contacts" | "view:productPriceRecords" | "manage:productPriceRecords" | "delete:productPriceRecords" | "view:customers" | "manage:customers" | "delete:customers", boolean | null | undefined>;
@@ -1663,23 +3422,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			meta: object;
 		}>;
 	}>>;
-	tools: import("@trpc/server").TRPCBuiltRouter<{
+	tools: BuiltRouter<{
 		ctx: TrpcContext;
 		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+		errorShape: DefaultErrorShape | {
 			message: string;
 			data: {
 				httpCode: error.http.StatusCodeCode;
-				code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+				code: TRPC_ERROR_CODE_KEY;
 				httpStatus: number;
 				path?: string;
 				stack?: string;
 			};
-			code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+			code: TRPC_ERROR_CODE_NUMBER;
 		};
 		transformer: true;
-	}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		list: import("@trpc/server").TRPCQueryProcedure<{
+	}, DecorateCreateRouterOptions<{
+		list: QueryProcedure<{
 			input: {
 				search?: string | null | undefined;
 				status?: "lost" | "broken" | "available" | "unavailable" | null | undefined;
@@ -1700,7 +3459,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			}[];
 			meta: object;
 		}>;
-		get: import("@trpc/server").TRPCQueryProcedure<{
+		get: QueryProcedure<{
 			input: {
 				id: string;
 			};
@@ -1718,7 +3477,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		create: import("@trpc/server").TRPCMutationProcedure<{
+		create: MutationProcedure<{
 			input: {
 				customId: number;
 				brand: string;
@@ -1731,7 +3490,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		update: import("@trpc/server").TRPCMutationProcedure<{
+		update: MutationProcedure<{
 			input: {
 				id: string;
 				data: {
@@ -1745,7 +3504,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		delete: import("@trpc/server").TRPCMutationProcedure<{
+		delete: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1754,7 +3513,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		track: import("@trpc/server").TRPCMutationProcedure<{
+		track: MutationProcedure<{
 			input: {
 				id: string;
 				data: {
@@ -1769,7 +3528,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		untrack: import("@trpc/server").TRPCMutationProcedure<{
+		untrack: MutationProcedure<{
 			input: {
 				id: string;
 			};
@@ -1778,23 +3537,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 			};
 			meta: object;
 		}>;
-		trackings: import("@trpc/server").TRPCBuiltRouter<{
+		trackings: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					finished?: boolean | null | undefined;
 					toolId?: string | null | undefined;
@@ -1821,23 +3580,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			requests: import("@trpc/server").TRPCBuiltRouter<{
+			requests: BuiltRouter<{
 				ctx: TrpcContext;
 				meta: object;
-				errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+				errorShape: DefaultErrorShape | {
 					message: string;
 					data: {
 						httpCode: error.http.StatusCodeCode;
-						code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+						code: TRPC_ERROR_CODE_KEY;
 						httpStatus: number;
 						path?: string;
 						stack?: string;
 					};
-					code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+					code: TRPC_ERROR_CODE_NUMBER;
 				};
 				transformer: true;
-			}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-				list: import("@trpc/server").TRPCQueryProcedure<{
+			}, DecorateCreateRouterOptions<{
+				list: QueryProcedure<{
 					input: {
 						toolId?: string | null | undefined;
 						status?: "open" | "accepted" | "denied" | null | undefined;
@@ -1861,7 +3620,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 					}[];
 					meta: object;
 				}>;
-				request: import("@trpc/server").TRPCMutationProcedure<{
+				request: MutationProcedure<{
 					input: {
 						toolTrackingId: string;
 						transferToUserId?: string | null | undefined;
@@ -1873,7 +3632,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 					};
 					meta: object;
 				}>;
-				accept: import("@trpc/server").TRPCMutationProcedure<{
+				accept: MutationProcedure<{
 					input: {
 						id: string;
 						projectId?: string | null | undefined;
@@ -1883,7 +3642,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 					};
 					meta: object;
 				}>;
-				deny: import("@trpc/server").TRPCMutationProcedure<{
+				deny: MutationProcedure<{
 					input: {
 						id: string;
 					};
@@ -1894,23 +3653,23 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}>;
 			}>>;
 		}>>;
-		inventories: import("@trpc/server").TRPCBuiltRouter<{
+		inventories: BuiltRouter<{
 			ctx: TrpcContext;
 			meta: object;
-			errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+			errorShape: DefaultErrorShape | {
 				message: string;
 				data: {
 					httpCode: error.http.StatusCodeCode;
-					code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+					code: TRPC_ERROR_CODE_KEY;
 					httpStatus: number;
 					path?: string;
 					stack?: string;
 				};
-				code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+				code: TRPC_ERROR_CODE_NUMBER;
 			};
 			transformer: true;
-		}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-			list: import("@trpc/server").TRPCQueryProcedure<{
+		}, DecorateCreateRouterOptions<{
+			list: QueryProcedure<{
 				input: {
 					toolId?: string | null | undefined;
 				};
@@ -1922,7 +3681,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				}[];
 				meta: object;
 			}>;
-			create: import("@trpc/server").TRPCMutationProcedure<{
+			create: MutationProcedure<{
 				input: {
 					toolId: string;
 					comment?: string | null | undefined;
@@ -1932,7 +3691,7 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				};
 				meta: object;
 			}>;
-			delete: import("@trpc/server").TRPCMutationProcedure<{
+			delete: MutationProcedure<{
 				input: {
 					id: string;
 				};
@@ -1942,17 +3701,17 @@ declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 				meta: object;
 			}>;
 		}>>;
-		categories: import("@trpc/server").TRPCQueryProcedure<{
+		categories: QueryProcedure<{
 			input: void;
 			output: string[];
 			meta: object;
 		}>;
-		brands: import("@trpc/server").TRPCQueryProcedure<{
+		brands: QueryProcedure<{
 			input: void;
 			output: string[];
 			meta: object;
 		}>;
-		suggestNextCustomId: import("@trpc/server").TRPCQueryProcedure<{
+		suggestNextCustomId: QueryProcedure<{
 			input: void;
 			output: number;
 			meta: object;
@@ -1967,29 +3726,318 @@ interface Cache$1 {
 	clear(): Promise<void>;
 	keys(): Promise<Set<string>>;
 }
+declare class Subscription implements SubscriptionLike {
+	private initialTeardown?;
+	static EMPTY: Subscription;
+	/**
+	 * A flag to indicate whether this Subscription has already been unsubscribed.
+	 */
+	closed: boolean;
+	private _parentage;
+	/**
+	 * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
+	 * list occurs in the {@link #add} and {@link #remove} methods.
+	 */
+	private _finalizers;
+	/**
+	 * @param initialTeardown A function executed first as part of the finalization
+	 * process that is kicked off when {@link #unsubscribe} is called.
+	 */
+	constructor(initialTeardown?: (() => void) | undefined);
+	/**
+	 * Disposes the resources held by the subscription. May, for instance, cancel
+	 * an ongoing Observable execution or cancel any other type of work that
+	 * started when the Subscription was created.
+	 */
+	unsubscribe(): void;
+	/**
+	 * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
+	 * when this subscription is unsubscribed. If this subscription is already {@link #closed},
+	 * because it has already been unsubscribed, then whatever finalizer is passed to it
+	 * will automatically be executed (unless the finalizer itself is also a closed subscription).
+	 *
+	 * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
+	 * subscription to a any subscription will result in no operation. (A noop).
+	 *
+	 * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
+	 * operation at all. (A noop).
+	 *
+	 * `Subscription` instances that are added to this instance will automatically remove themselves
+	 * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
+	 * will need to be removed manually with {@link #remove}
+	 *
+	 * @param teardown The finalization logic to add to this subscription.
+	 */
+	add(teardown: TeardownLogic): void;
+	/**
+	 * Checks to see if a this subscription already has a particular parent.
+	 * This will signal that this subscription has already been added to the parent in question.
+	 * @param parent the parent to check for
+	 */
+	private _hasParent;
+	/**
+	 * Adds a parent to this subscription so it can be removed from the parent if it
+	 * unsubscribes on it's own.
+	 *
+	 * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
+	 * @param parent The parent subscription to add
+	 */
+	private _addParent;
+	/**
+	 * Called on a child when it is removed via {@link #remove}.
+	 * @param parent The parent to remove
+	 */
+	private _removeParent;
+	/**
+	 * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
+	 *
+	 * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
+	 * from every other `Subscription` they have been added to. This means that using the `remove` method
+	 * is not a common thing and should be used thoughtfully.
+	 *
+	 * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance
+	 * more than once, you will need to call `remove` the same number of times to remove all instances.
+	 *
+	 * All finalizer instances are removed to free up memory upon unsubscription.
+	 *
+	 * @param teardown The finalizer to remove from this subscription
+	 */
+	remove(teardown: Exclude<TeardownLogic, void>): void;
+}
+declare class Subscriber<T> extends Subscription implements Observer$1<T> {
+	/**
+	 * A static factory for a Subscriber, given a (potentially partial) definition
+	 * of an Observer.
+	 * @param next The `next` callback of an Observer.
+	 * @param error The `error` callback of an
+	 * Observer.
+	 * @param complete The `complete` callback of an
+	 * Observer.
+	 * @return A Subscriber wrapping the (partially defined)
+	 * Observer represented by the given arguments.
+	 * @deprecated Do not use. Will be removed in v8. There is no replacement for this
+	 * method, and there is no reason to be creating instances of `Subscriber` directly.
+	 * If you have a specific use case, please file an issue.
+	 */
+	static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
+	/** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+	protected isStopped: boolean;
+	/** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+	protected destination: Subscriber<any> | Observer$1<any>;
+	/**
+	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+	 * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
+	 */
+	constructor(destination?: Subscriber<any> | Observer$1<any>);
+	/**
+	 * The {@link Observer} callback to receive notifications of type `next` from
+	 * the Observable, with a value. The Observable may call this method 0 or more
+	 * times.
+	 * @param value The `next` value.
+	 */
+	next(value: T): void;
+	/**
+	 * The {@link Observer} callback to receive notifications of type `error` from
+	 * the Observable, with an attached `Error`. Notifies the Observer that
+	 * the Observable has experienced an error condition.
+	 * @param err The `error` exception.
+	 */
+	error(err?: any): void;
+	/**
+	 * The {@link Observer} callback to receive a valueless notification of type
+	 * `complete` from the Observable. Notifies the Observer that the Observable
+	 * has finished sending push-based notifications.
+	 */
+	complete(): void;
+	unsubscribe(): void;
+	protected _next(value: T): void;
+	protected _error(err: any): void;
+	protected _complete(): void;
+}
+interface Operator<T, R> {
+	call(subscriber: Subscriber<R>, source: any): TeardownLogic;
+}
+declare class Observable$1<T> implements Subscribable$1<T> {
+	/**
+	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+	 */
+	source: Observable$1<any> | undefined;
+	/**
+	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+	 */
+	operator: Operator<any, T> | undefined;
+	/**
+	 * @param subscribe The function that is called when the Observable is
+	 * initially subscribed to. This function is given a Subscriber, to which new values
+	 * can be `next`ed, or an `error` method can be called to raise an error, or
+	 * `complete` can be called to notify of a successful completion.
+	 */
+	constructor(subscribe?: (this: Observable$1<T>, subscriber: Subscriber<T>) => TeardownLogic);
+	/**
+	 * Creates a new Observable by calling the Observable constructor
+	 * @param subscribe the subscriber function to be passed to the Observable constructor
+	 * @return A new observable.
+	 * @deprecated Use `new Observable()` instead. Will be removed in v8.
+	 */
+	static create: (...args: any[]) => any;
+	/**
+	 * Creates a new Observable, with this Observable instance as the source, and the passed
+	 * operator defined as the new observable's operator.
+	 * @param operator the operator defining the operation to take on the observable
+	 * @return A new observable with the Operator applied.
+	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+	 * If you have implemented an operator using `lift`, it is recommended that you create an
+	 * operator by simply returning `new Observable()` directly. See "Creating new operators from
+	 * scratch" section here: https://rxjs.dev/guide/operators
+	 */
+	lift<R>(operator?: Operator<T, R>): Observable$1<R>;
+	subscribe(observerOrNext?: Partial<Observer$1<T>> | ((value: T) => void)): Subscription;
+	/** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
+	subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
+	/**
+	 * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
+	 * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
+	 *
+	 * **WARNING**: Only use this with observables you *know* will complete. If the source
+	 * observable does not complete, you will end up with a promise that is hung up, and
+	 * potentially all of the state of an async function hanging out in memory. To avoid
+	 * this situation, look into adding something like {@link timeout}, {@link take},
+	 * {@link takeWhile}, or {@link takeUntil} amongst others.
+	 *
+	 * #### Example
+	 *
+	 * ```ts
+	 * import { interval, take } from 'rxjs';
+	 *
+	 * const source$ = interval(1000).pipe(take(4));
+	 *
+	 * async function getTotal() {
+	 *   let total = 0;
+	 *
+	 *   await source$.forEach(value => {
+	 *     total += value;
+	 *     console.log('observable -> ' + value);
+	 *   });
+	 *
+	 *   return total;
+	 * }
+	 *
+	 * getTotal().then(
+	 *   total => console.log('Total: ' + total)
+	 * );
+	 *
+	 * // Expected:
+	 * // 'observable -> 0'
+	 * // 'observable -> 1'
+	 * // 'observable -> 2'
+	 * // 'observable -> 3'
+	 * // 'Total: 6'
+	 * ```
+	 *
+	 * @param next A handler for each value emitted by the observable.
+	 * @return A promise that either resolves on observable completion or
+	 * rejects with the handled error.
+	 */
+	forEach(next: (value: T) => void): Promise<void>;
+	/**
+	 * @param next a handler for each value emitted by the observable
+	 * @param promiseCtor a constructor function used to instantiate the Promise
+	 * @return a promise that either resolves on observable completion or
+	 *  rejects with the handled error
+	 * @deprecated Passing a Promise constructor will no longer be available
+	 * in upcoming versions of RxJS. This is because it adds weight to the library, for very
+	 * little benefit. If you need this functionality, it is recommended that you either
+	 * polyfill Promise, or you create an adapter to convert the returned native promise
+	 * to whatever promise implementation you wanted. Will be removed in v8.
+	 */
+	forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
+	pipe(): Observable$1<T>;
+	pipe<A>(op1: OperatorFunction$1<T, A>): Observable$1<A>;
+	pipe<A, B>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>): Observable$1<B>;
+	pipe<A, B, C>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>): Observable$1<C>;
+	pipe<A, B, C, D>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>): Observable$1<D>;
+	pipe<A, B, C, D, E>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>): Observable$1<E>;
+	pipe<A, B, C, D, E, F>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>): Observable$1<F>;
+	pipe<A, B, C, D, E, F, G>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>): Observable$1<G>;
+	pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>, op8: OperatorFunction$1<G, H>): Observable$1<H>;
+	pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>, op8: OperatorFunction$1<G, H>, op9: OperatorFunction$1<H, I>): Observable$1<I>;
+	pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>, op8: OperatorFunction$1<G, H>, op9: OperatorFunction$1<H, I>, ...operations: OperatorFunction$1<any, any>[]): Observable$1<unknown>;
+	/** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+	toPromise(): Promise<T | undefined>;
+	/** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+	toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
+	/** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+	toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
+}
+interface UnaryFunction$1<T, R> {
+	(source: T): R;
+}
+interface OperatorFunction$1<T, R> extends UnaryFunction$1<Observable$1<T>, Observable$1<R>> {
+}
+interface Unsubscribable$1 {
+	unsubscribe(): void;
+}
+declare type TeardownLogic = Subscription | Unsubscribable$1 | (() => void) | void;
+interface SubscriptionLike extends Unsubscribable$1 {
+	unsubscribe(): void;
+	readonly closed: boolean;
+}
+interface Subscribable$1<T> {
+	subscribe(observer: Partial<Observer$1<T>>): Unsubscribable$1;
+}
+interface Observer$1<T> {
+	/**
+	 * A callback function that gets called by the producer during the subscription when
+	 * the producer "has" the `value`. It won't be called if `error` or `complete` callback
+	 * functions have been called, nor after the consumer has unsubscribed.
+	 *
+	 * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
+	 */
+	next: (value: T) => void;
+	/**
+	 * A callback function that gets called by the producer if and when it encountered a
+	 * problem of any kind. The errored value will be provided through the `err` parameter.
+	 * This callback can't be called more than one time, it can't be called if the
+	 * `complete` callback function have been called previously, nor it can't be called if
+	 * the consumer has unsubscribed.
+	 *
+	 * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
+	 */
+	error: (err: any) => void;
+	/**
+	 * A callback function that gets called by the producer if and when it has no more
+	 * values to provide (by calling `next` callback function). This means that no error
+	 * has happened. This callback can't be called more than one time, it can't be called
+	 * if the `error` callback function have been called previously, nor it can't be called
+	 * if the consumer has unsubscribed.
+	 *
+	 * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
+	 */
+	complete: () => void;
+}
 /**
  * Streaming/caching modes consistent with your REST client.
  */
 export type CacheMode = "cache-first" | "cache-only" | "network-first" | "network-only";
-export type MyTRPCClient = TRPCClient<AppRouter>;
-export type PathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
-export type Join<P extends string, K extends string> = P extends "" ? K : `${P}.${K}`;
-export type IsFn<T> = T extends (...args: any[]) => any ? true : false;
-export type TRPCPaths<TClient, Method extends string, P extends string = ""> = TClient extends object ? (Method extends keyof TClient ? IsFn<TClient[Method]> extends true ? P : {
+type MyTRPCClient = TRPCClient<AppRouter>;
+type PathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
+type Join<P extends string, K extends string> = P extends "" ? K : `${P}.${K}`;
+type IsFn<T> = T extends (...args: any[]) => any ? true : false;
+type TRPCPaths<TClient, Method extends string, P extends string = ""> = TClient extends object ? (Method extends keyof TClient ? IsFn<TClient[Method]> extends true ? P : {
 	[K in Extract<keyof TClient, string>]: TRPCPaths<TClient[K], Method, Join<P, K>>;
 }[Extract<keyof TClient, string>] : {
 	[K in Extract<keyof TClient, string>]: TRPCPaths<TClient[K], Method, Join<P, K>>;
 }[Extract<keyof TClient, string>]) : never;
-export type TRPCQueryPaths<TClient> = TRPCPaths<TClient, "query">;
-export type TRPCMutatePaths<TClient> = TRPCPaths<TClient, "mutate">;
-export type QueryPaths = TRPCQueryPaths<MyTRPCClient>;
-export type MutatePaths = TRPCMutatePaths<MyTRPCClient>;
-export type AnyFn = (...args: any[]) => any;
-export type FirstParam<F> = F extends AnyFn ? Parameters<F> extends [
+type TRPCQueryPaths<TClient> = TRPCPaths<TClient, "query">;
+type TRPCMutatePaths<TClient> = TRPCPaths<TClient, "mutate">;
+type QueryPaths = TRPCQueryPaths<MyTRPCClient>;
+type MutatePaths = TRPCMutatePaths<MyTRPCClient>;
+type AnyFn = (...args: any[]) => any;
+type FirstParam<F> = F extends AnyFn ? Parameters<F> extends [
 	infer A,
 	...any[]
 ] ? A : void : never;
-export type RetType<F> = F extends AnyFn ? ReturnType<F> : never;
+type RetType<F> = F extends AnyFn ? ReturnType<F> : never;
 export interface Client {
 	/**
 	 * Convenient wrapper for query execution. This wrapper automatically handles:
@@ -2006,7 +4054,7 @@ export interface Client {
 	]>;
 	streamQuery<PathT extends QueryPaths, QueryResolverT = PathValue<MyTRPCClient, `${PathT}.query`>>(path: PathT, input: FirstParam<QueryResolverT>, opts?: {
 		strategy?: CacheMode;
-	}): Observable<[
+	}): Observable$1<[
 		Awaited<RetType<QueryResolverT>> | null,
 		TRPCClientError<any> | null
 	]>;