agentstack/lib/index.d.ts

Enterprise Application Stack for TypeScript

/// <reference types="node" />

import { Constructor, IAttribute } from 'agentframework';
import { EventEmitter } from 'events';

export interface ISerializable {
	toJSON(): object;
}
export declare class Exception extends Error implements ISerializable {
	code: number;
	cause: Exception | Error;
	context: object;
	constructor(err: Error, code: number, obj: object, msg: string, ...params: Array<any>);
	constructor(err: Error);
	constructor(err: Error, code: number);
	constructor(err: Error, code: number, obj: object);
	constructor(err: Error, code: number, obj: object, msg: string, ...params: Array<any>);
	constructor(err: Error, code: number, msg: string, ...params: Array<any>);
	constructor(err: Error, obj: object);
	constructor(err: Error, obj: object, msg: string, ...params: Array<any>);
	constructor(err: Error, msg: string, ...params: Array<any>);
	constructor(code: number);
	constructor(code: number, obj: object);
	constructor(code: number, obj: object, msg: string, ...params: Array<any>);
	constructor(code: number, msg: string, ...params: Array<any>);
	constructor(obj: object);
	constructor(obj: object, msg: string, ...params: Array<any>);
	constructor(msg?: string, ...params: Array<any>);
	private static parseArguments;
	private static buildNestedErrorStackTrace;
	toJSON(): object;
}
export declare class MissingConfigurationValueException extends Exception {
	constructor(key: string);
}
export declare class ApplicationNotCreatedException extends Exception {
	constructor(operation?: PropertyKey);
}
export declare class NotSupportedException extends Exception {
	constructor(operation: string);
}
export declare class FileStreamException extends Exception {
}
export declare class TransporterException extends Exception {
}
export declare class LoggerException extends Exception {
}
export declare class File {
	private _file;
	private _permission;
	private constructor();
	static Read: number;
	static ReadWrite: number;
	static Write: number;
	static resolve(root: string, filePath: string, permission: number): File;
	toString(): string;
	readonly path: string;
	readonly permission: number;
	readAll(): string;
}
export declare class Directory {
	private _directory;
	private _permission;
	private constructor();
	static cwd(): Directory;
	static withReadPermission(directory: string): Directory;
	static withReadWritePermission(directory: string): Directory;
	static mkdir(dir: string, mode?: number): boolean;
	private static resolve;
	toString(): string;
	readonly path: string;
	directory(relativePath: string): Directory;
	file(relativeFilePath: string): File;
}
export interface IApplicationOptions {
	root?: string;
	confDir?: string;
	settings?: any;
}
export declare enum LogLevel {
	trace = 10,
	debug = 20,
	info = 30,
	warn = 40,
	error = 50,
	fatal = 60
}
export interface ILogger {
	child(context: any): ILogger;
	update(context: any): void;
	context(): any;
	trace(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	trace(err: Error, msg?: string, ...params: Array<any>): void;
	trace(msg: string, ...params: Array<any>): void;
	trace(obj: any, msg?: string, ...params: Array<any>): void;
	debug(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	debug(err: Error, msg?: string, ...params: Array<any>): void;
	debug(msg: string, ...params: Array<any>): void;
	debug(obj: any, msg?: string, ...params: Array<any>): void;
	log(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	log(err: Error, msg?: string, ...params: Array<any>): void;
	log(msg: string, ...params: Array<any>): void;
	log(obj: any, msg?: string, ...params: Array<any>): void;
	info(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	info(err: Error, msg?: string, ...params: Array<any>): void;
	info(msg: string, ...params: Array<any>): void;
	info(obj: any, msg?: string, ...params: Array<any>): void;
	warn(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	warn(err: Error, msg?: string, ...params: Array<any>): void;
	warn(msg: string, ...params: Array<any>): void;
	warn(obj: any, msg?: string, ...params: Array<any>): void;
	error(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	error(err: Error, msg?: string, ...params: Array<any>): void;
	error(msg: string, ...params: Array<any>): void;
	error(obj: any, msg?: string, ...params: Array<any>): void;
	fatal(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	fatal(err: Error, msg?: string, ...params: Array<any>): void;
	fatal(msg: string, ...params: Array<any>): void;
	fatal(obj: any, msg?: string, ...params: Array<any>): void;
}
export declare class ApplicationSettings {
	NAME: string;
	VERSION: string;
	ENV: string;
	PRINT_SETTINGS: boolean;
	AUTO_CREATE_DIRECTORY: boolean;
	PACKAGE_FILE: string;
	EXIT_WAIT_TIMEOUT: number;
	HOME_DIR: string;
	DATA_DIR: string;
	CONF_DIR: string;
	LOG_DIR: string;
	LOG_LEVEL: string | 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
	LOG_CONSOLE: boolean;
	LOG_CONSOLE_LEVEL: string | 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
	LOG_CONSOLE_STYLE: string | 'default' | 'none';
	LOG_WEBHOOK: boolean;
	LOG_WEBHOOK_LEVEL: string | 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
	LOG_WEBHOOK_URL: string;
}
declare class StoppableEvent {
	stopPropagation(): void;
	isStopped(): any;
}
declare class StoppableEventEmitter extends EventEmitter {
	emitStoppableEvent(name: string | symbol, event: StoppableEvent): boolean;
}
export interface IResolver {
	construct<T>(type: Constructor, transit?: boolean): T;
	resolve<T>(type: Constructor, transit?: boolean): Promise<T>;
	registerSingleton(type: Constructor, instance: any): void;
	releaseSingleton(type: Constructor): void;
	registerType(type: Constructor, initializer: Function, finalizer: Function): void;
	releaseType(type?: Constructor): Array<any>;
}
export declare class Identity {
	id: string;
	address: string;
}
export declare class Application<T extends ApplicationSettings> extends StoppableEventEmitter implements ILogger, IResolver {
	protected _id: number;
	private _identity;
	private readonly _root;
	private readonly _settings;
	private readonly _logger;
	private readonly _options;
	private readonly _resolver;
	constructor(opts?: IApplicationOptions);
	readonly name: string;
	setIdentity(identity: Identity): void;
	readonly identity: Identity;
	exit(reason?: Error | object | string): void;
	readonly root: Directory;
	directory(relativePath?: string): Directory;
	file(relativeFilePath: string): File;
	readonly settings: T;
	get(key: string, defaultValue?: any): any;
	set(key: string, value: any): any;
	has(key: string): boolean;
	child(context: any): ILogger;
	update(context: any): void;
	context(): any;
	trace(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	trace(err: Error, msg?: string, ...params: Array<any>): void;
	trace(obj: any, msg?: string, ...params: Array<any>): void;
	trace(msg: string, ...params: Array<any>): void;
	debug(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	debug(err: Error, msg?: string, ...params: Array<any>): void;
	debug(obj: any, msg?: string, ...params: Array<any>): void;
	debug(msg: string, ...params: Array<any>): void;
	log(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	log(err: Error, msg?: string, ...params: Array<any>): void;
	log(obj: any, msg?: string, ...params: Array<any>): void;
	log(msg: string, ...params: Array<any>): void;
	info(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	info(err: Error, msg?: string, ...params: Array<any>): void;
	info(obj: any, msg?: string, ...params: Array<any>): void;
	info(msg: string, ...params: Array<any>): void;
	warn(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	warn(err: Error, msg?: string, ...params: Array<any>): void;
	warn(obj: any, msg?: string, ...params: Array<any>): void;
	warn(msg: string, ...params: Array<any>): void;
	error(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	error(err: Error, msg?: string, ...params: Array<any>): void;
	error(obj: any, msg?: string, ...params: Array<any>): void;
	error(msg: string, ...params: Array<any>): void;
	fatal(err: Error, obj: any, msg?: string, ...params: Array<any>): void;
	fatal(err: Error, msg?: string, ...params: Array<any>): void;
	fatal(obj: any, msg?: string, ...params: Array<any>): void;
	fatal(msg: string, ...params: Array<any>): void;
	construct<T>(type: Constructor, transit?: boolean): T;
	resolve<T>(type: Constructor, transit?: boolean): Promise<T>;
	registerSingleton(type: Constructor, instance: any): void;
	releaseSingleton(type: Constructor): void;
	registerType(type: Constructor, create?: Function, dispose?: Function): void;
	releaseType(type: Constructor): Array<any>;
}
export interface FetchConfiguration {
	method: string;
	url: string;
	data: any;
}
export interface FetchResponse {
	ok: boolean | number;
	headers: any;
	status: number;
	error?: string;
	errcode?: number;
	message?: string;
	stack?: string;
	result?: any;
	results?: Array<any>;
}
export interface Context<T extends ApplicationSettings> extends IResolver {
	readonly identity: Identity;
	readonly settings: T;
	readonly logger: ILogger;
	fetch(url: string, init?: FetchConfiguration): Promise<FetchResponse>;
	fetch(init: FetchConfiguration): Promise<FetchResponse>;
}
export declare class ConfigurationAttribute implements IAttribute {
	key?: string;
	constructor(key?: string);
	beforeDecorate(target: Object | Function, targetKey?: string | symbol, descriptor?: PropertyDescriptor): boolean;
}
export declare function conf(key?: string): PropertyDecorator;
export interface IDisposable {
	dispose(disposing: boolean): void;
	disposing: boolean;
}
export declare function parseYAML(file: File): any;
export declare function dumpYAML(data: any, filename: string): void;
export declare function parseJSON(file: File): any;
export declare function dumpJSON(data: any, filename: string): void;
export declare function deserialize(data: string): object;
export declare function serialize(obj: any): string;
export declare function service(): ClassDecorator;
export declare function singleton(type?: Constructor): PropertyDecorator;
export declare function transit(type?: Constructor): PropertyDecorator;
export interface ITypeRegistry {
	registerType(type: Constructor, initializer?: Function, finalizer?: Function): void;
	deleteType(type: Constructor): void;
	getInitializerOf(type: any): Function | undefined;
	getFinalizerOf(type: any): Function | undefined;
}
export declare class TypeRegistry implements ITypeRegistry {
	private parent?;
	private initializers;
	private finalizers;
	static readonly Singleton: unique symbol;
	static readonly Initializer: unique symbol;
	static readonly Finalizer: unique symbol;
	constructor(parent?: ITypeRegistry);
	registerType(type: Constructor, initializer?: Function, finalizer?: Function): void;
	deleteType(type: Constructor): void;
	getInitializerOf(type: any): Function | undefined;
	getFinalizerOf(type: any): Function | undefined;
}
export declare class Resolver implements IResolver {
	private readonly constructorParams;
	private singletons;
	private types;
	private registry;
	constructor(constructorParams: Array<any>, parent?: ITypeRegistry);
	construct<T>(type: Constructor, transit?: boolean): T;
	resolve<T>(type: Constructor, transit?: boolean): Promise<T>;
	registerSingleton(type: Constructor, instance: any): void;
	releaseSingleton(type: Constructor): void;
	registerType(type: Constructor, create?: Function, dispose?: Function): void;
	releaseType(type: Constructor): Array<any>;
	private create;
}
export declare abstract class Resolvable<T extends ApplicationSettings> {
	settings: T;
	logger: ILogger;
	readonly name: string;
	constructor(app: Application<T>);
}
export interface NextFunction {
	(): Promise<any>;
}
export declare class Middleware extends Array {
	use(fn: any): void;
	next(context: any, last: any, i: number): void;
	compose(context: any, last: any): Promise<any>;
}
export declare enum RouteType {
	STATIC = 0,
	PARAM = 1,
	ANY = 2
}
export interface Param {
	key: string;
	value: string;
}
export interface MatchedRoute {
	node: Route;
	params: Array<Param>;
}
export declare class Route {
	private key;
	private prefix;
	private type;
	private children;
	private parts;
	data: any;
	constructor(prefix?: string, type?: RouteType, children?: Array<Route>, data?: any);
	node(path: string): Route;
	search(path: string): MatchedRoute | null;
	private ensureChild;
	private createChild;
	private setParams;
	private findChild;
	private findOwnChild;
	private findOwnChildWithLabel;
	private findOwnChildByType;
}
export declare class BaseX {
	map: object;
	alphabet: string;
	base: number;
	leader: string;
	constructor(alphabet: string);
	static readonly singleton: BaseX;
	fromBuffer(data: Buffer): string;
	toBuffer(text: string): Buffer;
	fromHex(hex: string): string;
	toHex(text: string): string;
	fromNumber(n: number): string;
	toNumber(text: string): number;
	private decodeUnsafe;
}
export declare class Base62 extends BaseX {
	constructor();
	static fromBuffer(data: Buffer): string;
	static toBuffer(text: string): Buffer;
	static fromHex(hex: string): string;
	static toHex(text: string): string;
	static fromNumber(n: number): string;
	static toNumber(text: string): number;
}
export declare class Base58 extends BaseX {
	constructor();
	static fromBuffer(data: Buffer): string;
	static toBuffer(text: string): Buffer;
	static fromHex(hex: string): string;
	static toHex(text: string): string;
	static fromNumber(n: number): string;
	static toNumber(text: string): number;
}
export interface Stop {
	(err?: Error): void;
}
export interface Retriable<T> {
	(stop: Stop, attempts: number, errors?: Array<Error>): Promise<T>;
}
export interface RetryOptions {
	retries?: number;
	factor?: number;
	minTimeout?: number;
	maxTimeout?: number;
	randomize?: boolean;
	onRetry?: (err: Error) => void;
}
export declare function retry<T>(retriable: Retriable<T>, opts?: RetryOptions): Promise<T>;
export declare function CreateApplication<T extends ApplicationSettings>(opts?: IApplicationOptions): Application<T>;
export declare function SetCurrentApplication(app: any): void;
export declare function CurrentApplication<T extends ApplicationSettings>(): Application<T>;
export declare function padStart(text: any, maxLength: number, fillString?: string): string;
export declare function padEnd(text: string, maxLength: number, fillString?: string): string;
export declare const _default: Application<ApplicationSettings>;
export { URL } from 'url';
export default _default;