node-universe/dist/index.d.ts

基于 Nodejs 环境的一款微服务框架，原理来自于宇宙中的恒星，行星，卫星等系统。

import _ from 'lodash';
import util from 'util';
import EventEmitter3 from 'eventemitter3';
import Redlock from 'redlock';
import { LRUCache } from 'lru-cache';
import { NatsConnection } from 'nats';
import Mqtt from 'mqtt';
import { Kafka, Producer, Consumer, Admin } from 'kafkajs';
import EventEmitter from 'events';
import { Socket } from 'dgram';
import { Server, Socket as Socket$1 } from 'net';
import http from 'http';
import * as fastest_validator from 'fastest-validator';
import fastest_validator__default from 'fastest-validator';
import kleur from 'kleur';

interface GenericObject {
    [name: string]: any;
}

declare enum BaseLoggerLevels {
    fatal = "fatal",
    error = "error",
    warn = "warn",
    debug = "debug",
    info = "info",
    trace = "trace"
}
interface FormattedLoggerOptions {
    colors?: boolean;
    moduleColor?: boolean | string[] | string;
    formatter?: any;
    objectPrinter?: any;
    autoPadding?: boolean;
    folder: string;
    filename: string;
    eol: any;
    interval: number;
}
interface LogLevelConfig {
    type?: BaseLoggerLevels;
    options?: GenericObject;
}
interface LoggerBindings {
    nodeID?: string;
    namespace?: string;
    mod?: string;
    svc?: string;
    ver?: string;
}
declare class LoggerInstance {
    fatal(...args: any[]): void;
    error(...args: any[]): void;
    warn(...args: any[]): void;
    info(...args: any[]): void;
    debug(...args: any[]): void;
    trace(...args: any[]): void;
}

declare const _default$b: {
    TYPE_COUNTER: string;
    TYPE_GAUGE: string;
    TYPE_HISTOGRAM: string;
    TYPE_INFO: string;
    UNIVERSE_METRICS_COMMON_COLLECT_TOTAL: string;
    UNIVERSE_METRICS_COMMON_COLLECT_TIME: string;
    PROCESS_ARGUMENTS: string;
    PROCESS_PID: string;
    PROCESS_PPID: string;
    PROCESS_MEMORY_HEAP_SIZE_TOTAL: string;
    PROCESS_MEMORY_HEAP_SIZE_USED: string;
    PROCESS_MEMORY_RSS: string;
    PROCESS_MEMORY_EXTERNAL: string;
    PROCESS_MEMORY_HEAP_SPACE_SIZE_TOTAL: string;
    PROCESS_MEMORY_HEAP_SPACE_SIZE_USED: string;
    PROCESS_MEMORY_HEAP_SPACE_SIZE_AVAILABLE: string;
    PROCESS_MEMORY_HEAP_SPACE_SIZE_PHYSICAL: string;
    PROCESS_MEMORY_HEAP_STAT_HEAP_SIZE_TOTAL: string;
    PROCESS_MEMORY_HEAP_STAT_EXECUTABLE_SIZE_TOTAL: string;
    PROCESS_MEMORY_HEAP_STAT_PHYSICAL_SIZE_TOTAL: string;
    PROCESS_MEMORY_HEAP_STAT_AVAILABLE_SIZE_TOTAL: string;
    PROCESS_MEMORY_HEAP_STAT_USED_HEAP_SIZE: string;
    PROCESS_MEMORY_HEAP_STAT_HEAP_SIZE_LIMIT: string;
    PROCESS_MEMORY_HEAP_STAT_MALLOCATED_MEMORY: string;
    PROCESS_MEMORY_HEAP_STAT_PEAK_MALLOCATED_MEMORY: string;
    PROCESS_MEMORY_HEAP_STAT_ZAP_GARBAGE: string;
    PROCESS_UPTIME: string;
    PROCESS_INTERNAL_ACTIVE_HANDLES: string;
    PROCESS_INTERNAL_ACTIVE_REQUESTS: string;
    PROCESS_VERSIONS_NODE: string;
    PROCESS_EVENTLOOP_LAG_MIN: string;
    PROCESS_EVENTLOOP_LAG_AVG: string;
    PROCESS_EVENTLOOP_LAG_MAX: string;
    PROCESS_EVENTLOOP_LAG_COUNT: string;
    PROCESS_GC_TIME: string;
    PROCESS_GC_TOTAL_TIME: string;
    PROCESS_GC_EXECUTED_TOTAL: string;
    OS_MEMORY_FREE: string;
    OS_MEMORY_USED: string;
    OS_MEMORY_TOTAL: string;
    OS_UPTIME: string;
    OS_TYPE: string;
    OS_RELEASE: string;
    OS_HOSTNAME: string;
    OS_ARCH: string;
    OS_PLATFORM: string;
    OS_USER_UID: string;
    OS_USER_GID: string;
    OS_USER_USERNAME: string;
    OS_USER_HOMEDIR: string;
    OS_DATETIME_UNIX: string;
    OS_DATETIME_ISO: string;
    OS_DATETIME_UTC: string;
    OS_DATETIME_TZ_OFFSET: string;
    OS_NETWORK_ADDRESS: string;
    OS_NETWORK_MAC: string;
    OS_CPU_LOAD_1: string;
    OS_CPU_LOAD_5: string;
    OS_CPU_LOAD_15: string;
    OS_CPU_UTILIZATION: string;
    OS_CPU_USER: string;
    OS_CPU_SYSTEM: string;
    OS_CPU_TOTAL: string;
    OS_CPU_INFO_MODEL: string;
    OS_CPU_INFO_SPEED: string;
    OS_CPU_INFO_TIMES_USER: string;
    OS_CPU_INFO_TIMES_SYS: string;
    UNIVERSE_NODE_TYPE: string;
    UNIVERSE_NODE_VERSIONS_UNIVERSE: string;
    UNIVERSE_NODE_VERSIONS_LANG: string;
    UNIVERSE_NODE_VERSIONS_PROTOCOL: string;
    UNIVERSE_STAR_NAMESPACE: string;
    UNIVERSE_STAR_STARTED: string;
    UNIVERSE_STAR_LOCAL_SERVICES_TOTAL: string;
    UNIVERSE_STAR_MIDDLEWARES_TOTAL: string;
    UNIVERSE_REGISTRY_NODES_TOTAL: string;
    UNIVERSE_REGISTRY_NODES_ONLINE_TOTAL: string;
    UNIVERSE_REGISTRY_SERVICES_TOTAL: string;
    UNIVERSE_REGISTRY_SERVICE_ENDPOINTS_TOTAL: string;
    UNIVERSE_REGISTRY_ACTIONS_TOTAL: string;
    UNIVERSE_REGISTRY_ACTION_ENDPOINTS_TOTAL: string;
    UNIVERSE_REGISTRY_EVENTS_TOTAL: string;
    UNIVERSE_REGISTRY_EVENT_ENDPOINTS_TOTAL: string;
    UNIVERSE_REQUEST_TOTAL: string;
    UNIVERSE_REQUEST_ACTIVE: string;
    UNIVERSE_REQUEST_ERROR_TOTAL: string;
    UNIVERSE_REQUEST_TIME: string;
    UNIVERSE_REQUEST_LEVELS: string;
    UNIVERSE_REQUEST_DIRECTCALL_TOTAL: string;
    UNIVERSE_REQUEST_MULTICALL_TOTAL: string;
    UNIVERSE_EVENT_EMIT_TOTAL: string;
    UNIVERSE_EVENT_BROADCAST_TOTAL: string;
    UNIVERSE_EVENT_BROADCASTLOCAL_TOTAL: string;
    UNIVERSE_EVENT_RECEIVED_TOTAL: string;
    UNIVERSE_EVENT_RECEIVED_ACTIVE: string;
    UNIVERSE_EVENT_RECEIVED_ERROR_TOTAL: string;
    UNIVERSE_EVENT_RECEIVED_TIME: string;
    UNIVERSE_TRANSIT_PUBLISH_TOTAL: string;
    UNIVERSE_TRANSIT_RECEIVE_TOTAL: string;
    UNIVERSE_TRANSIT_REQUESTS_ACTIVE: string;
    UNIVERSE_TRANSIT_STREAMS_SEND_ACTIVE: string;
    UNIVERSE_TRANSIT_STREAMS_RECEIVE_ACTIVE: string;
    UNIVERSE_TRANSIT_READY: string;
    UNIVERSE_TRANSIT_CONNECTED: string;
    UNIVERSE_TRANSIT_PONG_TIME: string;
    UNIVERSE_TRANSIT_PONG_SYSTIME_DIFF: string;
    UNIVERSE_TRANSIT_ORPHAN_RESPONSE_TOTAL: string;
    UNIVERSE_TRANSPORTER_PACKETS_SENT_TOTAL: string;
    UNIVERSE_TRANSPORTER_PACKETS_SENT_BYTES: string;
    UNIVERSE_TRANSPORTER_PACKETS_RECEIVED_TOTAL: string;
    UNIVERSE_TRANSPORTER_PACKETS_RECEIVED_BYTES: string;
    UNIVERSE_CIRCUIT_STAR_OPENED_ACTIVE: string;
    UNIVERSE_CIRCUIT_STAR_OPENED_TOTAL: string;
    UNIVERSE_CIRCUIT_STAR_HALF_OPENED_ACTIVE: string;
    UNIVERSE_REQUEST_FALLBACK_TOTAL: string;
    UNIVERSE_REQUEST_BULKHEAD_INFLIGHT: string;
    UNIVERSE_REQUEST_BULKHEAD_QUEUE_SIZE: string;
    UNIVERSE_EVENT_BULKHEAD_INFLIGHT: string;
    UNIVERSE_EVENT_BULKHEAD_QUEUE_SIZE: string;
    UNIVERSE_REQUEST_RETRY_ATTEMPTS_TOTAL: string;
    UNIVERSE_REQUEST_TIMEOUT_TOTAL: string;
    UNIVERSE_CACHER_GET_TOTAL: string;
    UNIVERSE_CACHER_GET_TIME: string;
    UNIVERSE_CACHER_FOUND_TOTAL: string;
    UNIVERSE_CACHER_SET_TOTAL: string;
    UNIVERSE_CACHER_SET_TIME: string;
    UNIVERSE_CACHER_DEL_TOTAL: string;
    UNIVERSE_CACHER_DEL_TIME: string;
    UNIVERSE_CACHER_CLEAN_TOTAL: string;
    UNIVERSE_CACHER_CLEAN_TIME: string;
    UNIVERSE_CACHER_EXPIRED_TOTAL: string;
    UNIVERSE_DISCOVERER_REDIS_COLLECT_TOTAL: string;
    UNIVERSE_DISCOVERER_REDIS_COLLECT_TIME: string;
    UNIVERSE_DISCOVERER_ETCD_COLLECT_TOTAL: string;
    UNIVERSE_DISCOVERER_ETCD_COLLECT_TIME: string;
    UNIT_BIT: string;
    UNIT_BYTE: string;
    UNIT_KILOBYTES: string;
    UNIT_MEGABYTE: string;
    UNIT_GIGABYTE: string;
    UNIT_TERRABYTE: string;
    UNIT_PETABYTE: string;
    UNIT_EXOBYTE: string;
    UNIT_NANOSECONDS: string;
    UNIT_MICROSECONDS: string;
    UNIT_MILLISECONDS: string;
    UNIT_SECONDS: string;
    UNIT_MINUTE: string;
    UNIT_HOUR: string;
    UNIT_DAY: string;
    UNIT_WEEK: string;
    UNIT_MONTH: string;
    UNIT_YEAR: string;
    UNIT_HANDLE: string;
    UNIT_CPU: string;
    UNIT_GHZ: string;
    UNIT_REQUEST: string;
    UNIT_CONNECTION: string;
    UNIT_PACKET: string;
    UNIT_MESSAGE: string;
    UNIT_STREAM: string;
    UNIT_EVENT: string;
};

interface MetricRegistryOptions {
    enabled?: boolean;
    collectProcessMetrics?: boolean;
    collectInterval?: number;
    reporter?: string | MetricsReporterOptions | (MetricsReporterOptions | string)[] | null;
    defaultBuckets?: number[];
    defaultQuantiles?: number[];
    defaultMaxAgeSeconds?: number;
    defaultAgeBuckets?: number;
    defaultAggregator?: string;
}
interface MetricsReporterOptions {
    type: string;
    options?: MetricReporterOptions;
}
interface MetricReporterOptions {
    includes?: string | string[];
    excludes?: string | string[];
    metricNamePrefix?: string;
    metricNameSuffix?: string;
    metricNameFormatter?: (name: string) => string;
    labelNameFormatter?: (name: string) => string;
    [key: string]: any;
}
interface BaseMetricOptions {
    type: string;
    name: string;
    description?: string;
    labelNames?: string[];
    unit?: string;
    aggregator?: string;
    [key: string]: any;
}
interface GaugeMetricSnapshot {
    value: number;
    labels: GenericObject;
    timestamp: number;
}
interface InfoMetricSnapshot {
    value: number;
    labels: GenericObject;
    timestamp: number;
}
interface HistogramMetricSnapshot {
    labels: GenericObject;
    count: number;
    sum: number;
    timestamp: number;
    buckets?: {
        [key: string]: number;
    };
    min?: number | null;
    mean?: number | null;
    variance?: number | null;
    stdDev?: number | null;
    max?: number | null;
    quantiles?: {
        [key: string]: number;
    };
}
type MetricSnapshot = GaugeMetricSnapshot | InfoMetricSnapshot | HistogramMetricSnapshot;

declare class BaseMetric {
    type: string;
    registry: MetricRegistry;
    name: string;
    description: string;
    labelNames: string[];
    unit: string;
    aggregator: string;
    lastSnapshot: Array<MetricSnapshot> | null;
    dirty: boolean;
    values: Map<string, GenericObject>;
    constructor(options: BaseMetricOptions, registry: MetricRegistry);
    setDirty(): void;
    clearDirty(): void;
    get(labels: GenericObject): GenericObject | undefined;
    set(value: number | string, labels?: GenericObject, timestamp?: number): void;
    reset(labels?: GenericObject, timestamp?: number): void;
    resetAll(timestamp?: number): void;
    clear(): void;
    hashingLabels(labels?: GenericObject): string;
    changed(value: any | null, labels?: any, timestamp?: number): void;
    snapshot(): MetricSnapshot[] | null;
    increment(labels?: GenericObject, value?: number, timestamp?: number): void;
    decrement(labels?: GenericObject, value?: number, timestamp?: number): void;
    observe(value: number, labels?: GenericObject, timestamp?: number): void;
    generateSnapshot(): any;
    toObject(): {
        type: string;
        name: string;
        description: string;
        labelNames: string[];
        unit: string;
        values: MetricSnapshot[] | null;
    };
}

declare class BaseReporter {
    options: MetricReporterOptions;
    registry: MetricRegistry | null;
    star: Star | null;
    logger: LoggerInstance | null;
    constructor(options: MetricReporterOptions);
    init(registry: MetricRegistry): void;
    stop(): Promise<void>;
    matchMetricName(name: string): boolean;
    formatMetricName(name: string): string;
    formatLabelName(name: string): string;
    metricChanged(metric: BaseMetric, value: any, labels?: GenericObject, timestamp?: number): void;
}

declare class MetricRegistry {
    star: Star;
    logger: LoggerInstance;
    dirty: boolean;
    options: MetricRegistryOptions;
    store: Map<string, BaseMetric>;
    reporter: BaseReporter[];
    collectTimer: NodeJS.Timer | null;
    constructor(star: Star, options?: MetricRegistryOptions | boolean);
    init(): void;
    stop(): Promise<void[]> | undefined;
    isEnabled(): boolean | undefined;
    changed(metric: BaseMetric, value: any, labels?: GenericObject, timestamp?: number): void;
    register(options: BaseMetricOptions): BaseMetric | null;
    hasMetric(name: string): boolean;
    getMetric(name: string): BaseMetric | null;
    set(name: string, value: any | null, labels?: GenericObject, timestamp?: number): void | null;
    increment(name: string, labels?: GenericObject | null, value?: number, timestamp?: number): void | null;
    decrement(name: string, labels?: GenericObject | null, value?: number, timestamp?: number): void | null;
    observe(name: string, value: number, labels?: GenericObject, timestamp?: number): void | null;
    reset(name: string, labels?: GenericObject, timestamp?: number): null | undefined;
    resetAll(name: string, timestamp?: number): null | undefined;
    timer(name?: string, labels?: GenericObject, timestamp?: number): () => number;
    list(options?: GenericObject): GenericObject[];
    pluralizeUnit(unit: string): string;
}

declare class PrometheusReporter extends BaseReporter {
    server: http.Server | null;
    defaultLabels: GenericObject;
    constructor(options: MetricReporterOptions);
    init(registry: MetricRegistry): void;
    private handler;
    stop(): Promise<void>;
    private generatePrometheusResponse;
    private escapeLabelValue;
    private labelsToStr;
}

declare class ConsoleReporter extends BaseReporter {
    lastChanges: Set<string>;
    timer: NodeJS.Timer | null;
    constructor(options: MetricsReporterOptions);
    init(registry: MetricRegistry): void;
    private labelToStr;
    print(): void;
    private log;
    metricChanged(metric: BaseMetric, value: any, labels?: GenericObject, timestamp?: number): void;
}

declare class EventRepoter extends BaseReporter {
    lastChanges: Set<any>;
    timer: NodeJS.Timer | null;
    constructor(options: MetricReporterOptions);
    init(registry: MetricRegistry): void;
    sendEvent(): void;
    metricChanged(metric: BaseMetric, value: any, labels?: GenericObject | undefined, timestamp?: number | undefined): void;
}

declare class CSVReporter extends BaseReporter {
    lastChanges: Set<any>;
    timer: NodeJS.Timer | null;
    folder: string;
    constructor(options: MetricReporterOptions);
    init(registry: MetricRegistry): void;
    labelsToStr(labels: object): string;
    getFilename(metric: any, item: any): any;
    writeRow(filename: string, headers: string[], fields: string[]): void;
    flush(): void;
    metricChanged(metric: any, value: any, labels: any): void;
}

declare class DataDogReporter extends BaseReporter {
    private timer;
    private defaultLabels;
    constructor(options: any);
    init(registry: any): void;
    flush(): Promise<void> | undefined;
    stop(): Promise<void>;
    private escapeLabelValue;
    private labelsToTags;
    private posixTimestamp;
    private generateDatadogSeries;
}

declare class StatsdReporter extends BaseReporter {
    private defaultLabels;
    constructor(options: any);
    init(registry: any): void;
    private labelsToTags;
    private escapeLabelValue;
    private generateStatsDSeries;
    private generateStatDLine;
    flush(): void;
    private sendChunks;
    private send;
    metricChanged(metric: any, value: any, labels: any): void;
}

declare function resolve$8(opt: any): any;
declare function register$9(name: any, value: any): void;
declare const _default$a: {
    Base: typeof BaseReporter;
    Console: typeof ConsoleReporter;
    Event: typeof EventRepoter;
    CSV: typeof CSVReporter;
    Prometheus: typeof PrometheusReporter;
    DateDog: typeof DataDogReporter;
    Statsd: typeof StatsdReporter;
} & {
    resolve: typeof resolve$8;
    register: typeof register$9;
};

declare class BaseCacher {
    options: CacherOptions;
    connected: any;
    star: Star | null;
    logger: LoggerInstance | null;
    prefix: string;
    metrics: MetricRegistry | null;
    constructor(options: CacherOptions);
    init(star: Star): void;
    private registerStarCacherMetrics;
    close(): Promise<any>;
    get(key: string): Promise<any>;
    getWithTTL(key: string): Promise<any>;
    set(key: string, data: any, ttl?: number): Promise<any>;
    delete(key: string | string[]): Promise<any>;
    clean(match?: string | string[]): Promise<any>;
    tryLock(key: string | string[], ttl?: number): Promise<any>;
    lock(key: string | string[], ttl?: number): Promise<any>;
    getParamMetaValue(key: string, params: GenericObject, meta: GenericObject): any;
    defaultKeygen(actionName: string, params: GenericObject, meta: GenericObject, keys: Array<any> | null): string;
    _hashedKey(key: string): string;
    _generateKeyFromObject(obj: any): any;
    getCacheKey(actionName: string, params: GenericObject, meta: GenericObject, keys: string[], actionKeygen?: Function): any;
    getCacheKeys(): Promise<any>;
    middleware(): {
        name: string;
        localAction: (handler: any, action: any) => any;
    };
}

type ActionCacheEnabledFuncType = (ctx: Context) => boolean;
interface ActionCacheOptions<P = Record<string, unknown>, M = unknown> {
    enabled?: boolean | ActionCacheEnabledFuncType;
    ttl?: number;
    keys?: string[];
    keygen?: CacherKeygenFunc<P, M>;
    lock?: {
        enabled?: boolean;
        staleTime?: number;
    };
}
type CacherKeygenFunc<P = Record<string, unknown>, M = unknown> = (actionName: string, params: P, meta: M, keys?: string[]) => string;
interface CacherOptions {
    ttl?: number;
    keygen?: CacherKeygenFunc;
    maxParamsLength?: number;
    [key: string]: any;
}
interface RedisCacherOptions extends CacherOptions {
    prefix?: string;
    redis?: GenericObject;
    redlock?: boolean | GenericObject;
    monitor?: boolean;
    pingInterval?: number;
}
type Cacher<T extends BaseCacher = BaseCacher> = T;

declare class RateLimiter {
    options: GenericObject;
    lastTime: number;
    balance: number;
    maxBalance: number;
    constructor(options: GenericObject);
    check(cost?: number): boolean;
}

declare class Span {
    id: string;
    name: string;
    type: string;
    options: GenericObject;
    tracer: Tracer | null;
    traceID: string;
    parentID: string | null;
    logger: LoggerInstance | null;
    service: {
        name?: string;
        version?: string | number | null | undefined;
        fullName?: string;
    };
    priority: number;
    sampled: boolean;
    startTime: number | null;
    finishTime: number | null;
    duration: number | null;
    startTicks: number;
    error: Error | boolean | null;
    logs: SpanLogEntry[];
    tags: GenericObject;
    constructor(tracer: Tracer, name: string, options?: GenericObject);
    addTags(obj: Object): this;
    start(time?: number): this;
    getTime(): number;
    log(name: string, fields?: GenericObject, time?: number): this;
    setError(err: Error): this;
    finish(time?: number): this;
    isActive(): boolean;
    startSpan(name: string, options?: GenericObject): Span | undefined;
}

declare class Tracer {
    star: Star;
    logger: LoggerInstance;
    options: GenericObject;
    sampleCounter: number;
    rateLimiter: RateLimiter | null;
    defaultTags: GenericObject | Function | null;
    exporter: TraceExporter[] | null;
    constructor(star: Star, options: TracerOptions | boolean);
    init(): void;
    stop(): Promise<any>;
    isEnabled(): any;
    shouldSample(span: Span): boolean;
    startSpan(name: string, options?: GenericObject): Span;
    spanStarted(span: Span): void;
    spanFinished(span: Span): void;
    invokeExporter(method: string, args: Array<any>): void;
    getCurrentTraceID(): null;
    getActiveSpanID(): null;
}

declare class BaseTraceExporter {
    options: GenericObject;
    tracer: Tracer | null;
    logger: LoggerInstance | null;
    star: Star | null;
    constructor(options?: GenericObject);
    init(tracer: Tracer): void;
    stop(): void;
    spanStarted(span: Span): void;
    spanFinished(span: Span): void;
    flattenTags(obj: GenericObject | null, convertToString?: boolean, path?: string): {} | null;
    errorToObject(error: Error | boolean | null): Partial<true | Error> | null;
}

type TracingActionTagsFuncType = (ctx: Context, response?: any) => GenericObject;
type TracingEventTagsFuncType = (ctx: Context) => GenericObject;
type TracingSpanNameOption = string | ((ctx: Context) => string);
type TracingActionTags = TracingActionTagsFuncType | {
    params?: boolean | string[];
    meta?: boolean | string[];
    response?: boolean | string[];
};
type TracingEventTags = TracingEventTagsFuncType | {
    params?: boolean | string[];
    meta?: boolean | string[];
};
interface TracingOptions {
    enabled?: boolean;
    tags?: TracingActionTags | TracingEventTags;
    spanName?: TracingSpanNameOption;
    safetyTags?: boolean;
}
interface TracingActionOptions extends TracingOptions {
    tags?: TracingActionTags;
}
interface TracingEventOptions extends TracingOptions {
    tags?: TracingEventTags;
}
interface TracerExporterOptions {
    type: string;
    options?: GenericObject;
}
interface TracerOptions {
    enabled?: boolean;
    exporter?: string | TracerExporterOptions | (TracerExporterOptions | string)[] | null;
    sampling?: {
        rate?: number | null;
        tracesPerSecond?: number | null;
        minPriority?: number | null;
    };
    actions?: boolean;
    events?: boolean;
    errorFields?: string[];
    stackTrace?: boolean;
    defaultTags?: GenericObject | Function | null;
    tags?: {
        action?: TracingActionTags;
        event?: TracingEventTags;
    };
}
type TraceExporter<T extends BaseTraceExporter = BaseTraceExporter> = T;
interface SpanLogEntry {
    name: string;
    fields: GenericObject;
    time: number;
    elapsed: number;
}
interface StarTrackingOptions {
    enabled?: boolean;
    shutdownTimeout?: number;
}

declare enum UniverseErrorOptionsType {
    BAD_GETWAY = "BAD_GETWAY",
    SERVICE_NOT_FOUND = "SERVICE_NOT_FOUND",
    SERVICE_NOT_AVAILABLE = "SERVICE_NOT_AVAILABLE",
    REQUEST_TIMEOUT = "REQUEST_TIMEOUT",
    REQUEST_SKIPPED = "REQUEST_SKIPPED",
    REQUEST_REJECTED = "REQUEST_REJECTED",
    QUEUE_FULL = "QUEUE_FULL",
    VALIDATION_ERROR = "VALIDATION_ERROR",
    MAX_CALL_LEVEL = "MAX_CALL_LEVEL",
    SERVICE_SCHEMA_ERROR = "SERVICE_SCHEMA_ERROR",
    STAR_OPTIONS_ERROR = "STAR_OPTIONS_ERROR",
    GRACEFUL_STOP_TIMEOUT = "GRACEFUL_STOP_TIMEOUT",
    PROTOCOL_VERSION_MISMATCH = "PROTOCOL_VERSION_MISMATCH",
    INVALID_PACKET_DATA = "INVALID_PACKET_DATA",
    MISSING_PAYLOAD = "MISSING_PAYLOAD",
    INVALID_ENDPOINT = "INVALID_ENDPOINT",
    INVALID_PARAMETERS = "INVALID_PARAMETERS",
    METRICS_DISABLED = "METRICS_DISABLED",
    NOT_FOUND_EVENT = "NOT_FOUND_EVENT",
    WAITFOR_SERVICES = "WAITFOR_SERVICES"
}
declare enum UniverseErrorCode {
    RESPONSE_ERROR = 400,
    SERVICE_NOT_FOUND = 404,
    VALIDATION_ERROR = 422,
    QUEUE_FULL = 429,
    SERVICE_ERROR = 500,
    BAD_GETWAY = 502,
    REQUEST_REJECTED = 503,
    REQUEST_TIMEOUT = 504,
    REQUEST_SKIPPED = 514
}
interface UniverseErrorData {
    nodeID?: string;
    name?: string;
    action?: any;
    version?: string;
    level?: number;
    type?: UniverseErrorOptionsType | string;
    service?: {
        name: string;
        version: string;
    };
    actual?: string;
    received?: string;
    strategy?: string | null;
    value?: any;
    schema?: any;
    size?: number;
    limit?: number;
    eventName?: string;
    services?: any[];
    statuses?: any[];
    [key: string]: any;
}
interface UniversePlainError extends UniverseError {
    nodeID?: string;
    [key: string]: any;
}

declare class BaseError extends Error {
    constructor(message?: string);
}

declare class UniverseError extends BaseError {
    code: UniverseErrorCode | number;
    type: UniverseErrorOptionsType | string;
    data?: UniverseErrorData;
    retryable: boolean;
    constructor(message: string, code?: UniverseErrorCode | number, type?: UniverseErrorOptionsType | string, data?: UniverseErrorData);
}
declare class UniverseRetryableError extends UniverseError {
    constructor(message: string, code?: UniverseErrorCode | number, type?: UniverseErrorOptionsType | string, data?: UniverseErrorData);
}
declare class StarDisconnectedError extends UniverseRetryableError {
    constructor();
}
declare class StarServerError extends UniverseRetryableError {
}
declare class StarClientError extends UniverseError {
    constructor(message: string, code: UniverseErrorCode | number, type: UniverseErrorOptionsType | string, data?: UniverseErrorData);
}
declare class ServiceNotFoundError extends UniverseRetryableError {
    constructor(data?: UniverseErrorData);
}
declare class QueueIsFullError extends UniverseRetryableError {
    constructor(data?: UniverseErrorData);
}
declare class ValidationError extends StarClientError {
    constructor(message: string, type?: UniverseErrorOptionsType | string, data?: UniverseErrorData);
}
declare class MaxCallLevelError extends UniverseError {
    constructor(data?: UniverseErrorData);
}
declare class ServiceSchemaError extends UniverseError {
    constructor(message: string, data?: UniverseErrorData);
}
declare class StarOptionsError extends UniverseError {
    constructor(message: string, data?: UniverseErrorData);
}
declare class GracefulStopTimeoutError extends UniverseError {
    constructor(data: UniverseErrorData | undefined);
}
declare class ProtocolVersionMismatchError extends UniverseError {
    constructor(data: UniverseErrorData | undefined);
}
declare class InvalidPacketDataError extends UniverseError {
    constructor(data: any);
}

declare function recreateError(error: UniversePlainError): UniverseError | undefined;
declare class Regenerator {
    star: Star | null;
    init(star: Star): void;
    restore(plainError: UniversePlainError, payload: GenericObject): Error;
    extracPlainError(err: any, payload: any): {
        name: any;
        message: any;
        nodeID: any;
        code: any;
        type: any;
        retryable: any;
        stack: any;
        data: any;
    };
    restoreCustomError(plainError: UniversePlainError, payload: GenericObject): Error | undefined;
    private createDefaultError;
    restoreExternalFields(plainError: UniversePlainError, err: any, payload: GenericObject): void;
    restoreStack(plainError: UniversePlainError, err: any): void;
}
declare function resolveRengerator(options: any): Regenerator;

interface EventSchema {
    name?: string;
    group?: string;
    params?: ActionParams;
    service?: Service;
    tracing?: boolean | TracingEventOptions;
    bulkhead?: BulkheadOptions;
    handler?: ActionHandler;
    context?: boolean;
    [key: string]: any;
}
type ServiceEventLegacyHandler = (payload: any, sender: string, eventName: string, ctx: Context) => void | Promise<void>;
type ServiceEventHandler = (ctx: Context) => void | Promise<void>;
interface ServiceEvent$1 {
    name?: string;
    group?: string;
    params?: ActionParams;
    context?: boolean;
    debounce?: number;
    throttle?: number;
    handler?: ServiceEventHandler | ServiceEventLegacyHandler;
}

interface ServiceSettingSchema {
    $noVersionPrefix?: boolean;
    $noServiceNamePrefix?: boolean;
    $dependencyTimeout?: number;
    $shutdownTimeout?: number;
    $secureSettings?: string[];
    [name: string]: any;
}
interface ServiceDependency {
    name: string;
    version?: string | number;
}
type ServiceActionsSchema<S = ServiceSettingSchema> = {
    [key: string]: ActionSchema | ActionHandler | boolean;
} & ThisType<Service<S>>;
type ServiceMethods = {
    [key: string]: (...args: any[]) => any;
} & ThisType<Service>;
interface ServiceHooksBefore {
    [key: string]: string | ActionHookBefore | (string | ActionHookBefore)[];
}
interface ServiceHooksAfter {
    [key: string]: string | ActionHookAfter | (string | ActionHookAfter)[];
}
interface ServiceHooksError {
    [key: string]: string | ActionHookError | (string | ActionHookError)[];
}
interface ServiceHooks {
    before?: ServiceHooksBefore;
    after?: ServiceHooksAfter;
    error?: ServiceHooksError;
}
interface ServiceEvent {
    name?: string;
    group?: string;
    params?: ActionParams;
    context?: boolean;
    debounce?: number;
    throttle?: number;
    handler?: ServiceEventHandler | ServiceEventLegacyHandler;
}
type ServiceEvents<S = ServiceSettingSchema> = {
    [key: string]: ServiceEventHandler | ServiceEventLegacyHandler | ServiceEvent;
} & ThisType<Service<S>>;
type ServiceSyncLifecycleHandler<S = ServiceSettingSchema> = (this: Service<S>) => void;
type ServiceAsyncLifecycleHandler<S = ServiceSettingSchema> = (this: Service<S>) => void | Promise<void>;
interface ServiceSchema<S = ServiceSettingSchema> {
    name: string;
    version?: string | number;
    settings?: S;
    dependencies?: string | ServiceDependency | (string | ServiceDependency)[];
    metadata?: any;
    actions?: ServiceActionsSchema;
    mixins?: Partial<ServiceSchema>[];
    methods?: ServiceMethods;
    hooks?: ServiceHooks;
    events?: ServiceEvents;
    created?: ServiceSyncLifecycleHandler<S> | ServiceSyncLifecycleHandler<S>[];
    started?: ServiceAsyncLifecycleHandler<S> | ServiceAsyncLifecycleHandler<S>[];
    stopped?: ServiceAsyncLifecycleHandler<S> | ServiceAsyncLifecycleHandler<S>[];
    [name: string]: any;
}

type ServiceAction = <T = Promise<any>, P extends GenericObject = GenericObject>(params?: P, options?: CallingOptions) => T;
interface ServiceActions {
    [name: string]: ServiceAction;
}
interface ServiceSearchObj {
    name: string;
    version?: string | number;
}

declare class Service<S = ServiceSettingSchema> {
    star: Star;
    fullName: string;
    name: string;
    version: string | number;
    settings?: ServiceSettingSchema | GenericObject;
    schema?: ServiceSchema<S>;
    metadata: GenericObject;
    logger: LoggerInstance | null;
    actions: ServiceActions | null;
    events: any;
    originalSchema: ServiceSchema<S> | null;
    dependencies: string | ServiceDependency | (string | ServiceDependency)[] | null;
    _serviceSpecification: GenericObject;
    constructor(star: Star, schema?: ServiceSchema<S>, schemaMods?: any);
    static getVersionedFullName(name: string, version?: string | number): string;
    private parseServiceSchema;
    private _validateAndPreprocessSchema;
    private _initializeServiceProperties;
    private _createServiceSpecification;
    private _registerServiceMethods;
    private _validateMethodName;
    private _registerServiceActions;
    private _registerServiceEvents;
    applyMixins(schema: ServiceSchema | Partial<ServiceSchema<ServiceSettingSchema>>): any;
    _init(): void;
    _start(): Promise<void>;
    _stop(): Promise<void>;
    private _cleanupServiceResources;
    _createMethod(methodDef: any, name: string): any;
    private _parseMethodDefinition;
    private _validateMethodDefinition;
    private _configureMethodProperties;
    _createAction(actionDef: any, name: string): GenericObject;
    private _parseActionDefinition;
    private _validateActionDefinition;
    private _configureActionProperties;
    _createEvent(eventDef: any, name: string): GenericObject;
    private _parseEventDefinition;
    private _validateEventDefinition;
    private _processEventHandler;
    private _configureEventProperties;
    _getPublishSettings(settings?: GenericObject): _.Omit<GenericObject, any> | undefined;
    mergeSchemas(mixinSchema: any, serviceSchema: any): any;
    mergeSchemaSettings(src: GenericObject, target: GenericObject): any;
    mergeSchemaMetadata(src: GenericObject, target: GenericObject): any;
    mergeSchemaUniqArray(src: GenericObject, target: GenericObject): any[];
    mergeSchemaDependencies(src: GenericObject, target: GenericObject): any[];
    mergeSchemaHooks(src: GenericObject, target: GenericObject): GenericObject;
    mergeSchemaActions(src: GenericObject, target: GenericObject): GenericObject;
    mergeSchemaMethods(src: GenericObject, target: GenericObject): GenericObject;
    mergeSchemaEvents(src: GenericObject, target: GenericObject): void;
    mergeSchemaLifecycleHandlers(src: GenericObject, target: GenericObject): any[];
    mergeSchemaUnkown(src: GenericObject, target: GenericObject): GenericObject;
    waitForServices(serviceNames: string | string[], timeout: number, interval: number): Promise<{
        services: string[];
        statuses: any[];
    }>;
    emitLocalEventHandler(eventName: string, params?: any, options?: GenericObject): any;
}

interface RestSchema {
    path?: string;
    method?: 'GET' | 'POST' | 'DELETE' | 'PUT' | 'PATCH';
    fullPath?: string;
    basePath?: string;
}
type ActionVisibility = 'published' | 'public' | 'protected' | 'private';
type ActionHandler<T = any> = (ctx: Context) => Promise<T> | T;
type ActionParamSchema = {
    [key: string]: any;
};
type ActionParamTypes = 'any' | 'array' | 'boolean' | 'custom' | 'date' | 'email' | 'enum' | 'forbidden' | 'function' | 'number' | 'object' | 'string' | 'url' | 'uuid' | boolean | string | ActionParamSchema;
type ActionParams = {
    [key: string]: ActionParamTypes;
};
type FallbackHandler = (ctx: Context, err: UniverseError) => Promise<any>;
type FallbackResponse$1 = string | number | GenericObject;
type FallbackResponseHandler$1 = (ctx: Context, err: UniverseError) => Promise<any>;
interface ActionSchema {
    name?: string;
    rest?: RestSchema | RestSchema[] | string | string[];
    visibility?: ActionVisibility;
    params?: ActionParams;
    service?: Service;
    cache?: boolean | ActionCacheOptions;
    handler?: ActionHandler;
    tracing?: boolean | TracingActionOptions;
    bulkhead?: BulkheadOptions;
    circuitBreaker?: StarCircuitBreakerOptions;
    retryPolicy?: RetryPolicyOptions;
    fallback?: string | FallbackHandler;
    hooks?: ActionHooks;
    [key: string]: any;
}
type CheckRetryable = (err: UniverseError | Error) => boolean;
interface BulkheadOptions {
    enabled?: boolean;
    concurrency?: number;
    maxQueueSize?: number;
}
interface StarCircuitBreakerOptions {
    enabled?: boolean;
    threshold?: number;
    windowTime?: number;
    minRequestCount?: number;
    halfOpenTime?: number;
    check?: CheckRetryable;
}
interface RetryPolicyOptions {
    enabled?: boolean;
    retries?: number;
    delay?: number;
    maxDelay?: number;
    factor?: number;
    check?: CheckRetryable;
}
type ActionHookBefore = (ctx: Context) => Promise<void> | void;
type ActionHookAfter = (ctx: Context, res: any) => Promise<any> | any;
type ActionHookError = (ctx: Context, err: Error) => Promise<void> | void;
interface ActionHooks {
    before?: string | ActionHookBefore | (string | ActionHookBefore)[];
    after?: string | ActionHookAfter | (string | ActionHookAfter)[];
    error?: string | ActionHookError | (string | ActionHookError)[];
}
interface ContextParentSpan$1 {
    id: string;
    traceID: string;
    sampled: boolean;
}
interface CallingOptions {
    timeout?: number | null;
    retries?: number | null;
    fallbackResponse?: FallbackResponse$1 | FallbackResponse$1[] | FallbackResponseHandler$1;
    nodeID?: string;
    meta?: GenericObject;
    parentSpan?: ContextParentSpan$1;
    parentCtx?: Context;
    requestID?: string;
    tracking?: boolean;
    paramsCloning?: boolean;
    caller?: string;
    ctx?: Context;
}

declare class LoggerFactory {
    star: Star;
    options: any;
    appenders: any[];
    cache: Map<any, any>;
    constructor(star: Star);
    init(options: LogLevelConfig | LogLevelConfig[] | boolean | null): void;
    stop(): any;
    getCallerFromStack(): {
        filename: any;
        lineNumber: any;
        columnNumber: any;
        methodName: any;
        functionName: any;
    } | undefined;
    getBindingsKey(bindings: LoggerBindings): string;
    getLogger(bindings: LoggerBindings): any;
}

declare class BaseLogger {
    options: GenericObject;
    Promise: any;
    loggerFactory: any;
    star: any;
    constructor(options: GenericObject);
    init(loggerFactory: LoggerFactory): void;
    stop(): Promise<void>;
    getLogLevel(mod: string): BaseLoggerLevels | null;
    getLogHandler(bindings: GenericObject): null;
}

interface DiscovererOptions extends GenericObject {
    heartbeatInterval?: number;
    heartbeatTimeout?: number;
    disableHeartbeatChecks?: boolean;
    disableOfflineNodeRemoving?: boolean;
    cleanOfflineNodesTimeout?: number;
}
declare class Discoverer extends BaseDiscoverer {
}

declare enum PacketTypes {
    PACKET_UNKNOWN = "???",
    PACKET_EVENT = "EVENT",
    PACKET_REQUEST = "REQ",
    PACKET_RESPONSE = "RES",
    PACKET_DISCOVER = "DISCOVER",
    PACKET_INFO = "INFO",
    PACKET_DISCONNECT = "DISCONNECT",
    PACKET_HEARTBEAT = "HEARTBEAT",
    PACKET_PING = "PING",
    PACKET_PONG = "PONG",
    PACKET_GOSSIP_REQ = "GOSSIP_REQ",
    PACKET_GOSSIP_RES = "GOSSIP_RES",
    PACKET_GOSSIP_HELLO = "GOSSIP_HELLO"
}
interface PacketPayload {
    version?: string;
    sender?: string | null;
    event?: any;
    action?: any;
    groups?: any;
    host?: string;
    port?: number;
    online?: any;
    offline?: any;
}

declare class Packet {
    type: PacketTypes;
    target: any;
    payload: GenericObject | PacketPayload;
    services: any;
    config: any;
    metadata: any;
    meta: any;
    error: any;
    online: any;
    offline: any;
    dataType: any;
    params: any;
    paramsType: any;
    constructor(type: PacketTypes, target?: any, payload?: GenericObject | PacketPayload);
}

interface TransitRequest {
    action?: any;
    nodeID?: string;
    ctx?: Context;
    resolve: (value: any) => void;
    reject: (reason: any) => void;
    stream?: boolean;
}
interface StarTransitOptions {
    maxQueueSize?: number;
    disableReconnect?: boolean;
    disableVersionCheck?: boolean;
    maxChunkSize?: number;
}

declare class Transporter {
    hasBuiltInBalancer: boolean;
    connected: boolean;
    constructor(opts?: GenericObject);
    init(transit: Transit, messageHandler: (cmd: string, msg: string) => void, afterConnect: (wasReconnect: boolean) => void): void;
    connect(): Promise<any>;
    disconnect(): Promise<any>;
    onConnected(wasReconnect?: boolean): Promise<any>;
    makeSubscriptions(topics: GenericObject[]): Promise<void>;
    subscribe(cmd: string, nodeID?: string): Promise<void>;
    subscribeBalancedRequest(action: string): Promise<void>;
    subscribeBalancedEvent(event: string, group: string): Promise<void>;
    unsubscribeFromBalancedCommands(): Promise<void>;
    incomingMessage(cmd: string, msg: Buffer): Promise<void>;
    receive(cmd: string, data: Buffer): Promise<void>;
    prepublish(packet: Packet): Promise<void>;
    publish(packet: Packet): Promise<void>;
    publishBalancedEvent(packet: Packet, group: string): Promise<void>;
    publishBalancedRequest(packet: Packet): Promise<void>;
    send(topic: string, data: Buffer, meta: GenericObject): Promise<void>;
    getTopicName(cmd: string, nodeID?: string): string;
    makeBalancedSubscriptions(): Promise<void>;
    serialize(packet: Packet): Buffer | null;
    deserialize(type: string, data: Buffer): Packet | null;
}

declare class Node {
    id: string;
    instanceID: string | null;
    available: boolean;
    local: boolean;
    lastHeartbeatTime: number;
    config: GenericObject;
    client: GenericObject;
    metadata: any;
    ipList: any;
    port: number | null;
    hostname: string | null;
    udpAddress: string | null;
    rawInfo: any;
    services: Array<any>;
    cpu: any;
    cpuSeq: any;
    seq: number;
    offlineSince: any;
    constructor(id: string);
    update(payload: GenericObject, isReconnected: boolean): true | undefined;
    updateLocalInfo(cpuUsage: any): Promise<any>;
    heartbeat(payload: GenericObject): void;
    disconnected(): void;
}

declare class Transit {
    star: Star;
    logger: LoggerInstance;
    nodeID: string;
    instanceID: string;
    transporter: Transporter;
    options: StarTransitOptions | undefined;
    discoverer: Discoverer | null;
    metrics: MetricRegistry | null;
    errorRegenerator: Regenerator | null;
    pendingRequests: Map<any, TransitRequest>;
    pendingReqStreams: Map<any, any>;
    pendingResStreams: Map<any, any>;
    private maxPendingRequests;
    private maxStreamPoolSize;
    private cleanupInterval;
    connected: boolean;
    disconnecting: boolean;
    isReady: boolean;
    stat: GenericObject;
    subscribing: Promise<any> | null;
    __connectResolve: any;
    constructor(star: Star, transporter: Transporter, options?: StarTransitOptions);
    private registerUniverseMetrics;
    afterConnect(wasReconnect: boolean): Promise<null | undefined>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    ready(): void;
    sendDisconnectPacket(): Promise<void>;
    makeSubscriptions(): Promise<any>;
    messageHandler(cmd: string, msg: GenericObject): Promise<boolean> | undefined;
    private requestHandler;
    responseHandler(packet: GenericObject): void;
    sendPing(nodeID?: string, id?: string): Promise<void>;
    sendPong(payload: GenericObject): Promise<void>;
    processPong(payload: GenericObject): void;
    sendResponse(nodeID: string, id: string, meta: any, data: any, error: Error | null): Promise<void>;
    eventHandler(payload: GenericObject): Promise<boolean>;
    subscribe(topic: string, nodeID: string): Promise<void>;
    publish(packet: Packet): Promise<void>;
    sendHeartbeat(localNode: Node): Promise<void>;
    sendEvent(ctx: Context): Promise<void>;
    removePendingRequestByNodeID(nodeID: string): void;
    request(ctx: Context): Promise<unknown>;
    _sendRequest(ctx: Context, resolve: any, reject: any): Promise<void>;
    _createPayloadErrorField(error: any, payload: any): {
        name: any;
        message: any;
        nodeID: any;
        code: any;
        type: any;
        retryable: any;
        stack: any;
        data: any;
    } | undefined;
    sendNodeInfo(info: any, nodeID: string): Promise<void>;
    private _handleIncomingRequestStream;
    private _handleIncomingResponseStream;
    private _createErrorFromPayload;
    removePendingRequest(id: any): void;
    private handleTransitError;
    private startCleanupTimer;
    private stopCleanupTimer;
    private cleanupExpiredRequests;
    discoverNodes(): Promise<void>;
    discoverNode(nodeID: string): Promise<void>;
}

declare class BaseDiscoverer {
    options: DiscovererOptions;
    heartbeatTimer: NodeJS.Timeout | null;
    checkNodesTimer: NodeJS.Timeout | null;
    offlineTimer: NodeJS.Timeout | null;
    localNode: Node | null;
    star: Star | null;
    registry: Registry | null;
    logger: LoggerInstance | null;
    transit: Transit | null;
    constructor(options?: DiscovererOptions);
    init(registry: Registry): void;
    startHeartbeatTimers(): void;
    stopHeartbeatTimers(): void;
    stop(): Promise<void>;
    registerUniverseMetrics(): void;
    beat(): Promise<void> | undefined;
    checkRemoteNodes(): void;
    checkOfflineNodes(): void;
    heartbeatReceived(nodeID: string, payload: any): void;
    sendHeartbeat(): Promise<void>;
    processRemoteNodeInfo(nodeID: string, payload: any): Node | null;
    localNodeDisconnected(): Promise<void>;
    remoteNodeDisconnected(nodeID: string, isUnexpected: boolean): void | undefined;
    discoverNode(nodeID?: string): Promise<any>;
    discoverAllNodes(): Promise<any>;
    sendLocalNodeInfo(nodeID?: string): Promise<void>;
    disableHeartbeat(): void;
}

interface StarRegistryOptions {
    strategy?: Function | string;
    strategyOptions?: GenericObject;
    preferLocal?: boolean;
    discoverer?: RegistryDiscovererOptions | BaseDiscoverer | string;
    stopDelay?: number;
}
interface RegistryDiscovererOptions {
    type: string;
    options: DiscovererOptions;
}

declare class Serialize {
    constructor(options: any);
    init(star: Star): void;
    serialize(obj: GenericObject, type?: string): Buffer | void;
    deserialize(buf: Buffer, type?: string): GenericObject | void;
}

type CallMiddlewareHandler = {
    actionName: string;
    params: any;
    options: CallingOptions;
};
type Middleware = {
    [name: string]: ((handler: ActionHandler, action: ActionSchema) => any) | ((handler: ActionHandler, event: ServiceEvent$1) => any) | ((handler: ActionHandler) => any) | ((service: Service) => any) | ((star: Star) => any) | ((handler: CallMiddlewareHandler) => CallMiddlewareHandler);
};

declare class BaseValidator {
    options: GenericObject;
    star: Star | null;
    constructor(options: GenericObject);
    init(star: Star): void;
    compile(schema: any): void;
    validate(params: any, schema: any): void;
    convertSchemaToUniverse(schema: any): void;
    middleware(star: Star): {
        name: string;
        localAction: (handler: ActionHandler, action: ActionSchema) => ActionHandler;
        localEvent: (handler: ActionHandler, event: EventSchema) => ActionHandler;
    };
}

interface StarOptions {
    namespace?: string | null;
    nodeID?: string | null;
    metadata?: GenericObject;
    logger?: BaseLogger | LogLevelConfig | LogLevelConfig[] | boolean | null;
    logLevel?: BaseLoggerLevels | LogLevelConfig | null;
    registry?: StarRegistryOptions;
    contextParamsCloning?: boolean;
    maxCallLevel?: number;
    heartbeatInterval?: number;
    heartbeatTimeout?: number;
    transporter?: Transporter | string | GenericObject | null;
    transit?: StarTransitOptions;
    serializer?: Serialize | string | GenericObject | null;
    errorRegenerator?: Regenerator | null;
    uidGenerator?: () => string;
    errorHandler?: ((err: Error, info: any) => void) | null;
    Promise?: PromiseConstructorLike;
    ContextFactory?: Context;
    requestTimeout?: number;
    retryPolicy?: RetryPolicyOptions;
    tracking?: StarTrackingOptions;
    disableBalancer?: boolean;
    circuitBreaker?: StarCircuitBreakerOptions;
    bulkhead?: BulkheadOptions;
    cacher?: boolean | Cacher | string | GenericObject | null;
    validator?: boolean | BaseValidator | ValidatorNames | ValidatorOptions | null;
    metrics?: boolean | MetricRegistryOptions;
    tracing?: boolean | TracerOptions;
    internalServices?: boolean | {
        [key: string]: Partial<ServiceSchema>;
    };
    internalMiddlewares?: boolean;
    dependencyInterval?: number;
    dependencyTimeout?: number;
    hotReload?: boolean | HotReloadOptions;
    middlewares?: (Middleware | string)[];
    replCommands?: GenericObject[] | null;
    replDelimiter?: string;
    ServiceFactory?: Service;
    created?: StarSyncLifecyleHandler;
    started?: StarAsyncLifecyleHandler;
    stopped?: StarAsyncLifecyleHandler;
    skipProcessEventRegistration?: boolean;
    maxSafeObjectSize?: number;
}
interface HotReloadOptions {
    modules?: string[];
}
type StarAsyncLifecyleHandler = (star: Star) => void;
type StarSyncLifecyleHandler = (star: Star) => void | Promise<void>;
type FallbackResponse = string | number | GenericObject;
type FallbackResponseHandler = (ctx: Context, err: UniverseError) => Promise<any>;
interface ContextParentSpan {
    id: string;
    traceID: string;
    sampled: boolean;
}
interface CallCallingOptions {
    timeout?: number;
    retries?: number;
    fallbackResponse?: FallbackResponse | FallbackResponse[] | FallbackResponseHandler;
    nodeID?: string;
    meta?: GenericObject;
    parentSpan?: ContextParentSpan;
    parentCtx?: Context;
    requestID?: string;
    tracking?: boolean;
    paramsCloning?: boolean;
    caller?: string;
}
interface MCallCallingOptions extends CallCallingOptions {
    settled?: boolean;
}
interface StarCallActionParams<P extends GenericObject = GenericObject> {
    action: string;
    params?: P;
}
interface StarMCallActionParams<P extends GenericObject = GenericObject> extends StarCallActionParams {
    options?: CallCallingOptions;
}
interface ValidatorOptions {
    type: string;
    options?: GenericObject;
}
type ValidatorNames = 'Fastest';

declare class Context {
    id: string;
    star: Star;
    nodeID: string | null;
    endpoint: Endpoint | null;
    action: ActionSchema | null;
    service: Service | null;
    event: EventSchema | null;
    eventName: string | null;
    eventType: string | null;
    eventGroups: string[] | null;
    options: CallingOptions;
    parentID: string | null;
    caller: string | null;
    tracing: boolean | null;
    span: Span | null;
    _spanStack: Span[];
    needAck: boolean | null;
    ackID: string | null;
    locals: GenericObject;
    level: number;
    params: any;
    meta: GenericObject;
    requestID: string | null;
    cachedResult: boolean;
    starHrTime: any;
    constructor(star: Star, endpoint?: Endpoint);
    static create(star: Star, endpoint: Endpoint, params?: GenericObject, options?: GenericObject): Context;
    copy(endpoint?: Endpoint): Context;
    setParams(newParams: GenericObject, cloning?: boolean): void;
    setEndpoint(endpoint: Endpoint): void;
    call(actionName: string, params?: GenericObject, options?: GenericObject): Promise<any>;
    mcall(def: Array<StarMCallActionParams> | Record<string, StarMCallActionParams>, opts?: MCallCallingOptions): Promise<any[] | GenericObject>;
    emit(eventName: string, data?: any, options?: GenericObject): Promise<any[]> | Promise<void> | undefined;
    broadcast(eventName: string, data?: any, options?: GenericObject): Promise<any[]> | undefined;
    setContextEventData(options: {
        eventName?: string;
        eventType?: string;
        eventGroups?: string[];
    }): void;
    startSpan(name: string, opts?: GenericObject): any;
    finishSpan(span: Span, time?: number): void;
    toJSON(): Partial<this>;
    [util.inspect.custom](depth: number, options: any): any;
}

declare class BaseStrategy {
    registry: Registry;
    star: Star;
    options: GenericObject;
    constructor(registry: Registry, star: Star, options?: GenericObject);
    select(list: Endpoint[], ctx?: Context): Endpoint;
}

declare class ServiceItem {
    node: Node;
    name: string;
    fullName: string;
    version: string | number;
    settings?: ServiceSettingSchema;
    metadata: GenericObject;
    local: boolean;
    actions: any;
    events: any;
    dependencies: any;
    constructor(node: Node, service: Service, local: boolean);
    equals(fullName: string, nodeID?: string): boolean;
    update(service: Service): void;
    addAction(action: any): void;
    addEvent(e