import { Context, WebSocketSession, HttpSession, Geo } from '@based/functions';
import type { ActiveObservable } from './query/index.js';
import uws from '@based/uws';
import { BasedFunctions, FunctionConfig } from './functions/index.js';
import { BasedAuth, AuthConfig } from './auth/index.js';
import { BasedErrorCode, BasedErrorData } from '@based/errors';
import { BasedServerFunctionClient } from './functionApi/index.js';
import { ActiveChannel } from './channel/index.js';
import util from 'node:util';
type EventMap = {
    error: BasedErrorData | BasedErrorCode;
    ratelimit: void;
    log: any;
};
type Event = keyof EventMap;
type Listener<T> = (context: Context, data?: T, err?: Error | string) => void;
type RateLimit = {
    ws: number;
    http: number;
    drain: number;
};
type GetIp = (res: uws.HttpResponse, req: uws.HttpRequest) => string;
type QueryEvents = {
    subscribe: (obs: ActiveObservable, ctx?: Context<WebSocketSession>) => void;
    unsubscribe: (obs: ActiveObservable, ctx?: Context<WebSocketSession>) => void;
    get: (obs: ActiveObservable, ctx?: Context<WebSocketSession | HttpSession>) => void;
};
type ChannelEvents = {
    subscribe: (obs: ActiveChannel, ctx?: Context<WebSocketSession>) => void;
    unsubscribe: (obs: ActiveChannel, ctx?: Context<WebSocketSession>) => void;
};
export type ServerOptions = {
    clients?: {
        [key: string]: any;
    };
    port?: number;
    key?: string;
    geo?: (ctx: Context) => Geo;
    disableRest?: boolean;
    disableWs?: boolean;
    silent?: boolean;
    cert?: string;
    functions?: FunctionConfig;
    rateLimit?: RateLimit;
    client?: (server: BasedServer) => BasedServerFunctionClient;
    auth?: AuthConfig;
    query?: QueryEvents;
    channel?: ChannelEvents;
    ws?: {
        maxBackpressureSize?: number;
        open?: (client: Context<WebSocketSession>) => void;
        close?: (client: Context<WebSocketSession>) => void;
    };
    http?: {
        open?: (client: Context<HttpSession>) => void;
        close?: (client: Context<HttpSession>) => void;
    };
    getIp?: GetIp;
    console?: Console;
};
/**
Based server

```js
const server = new BasedServer({
  port: 9910,
  functions: {
    configs: {
      hello: {
        type: 'function',
        fn: async () => 'hello'
      },
      counter: {
        type: 'query',
        fn: () => () => {}
      }
    }
  }
})

server.functions.add({
  hello: { type: 'function', fn: async () => 'hello' }
})

server.functions.addRoutes({
  bla: { type: 'query' }
})

await server.start()
```
*/
export declare class BasedServer {
    console: Console;
    clients: {
        [key: string]: any;
    };
    client: BasedServerFunctionClient;
    functions: BasedFunctions;
    auth: BasedAuth;
    port: number;
    uwsApp: uws.TemplatedApp;
    silent: boolean;
    queryEvents: QueryEvents;
    channelEvents: ChannelEvents;
    rateLimit: RateLimit;
    listenSocket: any;
    forceReloadLastSeqId: number;
    encodedForceReload: Uint8Array;
    sendInitialForceReload: boolean;
    forceReloadTimer: ReturnType<typeof setTimeout>;
    forceReload(type?: number, validTime?: number): void;
    geo: (ctx: Context) => Geo;
    getIp: GetIp;
    blockedIps: Set<string>;
    allowedIps: Set<string>;
    rateLimitCounter: Map<string, {
        requests: number;
        errors?: Map<BasedErrorCode, number>;
    }>;
    requestsCounterInProgress: boolean;
    requestsCounterTimeout: NodeJS.Timeout;
    obsCleanTimeout: NodeJS.Timeout;
    obsCleanupCycle: number;
    activeObservables: {
        [name: string]: Map<number, ActiveObservable>;
    };
    activeObservablesById: Map<number, ActiveObservable>;
    channelCleanTimeout: NodeJS.Timeout;
    channelCleanupCycle: number;
    restFallbackPath: string;
    activeChannels: {
        [name: string]: Map<number, ActiveChannel>;
    };
    activeChannelsById: Map<number, ActiveChannel>;
    listeners: {
        [E in Event]?: Listener<EventMap[E]>[];
    };
    workerRequest: (type: string, payload?: any) => void | Promise<any>;
    private http;
    [util.inspect.custom](): string;
    constructor(opts: ServerOptions);
    emit(type: Event, client: Context, val: EventMap[Event], err?: Error | string): void;
    on(type: Event, fn: Listener<EventMap[Event]>): void;
    removeAllListeners(): void;
    once(type: Event, fn: Listener<EventMap[Event]>): void;
    off(type: Event, fn: Listener<EventMap[Event]>): void;
    start(port?: number, sharedSocket?: boolean): Promise<BasedServer>;
    destroy(): Promise<void>;
}
export {};