@powerlines/deepkit 0.4.91 → 0.4.92

package/dist/vendor/core.d.ts

@@ -1 +1,827 @@
-export * from '@deepkit/core';
+/**
+ * Makes sure the error once printed using console.log contains the actual class name.
+ *
+ * @example
+ * ```
+ * class MyApiError extends CustomerError {}
+ *
+ * throw MyApiError() // prints MyApiError instead of simply "Error".
+ * ```
+ *
+ * @public
+ */
+export declare class CustomError extends Error {
+	name: string;
+	constructor(...args: any[]);
+}
+export interface CustomError {
+	cause?: unknown;
+}
+/**
+ * @public
+ */
+export interface ClassType<T = any> {
+	new (...args: any[]): T;
+}
+/**
+ * @public
+ */
+export type AbstractClassType<T = any> = abstract new (...args: any[]) => T;
+export type ExtractClassType<T> = T extends AbstractClassType<infer K> ? K : never;
+/**
+ * Returns the class name either of the class definition or of the class of an instance.
+ *
+ * Note when code is minimized/uglified this output will change. You should disable in your compile the
+ * className modification.
+ *
+ * @example
+ * ```typescript
+ * class User {}
+ *
+ * expect(getClassName(User)).toBe('User');
+ * expect(getClassName(new User())).toBe('User');
+ * ```
+ *
+ * @public
+ */
+export declare function getClassName<T>(classTypeOrInstance: ClassType<T> | Object): string;
+/**
+ * Same as getClassName but appends the propertyName.
+ * @public
+ */
+export declare function getClassPropertyName<T>(classType: ClassType<T> | Object, propertyName: string): string;
+/**
+ * @public
+ */
+export declare function applyDefaults<T>(classType: ClassType<T>, target: {
+	[k: string]: any;
+}): T;
+/**
+ * Tries to identify the object by normalised result of Object.toString(obj).
+ */
+export declare function identifyType(obj: any): string;
+/**
+ * Returns true if the given obj is a plain object, and no class instance.
+ *
+ * isPlainObject(\{\}) === true
+ * isPlainObject(new ClassXY) === false
+ *
+ * @public
+ */
+export declare function isPlainObject(obj: any): obj is object;
+/**
+ * Returns the ClassType for a given instance.
+ */
+export declare function getClassTypeFromInstance<T>(target: T): ClassType<T>;
+/**
+ * Returns true when target is a class instance.
+ */
+export declare function isClassInstance(target: any): boolean;
+/**
+ * Returns a human-readable string representation from the given value.
+ */
+export declare function stringifyValueWithType(value: any, depth?: number): string;
+/**
+ * Changes the class of a given instance and returns the new object.
+ *
+ * @example
+ * ```typescript
+ *
+ *  class Model1 {
+ *    id: number = 0;
+ *  }
+ *
+ *  class Model2 {
+ *    id: number = 0;
+ *  }
+ *
+ *  const model1 = new Model1();
+ *  const model2 = changeClass(model1, Model2);
+ *  model2 instanceof Model2; //true
+ * ```
+ */
+export declare function changeClass<T>(value: object, newClass: ClassType<T>): T;
+export declare function prettyPrintObject(object: object, depth?: number): string;
+/**
+ * Returns true if given obj is a function.
+ *
+ * @public
+ */
+export declare function isFunction(obj: any): obj is Function;
+export declare const AsyncFunction: {
+	new (...args: string[]): Function;
+};
+/**
+ * Returns true if given obj is a async function.
+ *
+ * @public
+ */
+export declare function isAsyncFunction(obj: any): obj is (...args: any[]) => Promise<any>;
+/**
+ * Returns true if given obj is a promise like object.
+ *
+ * Note: There's not way to check if it's actually a Promise using instanceof since
+ * there are a lot of different implementations around.
+ *
+ * @public
+ */
+export declare function isPromise<T>(obj: any | Promise<T>): obj is Promise<T>;
+/**
+ * Returns true if given obj is a ES6 class (ES5 fake classes are not supported).
+ *
+ * @public
+ */
+export declare function isClass(obj: any): obj is AbstractClassType;
+export declare function isGlobalClass(obj: any): obj is AbstractClassType;
+/**
+ * Returns true for real objects: object literals ({}) or class instances (new MyClass).
+ *
+ * @public
+ */
+export declare function isObject(obj: any): obj is {
+	[key: string]: any;
+};
+/**
+ * Returns true if given obj is a plain object, and no Date, Array, Map, Set, etc.
+ *
+ * This is different to isObject and used in the type system to differentiate
+ * between JS objects in general and what we define as ReflectionKind.objectLiteral.
+ * Since we have Date, Set, Map, etc. in the type system, we need to differentiate
+ * between them and all other object literals.
+ */
+export declare function isObjectLiteral(obj: any): obj is {
+	[key: string]: any;
+};
+/**
+ * @public
+ */
+export declare const isArray: (obj: any) => obj is any[];
+/**
+ * @public
+ */
+export declare function isNull(obj: any): obj is null;
+/**
+ * @public
+ */
+export declare function isUndefined(obj: any): obj is undefined;
+/**
+ * Checks if obj is not null and not undefined.
+ *
+ * @public
+ */
+export declare function isSet(obj: any): boolean;
+/**
+ * @public
+ */
+export declare function isNumber(obj: any): obj is number;
+/**
+ * Returns true if given value is strictly a numeric string value (or a number).
+ *
+ * ```typescript
+ * isNumeric(12); //true
+ * isNumeric('12'); //true
+ * isNumeric('12.3'); //true
+ * isNumeric('12.3 '); //false
+ * isNumeric('12px'); //false
+ * ```
+ * @public
+ */
+export declare function isNumeric(s: string | number): boolean;
+export declare const isInteger: (obj: any) => obj is number;
+/**
+ * @public
+ */
+export declare function isString(obj: any): obj is string;
+/**
+ * @public
+ */
+export declare function indexOf<T>(array: T[], item: T): number;
+/**
+ * @public
+ */
+export declare function sleep(seconds: number): Promise<void>;
+/**
+ * Creates a shallow copy of given array.
+ *
+ * @public
+ */
+export declare function copy<T>(v: T[]): T[];
+/**
+ * Checks whether given array or object is empty (no keys). If given object is falsy, returns false.
+ *
+ * @public
+ */
+export declare function empty<T>(value?: T[] | object | {}): boolean;
+/**
+ * Returns the size of given array or object.
+ *
+ * @public
+ */
+export declare function size<T>(array: T[] | {
+	[key: string]: T;
+}): number;
+/**
+ * Returns the first key of a given object.
+ *
+ * @public
+ */
+export declare function firstKey(v: {
+	[key: string]: any;
+} | object): string | undefined;
+/**
+ * Returns the last key of a given object.
+ *
+ * @public
+ */
+export declare function lastKey(v: {
+	[key: string]: any;
+} | object): string | undefined;
+/**
+ * Returns the first value of given array or object.
+ *
+ * @public
+ */
+export declare function first<T>(v: {
+	[key: string]: T;
+} | T[]): T | undefined;
+/**
+ * Returns the last value of given array or object.
+ *
+ * @public
+ */
+export declare function last<T>(v: {
+	[key: string]: T;
+} | T[]): T | undefined;
+/**
+ * Returns the average of a number array.
+ *
+ * @public
+ */
+export declare function average(array: number[]): number;
+/**
+ * @public
+ */
+export declare function prependObjectKeys(o: {
+	[k: string]: any;
+}, prependText: string): {
+	[k: string]: any;
+};
+/**
+ * @public
+ */
+export declare function appendObject(origin: {
+	[k: string]: any;
+}, extend: {
+	[k: string]: any;
+}, prependKeyName?: string): void;
+/**
+ * A better alternative to "new Promise()" that supports error handling and maintains the stack trace for Error.stack.
+ *
+ * When you use `new Promise()` you need to wrap your code inside a try-catch to call `reject` on error.
+ * asyncOperation() does this automatically.
+ *
+ * When you use `new Promise()` you will lose the stack trace when `reject(new Error())` is called.
+ * asyncOperation() makes sure the error stack trace is the correct one.
+ *
+ * @example
+ * ```typescript
+ * await asyncOperation(async (resolve, reject) => {
+ *     await doSomething(); //if this fails, reject() will automatically be called
+ *     stream.on('data', (data) => {
+ *         resolve(data); //at some point you MUST call resolve(data)
+ *     });
+ * });
+ * ```
+ *
+ * @public
+ * @reflection never
+ */
+export declare function asyncOperation<T>(executor: (resolve: (value: T) => void, reject: (error: any) => void) => void | Promise<void>): Promise<T>;
+/**
+ * When an API is called that returns a promise that loses the stack trace on error, you can use fixAsyncOperation().
+ *
+ * ```typescript
+ * cons storage = new BrokenPromiseStorage();
+ * const files = await fixAsyncOperation(storage.files('/'));
+ * ```
+ */
+export declare function fixAsyncOperation<T>(promise: Promise<T>): Promise<T>;
+/**
+ * @public
+ */
+export declare function mergePromiseStack<T>(promise: Promise<T>, stack?: string): Promise<T>;
+/**
+ * @beta
+ */
+export declare function createStack(removeCallee?: boolean): string;
+/**
+ * @beta
+ */
+export declare function mergeStack(error: Error, stack: string): void;
+/**
+ * Makes sure the given value is an error. If it's not an error, it creates a new error with the given value as message.
+ */
+export declare function ensureError(error?: any, classType?: ClassType): Error;
+export declare function collectForMicrotask<T>(callback: (args: T[]) => void): (arg: T) => void;
+/**
+ * Returns the current time as seconds.
+ *
+ * @public
+ */
+export declare function time(): number;
+/**
+ * @public
+ */
+export declare function getPathValue(bag: {
+	[field: string]: any;
+}, parameterPath: string, defaultValue?: any): any;
+/**
+ * @public
+ */
+export declare function setPathValue(bag: object, parameterPath: string, value: any): void;
+/**
+ * @public
+ */
+export declare function deletePathValue(bag: object, parameterPath: string): void;
+/**
+ * Returns the human-readable byte representation.
+ *
+ * @public
+ */
+export declare function humanBytes(bytes: number, si?: boolean): string;
+/**
+ * Returns the number of properties on `obj`. This is 20x faster than Object.keys(obj).length.
+ */
+export declare function getObjectKeysSize(obj: object): number;
+export declare function isConstructable(fn: any): boolean;
+export declare function isPrototypeOfBase(prototype: AbstractClassType | undefined, base: ClassType): boolean;
+export declare function getParentClass(classType: ClassType): ClassType | undefined;
+export declare function getInheritanceChain(classType: ClassType): ClassType[];
+export declare function inDebugMode(): boolean;
+/**
+ * Create a new class with the given name.
+ * This is currently the only know way to make it workable in browsers too.
+ */
+export declare function createDynamicClass(name: string, base?: ClassType): ClassType;
+export declare function isIterable(value: any): boolean;
+export declare function iterableSize(value: Array<unknown> | Set<unknown> | Map<unknown, unknown>): number;
+/**
+ * Returns __filename, works in both cjs and esm.
+ */
+export declare function getCurrentFileName(): string;
+/**
+ * Escape special characters in a regex string, so it can be used as a literal string.
+ */
+export declare function escapeRegExp(string: string): string;
+export declare function hasProperty(object: any, property: any): boolean;
+/**
+ * Returns an iterator of numbers from start (inclusive) to stop (exclusive) by step.
+ */
+export declare function range(startOrLength: number, stop?: number, step?: number): IterableIterator<number>;
+/**
+ * Returns an array of numbers from start (inclusive) to stop (exclusive) by step.
+ *
+ * Works the same as python's range function.
+ */
+export declare function rangeArray(startOrLength: number, stop?: number, step?: number): number[];
+/**
+ * Returns a combined array of the given arrays.
+ *
+ * Works the same as python's zip function.
+ */
+export declare function zip<T extends (readonly unknown[])[]>(...args: T): {
+	[K in keyof T]: T[K] extends (infer V)[] ? V : never;
+}[];
+/**
+ * Forwards the runtime type arguments from function x to function y.
+ * This is necessary when a generic function is overridden and forwarded to something else.
+ *
+ * ```typescript
+ * let generic = <T>(type?: ReceiveType<T>) => undefined;
+ *
+ * let forwarded<T> = () => {
+ *     forwardTypeArguments(forwarded, generic); //all type arguments are forwarded to generic()
+ *     generic(); //call as usual
+ * }
+ *
+ * forwarded<any>(); //generic receives any in runtime.
+ * ```
+ *
+ * Note that generic.bind(this) will not work, as bind() creates a new function and forwarded type arguments can not
+ * reach the original function anymore.
+ *
+ * ```typescript
+ * let forwarded<T> = () => {
+ *     const bound = generic.bind(this);
+ *     forwardTypeArguments(forwarded, bound); //can not be forwarded anymore
+ *     bound(); //fails
+ * }
+ * ```
+ *
+ *  This is a limitation of JavaScript. In this case you have to manually forward type arguments.
+ *
+ *  ```typescript
+ *  let forwarded<T> = (type?: ReceiveType<T>) => {
+ *     const bound = generic.bind(this);
+ *     bound(type);
+ *  }
+ *  ```
+ */
+export declare function forwardTypeArguments(x: any, y: any): void;
+export declare function formatError(error: any, withStack?: boolean): string;
+/**
+ * Asserts that the given object is an instance of the given class.
+ */
+export declare function assertInstanceOf<T>(object: any, constructor: {
+	new (...args: any[]): T;
+}): asserts object is T;
+/**
+ * Asserts that the given value is defined (not null and not undefined).
+ */
+export declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+export declare type __ΩCustomError = any[];
+export declare type __ΩClassType = any[];
+export declare type __ΩAbstractClassType = any[];
+export declare type __ΩExtractClassType = any[];
+/**
+ * Logs every call to this method on stdout.
+ *
+ * @public
+ */
+export declare function log(): (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Makes sure that calls to this async method are stacked up and are called one after another and not parallel.
+ *
+ * @public
+ */
+export declare function stack(): (target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>) => void;
+/**
+ * Makes sure that this async method is only running once at a time. When this method is running and it is tried
+ * to call it another times, that call is "dropped" and it returns simply the result of the previous running call (waiting for it to complete first).
+ *
+ * @public
+ */
+export declare function singleStack(): (target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>) => void;
+/**
+ * Returns the enum label for a given enum value.
+ *
+ * @public
+ */
+export declare function getEnumLabel(enumType: {
+	[field: string]: any;
+}, id: any): any;
+/**
+ * Returns all possible enum labels.
+ *
+ * @public
+ */
+export declare function getEnumLabels(enumDefinition: any): string[];
+/**
+ * Returns all possible enum keys.
+ *
+ * @public
+ */
+export declare function getEnumValues(enumDefinition: any): any[];
+export declare function getEnumKeyLabelMap(enumDefinition: any): Map<any, string>;
+/**
+ * Checks whether given enum value is valid.
+ *
+ * @public
+ */
+export declare function isValidEnumValue(enumDefinition: any, value: any, allowLabelsAsValue?: boolean): boolean;
+/**
+ * @public
+ */
+export declare function getValidEnumValue(enumDefinition: any, value: any, allowLabelsAsValue?: boolean): any;
+/**
+ * Iterator for each key of an array or object.
+ *
+ * @example
+ * ```
+ * for (const i of eachKey(['a', 'b']) {
+ *    console.log(i); //0, 1
+ * }
+ * ```
+ *
+ * @public
+ * @category iterator
+ */
+export declare function eachKey<T>(object: ArrayLike<T>): IterableIterator<number>;
+/** @public */
+export declare function eachKey<T extends {
+	[key: string]: any;
+}, K extends keyof T>(object: T): IterableIterator<string>;
+/**
+ * Iterator for each value of an array or object.
+ *
+ * @example
+ * ```
+ * for (const v of each(['a', 'b']) {
+ *    console.log(v); //a, b
+ * }
+ * ```
+ *
+ * @public
+ * @category iterator
+ */
+export declare function each<T>(object: {
+	[s: string]: T;
+} | ArrayLike<T>): IterableIterator<T>;
+/**
+ * Iterator for key value pair of an array or object.
+ *
+ * @example
+ * ```
+ * for (const [i, v] of eachPair(['a', 'b']) {
+ *    console.log(i, v); //0 a, 1 b
+ * }
+ *
+ * for (const [i, v] of eachPair({'foo': 'bar}) {
+ *    console.log(i, v); //foo bar
+ * }
+ * ```
+ *
+ * @public
+ * @category iterator
+ */
+export declare function eachPair<T>(object: ArrayLike<T>): IterableIterator<[
+	number,
+	T
+]>;
+/** @public */
+export declare function eachPair<T>(object: {
+	[s: string]: T;
+}): IterableIterator<[
+	string,
+	T
+]>;
+export declare class Timer {
+	protected timeoutTimers: any[];
+	setTimeout(cb: () => void, timeout: number): any;
+	/**
+	 * Clears all timers at once.
+	 */
+	clear(): void;
+}
+/**
+ * This lock mechanism works only for one process (worker).
+ *
+ * live-mutex: has horrible API and doesn't allow to check if an key is currently locked.
+ * proper-filelock: No way to do a correct mutex locking with event-driven blocking acquire() method.
+ * redislock: Very bad performance on high-load (when multiple locks on the same key `wait`, since it loops)
+ * mongodb lock: even worse performance than redis. Jesus.
+ */
+export declare class ProcessLock {
+	readonly id: string;
+	private holding;
+	protected ttlTimeout: any;
+	constructor(id: string);
+	acquire(ttl?: number, timeout?: number): Promise<void>;
+	isLocked(): boolean;
+	tryLock(ttl?: number): boolean;
+	unlock(): void;
+}
+export declare class ProcessLocker {
+	/**
+	 *
+	 * @param id
+	 * @param ttl optional defines when the times automatically unlocks.
+	 * @param timeout if after `timeout` seconds the lock isn't acquired, it throws an error.
+	 */
+	acquireLock(id: string, ttl?: number, timeout?: number): Promise<ProcessLock>;
+	tryLock(id: string, ttl?: number): Promise<ProcessLock | undefined>;
+	isLocked(id: string): boolean;
+}
+export declare class Mutex {
+	protected promise?: Promise<void>;
+	protected resolver?: Function;
+	unlock(): void;
+	lock(): Promise<void>;
+}
+export declare class ParsedHost {
+	host: string;
+	port: number;
+	unixSocket: string;
+	get isUnixSocket(): boolean;
+	get isHostname(): boolean;
+	get hostWithIp(): string;
+	toString(): string;
+	getWebSocketUrl(secure?: boolean): string;
+	getHttpUrl(secure?: boolean): string;
+}
+export declare function parseHost(hostWithIpOrUnixPath: string): ParsedHost;
+export declare function toFastProperties(obj: any): void;
+export declare class CompilerContext {
+	readonly context: Map<string, any>;
+	protected constVariables: Map<any, string>;
+	maxReservedVariable: number;
+	protected reservedNames: Set<string>;
+	protected variableContext: {
+		[name: string]: any;
+	};
+	/**
+	 * Code that is executed in the context, but before the actual function is generated.
+	 * This helps for example to initialize dynamically some context variables.
+	 */
+	preCode: string;
+	initialiseVariables: string[];
+	config: {
+		indent: boolean;
+	};
+	constructor(config?: Partial<CompilerContext["config"]>);
+	reserveName(name: string): string;
+	set(values: {
+		[name: string]: any;
+	}): void;
+	/**
+	 * Returns always the same variable name for the same value.
+	 * The variable name should not be set afterwards.
+	 */
+	reserveConst(value: any, name?: string): string;
+	reserveVariable(name?: string, value?: any): string;
+	raw(functionCode: string): Function;
+	protected format(code: string): string;
+	build(functionCode: string, ...args: string[]): any;
+	buildAsync(functionCode: string, ...args: string[]): Function;
+}
+export declare function indent(indentation: number, prefix?: string): (str?: string) => string;
+export declare function capitalize(string: string): string;
+export type AsyncSubscriber<T> = (event: T) => Promise<void> | void;
+export type Subscriber<T> = (event: T) => Promise<void> | void;
+export type AsyncEventSubscription = {
+	unsubscribe: () => void;
+};
+export type EventSubscription = {
+	unsubscribe: () => void;
+};
+export declare class EmitterEvent {
+	readonly id: number;
+	stopped: boolean;
+	propagationStopped: boolean;
+	/**
+	 * Stop propagating the event to subsequent event listeners.
+	 */
+	stopPropagation(): void;
+	/**
+	 * Signal the emitter that you want to abort.
+	 * Subsequent event listeners will still be called.
+	 */
+	stop(): void;
+}
+export declare class EventEmitter<T extends EmitterEvent> {
+	protected parent?: EventEmitter<any> | undefined;
+	protected subscribers: Subscriber<T>[];
+	constructor(parent?: EventEmitter<any> | undefined);
+	subscribe(callback: Subscriber<T>): EventSubscription;
+	emit(event: T): void;
+	hasSubscriptions(): boolean;
+}
+export declare class AsyncEventEmitter<T extends EmitterEvent> {
+	protected parent?: AsyncEventEmitter<any> | undefined;
+	protected subscribers: AsyncSubscriber<T>[];
+	constructor(parent?: AsyncEventEmitter<any> | undefined);
+	subscribe(callback: AsyncSubscriber<T>): AsyncEventSubscription;
+	emit(event: T): Promise<void>;
+	hasSubscriptions(): boolean;
+}
+export declare type __ΩAsyncEventSubscription = any[];
+export declare type __ΩEventSubscription = any[];
+export declare const nextTick: (cb: () => void) => any;
+export declare const clearTick: (id: any) => any;
+/**
+ * Wraps a function and calls it only `cps` times per frame.
+ *
+ * This is handy to throttle all kind of rapid calls, like mouse move events or other kind of events.
+ *
+ * @example
+ * ```typescript
+ * function expensiveFunction() {
+ *     //...
+ * }
+ *
+ * const throttled = throttleTime(expensiveFunction, 5); //5 calls per second max
+ *
+ * throttled();
+ * throttled();
+ * throttled();
+ * //throttled will here only be called once
+ * ```
+ */
+export declare function throttleTime(call: Function, cps?: number): (...args: any[]) => void;
+/**
+ * This functions returns a stack that is filled as long as the gate is not activated.
+ * Once activated all recorded calls go to given callback and subsequent calls go directly to given callback.
+ */
+export declare function bufferedGate<T>(callback: (arg: T) => any): {
+	activate: () => void;
+	call: (i: T) => void;
+};
+export declare function extractParameters(fn: string | Function | ClassType): string[];
+export declare function extractMethodBody(classCode: string, name: string): string;
+export declare function removeStrings(code: string): string;
+export declare function urlJoin(...path: string[]): string;
+/**
+ * @public
+ */
+export declare function arrayHasItem<T>(array: T[], item: T): boolean;
+/**
+ * Clears the array so its empty. Returns the amount of removed items.
+ *
+ * @public
+ */
+export declare function arrayClear<T>(array: T[]): number;
+/**
+ * Removes on particular item by reference of an array.
+ *
+ * @public
+ */
+export declare function arrayRemoveItem<T>(array: T[], item: T): boolean;
+/**
+ * Moves a particular item in an array up or down (move>0=down, move<0=up).
+ * Changes the array itself.
+ *
+ * ```typescript
+ * const array = ['a', 'b', 'c'];
+ *
+ * arrayMoveItem(array, 'a', +1); //['b', 'a', 'c']
+ * arrayMoveItem(array, 'a', -1); //['a', 'b', 'c']
+ *
+ * arrayMoveItem(array, 'b', -1); //['b', 'a', 'c']
+ * arrayMoveItem(array, 'b', +1); //['a', 'c', 'b']
+ *
+ * arrayMoveItem(array, 'c', -1); //['b', 'c', 'b']
+ * arrayMoveItem(array, 'c', +1); //['a', 'b', 'c']
+ *
+ * ```
+ *
+ * @public
+ */
+export declare function arrayMoveItem<A extends T[], T>(array: A, item: T, move: number): A;
+/**
+ * Type to use for custom type annotations.
+ *
+ * Adds runtime meta information to a type without influencing the type itself.
+ * This is like an intrinsic type, but only for runtime.
+ *
+ * ```typescript
+ * import { TypeAnnotation } from '@deepkit/core';
+ * import { typeAnnotation } from '@deepkit/type';
+ *
+ * type PrimaryKey = TypeAnnotation<'primaryKey'>;
+ * type UserId = string & PrimaryKey;
+ *
+ * const type = typeOf<UserId>();
+ * const metaData = typeAnnotation.getType(type, 'primaryKey');
+ * ```
+ *
+ * Runtime type is `{ __meta?: never & [T, Options] };`
+ *
+ * @intrinsic
+ */
+export type TypeAnnotation<T extends string, Options = never> = unknown;
+export type InjectMeta<T = never> = TypeAnnotation<"inject", T>;
+export type Inject<Type, Token = never> = Type & InjectMeta<Token>;
+export declare type __ΩTypeAnnotation = any[];
+export declare type __ΩInjectMeta = any[];
+export declare type __ΩInject = any[];
+/**
+ * Create a buffer of the given size (uninitialized, so it may contain random data).
+ *
+ * Note that the result is either Uin8Array or Buffer, depending on the environment.
+ * Buffer from NodeJS works slightly different than Uint8Array.
+ */
+export declare const createBuffer: (size: number) => Uint8Array;
+/**
+ * Concat multiple buffers into one.
+ */
+export declare function bufferConcat(chunks: Uint8Array[], length?: number): Uint8Array;
+export declare const uint8ArrayToUtf8: (buffer: Uint8Array) => any;
+/**
+ * Convert a buffer to a string.
+ */
+export declare function bufferToString(buffer: string | Uint8Array): string;
+export declare function nativeBase64ToUint8Array(base64: string): Uint8Array;
+/**
+ * Converts a base64 string to a Uint8Array.
+ */
+export declare const base64ToUint8Array: (v: string) => Uint8Array;
+/**
+ * Normalizes the given path.
+ * Removes duplicate slashes, removes trailing slashes, adds a leading slash.
+ */
+export declare function pathNormalize(path: string): string;
+/**
+ * Returns the directory (dirname) of the given path.
+ */
+export declare function pathDirectory(path: string): string;
+/**
+ * Returns the basename of the given path.
+ */
+export declare function pathBasename(path: string): string;
+/**
+ * Returns the extension of the given path.
+ */
+export declare function pathExtension(path: string): string;
+export declare function pathJoin(...paths: string[]): string;
+
+export {};