# API `@deepkit/rpc`

```shell
npm install @deepkit/rpc
```

## API reference of @deepkit/rpc

### RpcControllerState (class)

```typescript
export class RpcControllerState {
    peerId?: string;
    constructor(public controller: string);
    getState(method: string): ControllerStateActionState;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/action.ts#L54

### RpcActionClient (class)

```typescript
export class RpcActionClient {
    entityState;
    constructor(protected client: WritableClient);
    action<T>(controller: RpcControllerState, method: string, args: any[], options: {
        timeout?: number;
        dontWaitForConnection?: true;
        typeReuseDisabled?: boolean;
    } = {});
    async loadActionTypes(controller: RpcControllerState, method: string, options: {
        timeout?: number;
        dontWaitForConnection?: true;
        typeReuseDisabled?: boolean;
    } = {}): Promise<ControllerStateActionTypes>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/action.ts#L477

### DirectClient (class)

```typescript
export class DirectClient extends RpcClient {
    constructor(rpcKernel: RpcKernel, injector?: InjectorContext);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-direct.ts#L16

### RpcDirectClientAdapter (class)

```typescript
export class RpcDirectClientAdapter implements ClientTransportAdapter {
    constructor(public rpcKernel: RpcKernel, protected injector?: InjectorContext);
    async connect(connection: TransportClientConnection);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-direct.ts#L22

### AsyncDirectClient (class)

This direct client includes in each outgoing/incoming message an async hop making
the communication asynchronous.

```typescript
export class AsyncDirectClient extends RpcClient {
    constructor(rpcKernel: RpcKernel, injector?: InjectorContext);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-direct.ts#L61

### RpcAsyncDirectClientAdapter (class)

```typescript
export class RpcAsyncDirectClientAdapter implements ClientTransportAdapter {
    constructor(public rpcKernel: RpcKernel, protected injector?: InjectorContext);
    async connect(connection: TransportClientConnection);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-direct.ts#L67

### webSocketFromBaseUrl (function)

Returns the WebSocket URL for the given base URL and allows port mapping.
Default port-mapping maps Angular server :4200 to :8080

```typescript
(baseUrl: string, portMapping?: { [name: number]: number; }): string
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-websocket.ts#L43

### provideRpcWebSocketClient (function)

Creates a provider for RpcWebSocketClient that is compatible with Angular and Deepkit.
baseUrl needs to be absolute.

```typescript
(baseUrl?: string, portMapping?: { [name: number]: number; }): { provide: typeof RpcWebSocketClient; useFactory: () => RpcWebSocketClient; }
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-websocket.ts#L55

### RpcWebSocketClient (class)

A RpcClient that connects via WebSocket transport.

```typescript
export class RpcWebSocketClient extends RpcClient {
    constructor(url: string);
    static fromCurrentHost<T extends ClassType<RpcClient>>(this: T, baseUrl: string = ): InstanceType<T>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-websocket.ts#L21

### DeepkitClient (class)

```typescript
export class DeepkitClient extends RpcWebSocketClient {
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-websocket.ts#L36

### RpcWebSocketClientAdapter (class)

```typescript
export class RpcWebSocketClientAdapter implements ClientTransportAdapter {
    constructor(public url: string, protected webSocketConstructor: typeof WebSocket = WebSocket);
    async getWebSocketConstructor(): Promise<typeof WebSocket>;
    async connect(connection: TransportClientConnection);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client-websocket.ts#L65

### OfflineError (error)

```typescript
export class OfflineError extends CustomError {
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L40

### RemoteController (type)

```typescript
type RemoteController<T> = {
    [P in keyof T]: T[P] extends (...args: any[]) => any ? PromisifyFn<T[P]> : never
};
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L44

### ClientTransportAdapter (type)

```typescript
interface ClientTransportAdapter {
    connect(connection: TransportClientConnection): Promise<void> | void;

    /**
     * Whether ClientId call is needed to get a client id.
     * This is disabled for http adapter.
     */
    supportsPeers?(): boolean;

    /**
     * Whether Authentication call is needed to authenticate the client.
     * This is disabled for http adapter (Authorization header is used).
     */
    supportsAuthentication?(): boolean;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L48

### WritableClient (type)

```typescript
interface WritableClient {
    clientStats: RpcStats;

    sendMessage<T>(
        type: number,
        body?: T,
        receiveType?: ReceiveType<T>,
        options?: {
            dontWaitForConnection?: boolean,
            connectionId?: number,
            peerId?: string,
            timeout?: number
        },
    ): RpcMessageSubject;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L64

### RpcClientToken (class)

```typescript
export class RpcClientToken {
    constructor(protected token: any);
    get();
    set(v: any);
    has();
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L80

### RpcClientTransporter (class)

```typescript
export class RpcClientTransporter {
    connectionId: number;
    writerOptions: TransportOptions;
    id?: Uint8Array;
    /**
     * When the connection is established (including handshake and authentication).
     */
    readonly connection;
    /**
     * When the connection was reconnected. This is not called for the very first connection.
     */
    readonly reconnected;
    /**
     * When the connection was disconnected (due to error or close).
     * This increases the connectionId by one.
     */
    readonly disconnected;
    /**
     * Triggered for any onError call from the transporter.
     * Right after this event, onDisconnect is called (and thus connection.next(false) and disconnected.next()).
     */
    readonly errored;
    reader;
    constructor(public transport: ClientTransportAdapter, protected stats: RpcStats);
    bufferedAmount(): number;
    clientAddress(): string;
    /**
     * True when fully connected (after successful handshake and authentication)
     */
    isConnected(): boolean;
    onClose(error?: Error);
    /**
     * Optional handshake.
     * When peer messages are allowed, this needs to request the client id and returns id.
     */
    async onHandshake(): Promise<Uint8Array | undefined>;
    async onAuthenticate(token?: any): Promise<void>;
    onMessage(message: RpcMessage);
    async disconnect();
    /**
     * Simply connect with login using the token, without auto re-connect.
     */
    async connect(token?: any): Promise<void>;
    send(message: RpcMessageDefinition, progress?: SingleProgress);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L97

### RpcClientPeer (class)

```typescript
export class RpcClientPeer {
    constructor(protected actionClient: RpcActionClient, protected peerId: string, protected onDisconnect: (peerId: string) => void);
    controller<T>(nameOrDefinition: string | ControllerDefinition<T>, options: {
        timeout?: number;
        dontWaitForConnection?: true;
    } = {}): RemoteController<T>;
    disconnect();
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L339

### RpcEventMessage (type)

```typescript
type RpcEventMessage = { id: number, date: Date, type: number, body: any };
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L370

### RpcClientEventIncomingMessage (type)

```typescript
type RpcClientEventIncomingMessage =
    { event: 'incoming', composite: boolean, messages: RpcEventMessage[] }
    & RpcEventMessage;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L371

### RpcClientEventOutgoingMessage (type)

```typescript
type RpcClientEventOutgoingMessage =
    { event: 'outgoing', composite: boolean, messages: RpcEventMessage[] }
    & RpcEventMessage;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L374

### RpcClientEvent (type)

```typescript
type RpcClientEvent = RpcClientEventIncomingMessage | RpcClientEventOutgoingMessage;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L378

### RpcBaseClient (class)

```typescript
export class RpcBaseClient implements WritableClient {
    clientStats: RpcStats;
    actionClient;
    readonly token;
    readonly transporter: RpcClientTransporter;
    username?: string;
    typeReuseDisabled: boolean;
    events;
    constructor(protected transport: ClientTransportAdapter);
    onClose(error?: Error);
    /**
     * Per default entity types with a name (@entity.name()) will be reused. If a entity with a given name
     * was not loaded and error is thrown. This to ensure nominal typing (object instanceof T).
     * Use this method to disable this behavior and construct new nominal types if an entity is not loaded.
     */
    disableTypeReuse(): this;
    getId(): Uint8Array;
    debug();
    sendMessage<T>(type: number, body?: T, schema?: ReceiveType<T>, options: {
        dontWaitForConnection?: boolean;
        connectionId?: number;
        peerId?: string;
        timeout?: number;
    } = {}): RpcMessageSubject;
    async connect(): Promise<this>;
    async disconnect();
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L380

### RpcClient (class)

```typescript
export class RpcClient extends RpcBaseClient {
    /**
     * For server->client (us) communication.
     * This is automatically created when registerController is called.
     * Set this property earlier to work with a custom RpcKernel.
     */
    clientKernel?: RpcKernel;
    /**
     * For peer->client(us) communication.
     * This is automatically created when registerAsPeer is called.
     * Set this property earlier to work with a custom RpcKernel.
     */
    peerKernel?: RpcKernel;
    async ping(): Promise<void>;
    getId(): Uint8Array;
    /**
     * Registers a new controller for the peer's RPC kernel.
     * Use `registerAsPeer` first.
     */
    registerPeerController<T>(classType: ClassType<T>, nameOrDefinition: string | ControllerDefinition<T>);
    /**
     * Registers a new controller for the server's RPC kernel.
     * This is when the server wants to communicate actively with the client (us).
     */
    registerController<T>(classType: ClassType<T>, nameOrDefinition: string | ControllerDefinition<T>);
    async registerAsPeer(id: string);
    /**
     * Creates a new peer connection, or re-uses an existing non-disconnected one.
     *
     * Make sure to call disconnect() on it once you're done using it, otherwise the peer
     * will leak memory. (connection will be dropped if idle for too long automatically tough)
     */
    peer(peerId: string): RpcClientPeer;
    controller<T>(nameOrDefinition: string | ControllerDefinition<T>, options: {
        timeout?: number;
        dontWaitForConnection?: true;
        typeReuseDisabled?: boolean;
    } = {}): RemoteController<T>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/client.ts#L581

### createRpcHttpClientProvider (function)

```typescript
(baseUrl?: string, headers?: { [name: string]: string; }, http?: RpcHttpInterface): { provide: typeof RpcClient; useFactory: () => RpcClient; }
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/http.ts#L56

### RpcHttpResponseInterface (type)

```typescript
interface RpcHttpResponseInterface {
    status: number;
    headers: { [name: string]: string };
    body?: any;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/http.ts#L10

### RpcHttpInterface (type)

```typescript
interface RpcHttpInterface {
    fetch(url: string, options: {
        headers: { [name: string]: string },
        method: string,
        body?: string
    }): Promise<RpcHttpResponseInterface>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/http.ts#L16

### RpcHttpFetch (class)

```typescript
export class RpcHttpFetch implements RpcHttpInterface {
    constructor(private baseUrl: string | ((url: string) => string) = );
    async fetch(url: string, options: {
        headers: {
            [name: string]: string;
        };
        method: string;
        body: any;
    }): Promise<RpcHttpResponseInterface>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/http.ts#L24

### RpcHttpClientAdapter (class)

```typescript
export class RpcHttpClientAdapter implements ClientTransportAdapter {
    constructor(public url: string, public headers: {
        [name: string]: string;
    } = {}, public http: RpcHttpInterface = new RpcHttpFetch());
    supportsPeers();
    supportsAuthentication();
    async connect(connection: TransportClientConnection): Promise<void>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/http.ts#L67

### RpcHttpHeaderNames (variable)

```typescript
string[]
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/http.ts#L155

### UnexpectedMessageType (error)

```typescript
export class UnexpectedMessageType extends CustomError {
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/message-subject.ts#L16

### RpcMessageSubject (class)

```typescript
export class RpcMessageSubject {
    /**
     * Releases this subject. It is necessary that eventually every created subject is released,
     * otherwise dramatic performance decrease and memory leak will happen.
     */
    constructor(private continuation: <T>(type: number, body?: T, schema?: ReceiveType<T>) => void, public release: () => void);
    /**
     * Called when the underlying transport disconnected.
     * This force-cleans everything up.
     */
    disconnect(error?: Error);
    next(next: RpcMessage);
    /**
     * Registers a callback that is called to handle unexpected rejections,
     * like disconnects, transport errors, or timeouts.
     */
    onRejected(callback: (error: any) => void): this;
    onReply(callback: (next: RpcMessage, subject: RpcMessageSubject) => void): this;
    /**
     * Sends a message to the server in the context of this created subject.
     * If the connection meanwhile has been reconnected, and completed MessageSubject.
     */
    send<T>(type: number, body?: T, schema?: ReceiveType<T>): this;
    /**
     * Waits for the Ack message from the server, then closes the subject.
     */
    async ackThenClose(): Promise<undefined>;
    /**
     * Wait for next message to arrive.
     */
    async waitNextMessage<T>(): Promise<RpcMessage>;
    /**
     * Wait for next message with body parse.
     */
    async waitNext<T>(type: number, schema?: ReceiveType<T>): Promise<T>;
    /**
     * Waits for the first message of a specific type, then closes the subject.
     */
    async firstThenClose<T = RpcMessage>(type: number, schema?: ReceiveType<T>): Promise<T>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/message-subject.ts#L21

### EntitySubjectStore (class)

```typescript
export class EntitySubjectStore<T extends IdVersionInterface> {
    store;
    onCreation;
    constructor(protected classType: ClassType);
    isRegistered(id: IdType): boolean;
    register(item: T): void;
    deregister(id: IdType): void;
    getItem(id: IdType): T | undefined;
    onDelete(id: IdType): void;
    onSet(id: IdType, item: T): void;
    onPatch(id: IdType, version: number, patch: EntityPatch): void;
    /**
     * Before calling createFork you must be sure the item is already registered.
     */
    createFork(id: IdType): EntitySubject<T>;
    getForkCount(id: IdType): number;
    getEntitySubjectCount(): number;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/entity-state.ts#L25

### EntityState (class)

```typescript
export class EntityState {
    getStore<T extends IdVersionInterface>(classType: ClassType<T>): EntitySubjectStore<T>;
    getStoreByName<T extends IdVersionInterface>(name: string): EntitySubjectStore<T>;
    createEntitySubject(classType: ClassType, bodySchema: TypeObjectLiteral, message: RpcMessage);
    /**
     * Handles the RpcType.Entity, which is a composite per default.
     */
    handle(entityMessage: RpcMessage);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/client/entity-state.ts#L160

### ActionTypes (type)

```typescript
type ActionTypes = {
    strictSerialization: boolean;
    actionCallSchema: TypeObjectLiteral, //with args as property
    parametersValidate: Guard<any>,

    parameters: TypeTuple,
    mode: ActionMode;
    type: Type; //the type T of Collection<T>, EntitySubject<T>, Observable<T>, or return type of the function if mode=arbitrary

    resultSchema: TypeObjectLiteral, //with v as property
    observableNextSchema?: TypeObjectLiteral, //with v as property
    collectionSchema?: Type, //with v as array property
    collectionQueryModel?: Type,

    noTypeWarned: boolean;
};
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/action.ts#L67

### RpcServerActionObservableSubject (type)

```typescript
interface RpcServerActionObservableSubject {
    subject: Subject<any>,
    trackingType: NumericKeys<ActionStats>,
    completed: boolean,
    completedByClient: boolean,
    subscription: Subscription
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/action.ts#L134

### RpcServerAction (class)

```typescript
export class RpcServerAction {
    constructor(protected stats: RpcStats, protected cache: RpcCache, protected connection: RpcKernelBaseConnection, protected controllers: Map<string, {
        controller: ClassType;
        module?: InjectorModule;
    }>, protected injector: InjectorContext, protected eventDispatcher: EventDispatcher, protected security: RpcKernelSecurity, protected sessionState: SessionState, protected logger: LoggerInterface);
    async handleActionTypes(message: RpcMessage, response: RpcMessageBuilder);
    async onClose();
    async handle(message: RpcMessage, response: RpcMessageBuilder);
    async handleAction(message: RpcMessage, response: RpcMessageBuilder);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/action.ts#L142

### RpcCompositeMessage (class)

```typescript
export class RpcCompositeMessage {
    strictSerialization: boolean;
    logValidationErrors: boolean;
    errorLabel: string;
    constructor(protected stats: RpcTransportStats, protected logger: Logger, public type: number, protected id: number, protected writer: TransportMessageWriter, protected transportOptions: TransportOptions, protected clientId?: Uint8Array, protected source?: Uint8Array, protected routeType: RpcMessageRouteType.client | RpcMessageRouteType.server = RpcMessageRouteType.client);
    add<T>(type: number, body?: T, receiveType?: ReceiveType<T>): this;
    write(message: RpcMessageDefinition): void;
    send();
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L44

### RpcMessageBuilder (class)

```typescript
export class RpcMessageBuilder {
    routeType: RpcMessageRouteType.client | RpcMessageRouteType.server;
    strictSerialization: boolean;
    logValidationErrors: boolean;
    errorLabel: string;
    constructor(protected stats: RpcTransportStats, protected logger: Logger, protected writer: TransportMessageWriter, protected transportOptions: TransportOptions, protected id: number, protected clientId?: Uint8Array, protected source?: Uint8Array);
    write(message: RpcMessageDefinition): void;
    ack(): void;
    error(error: Error | string): void;
    reply<T>(type: number, body?: T, receiveType?: ReceiveType<T>): void;
    /**
     * @deprecated
     */
    replyBinary<T>(type: number, body?: Uint8Array): void;
    composite(type: number): RpcCompositeMessage;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L93

### RpcPeerExchange (class)

This is a reference implementation and only works in a single process.
A real-life implementation would use an external message-bus, like Redis & co.

```typescript
export class RpcPeerExchange {
    async isRegistered(id: string): Promise<boolean>;
    async deregister(id: string | Uint8Array): Promise<void>;
    register(id: string | Uint8Array, writer: TransportConnection): void;
    redirect(message: RpcMessage);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L170

### RpcKernelBaseConnection (class)

```typescript
export abstract class RpcKernelBaseConnection {
    sessionState;
    writer: TransportMessageWriter;
    /**
     * Statistics about the server->client communication.
     */
    clientStats: RpcStats;
    transportOptions: TransportOptions;
    readonly onClose: Promise<void>;
    closed: boolean;
    constructor(public stats: RpcStats, protected logger: Logger, public transportConnection: TransportConnection, protected connections: RpcKernelConnections, protected injector: InjectorContext, protected eventDispatcher: EventDispatcher);
    write(message: RpcMessageDefinition): void;
    /**
     * Serializes the message (binary) and sends it to the client using
     * a chunk writer (splitting the message into smaller parts if necessary,
     * so they can be tracked).
     */
    sendBinary(message: RpcMessageDefinition, writer: RpcBinaryWriter): void;
    clientAddress(): string | undefined;
    createMessageBuilder(): RpcMessageBuilder;
    /**
     * Creates a regular timer using setTimeout() and automatically cancel it once the connection breaks or server stops.
     */
    setTimeout(cb: () => void, timeout: number): any;
    close(reason: string | Error = ): void;
    feed(buffer: Uint8Array, bytes?: number): void;
    handleMessage(message: RpcMessage): void;
    onRequest(basePath: string, request: RpcHttpRequest, response: RpcHttpResponse): void | Promise<void>;
    abstract onMessage(message: RpcMessage, response: RpcMessageBuilder): void | Promise<void>;
    controller<T>(nameOrDefinition: string | ControllerDefinition<T>, timeoutInSeconds = ): RemoteController<T>;
    sendMessage<T>(type: number, body?: T, receiveType?: ReceiveType<T>): RpcMessageSubject;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L213

### RpcKernelConnections (class)

```typescript
export class RpcKernelConnections {
    connections: RpcKernelBaseConnection[];
    stats: RpcTransportStats;
    broadcast(buffer: RpcMessageDefinition);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L383

### RpcCacheAction (type)

```typescript
interface RpcCacheAction {
    controller: RpcControllerAccess;
    fn: Function;
    types: ActionTypes;
    action: RpcAction;
    resolver: Resolver<any>;
    bodyDecoder: BodyDecoder<any>;
    label: string; //controller.action
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L395

### RpcCache (class)

```typescript
export class RpcCache {
    actionsTypes: {
        [id: string]: ActionTypes;
    };
    actions: {
        [id: string]: RpcCacheAction;
    };
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L405

### RpcKernelConnection (class)

```typescript
export class RpcKernelConnection extends RpcKernelBaseConnection {
    myPeerId?: string;
    routeType: RpcMessageRouteType.client | RpcMessageRouteType.server;
    constructor(stats: RpcStats, logger: Logger, transport: TransportConnection, connections: RpcKernelConnections, injector: InjectorContext, eventDispatcher: EventDispatcher, protected cache: RpcCache, protected controllers: Map<string, {
        controller: ClassType;
        module?: InjectorModule;
    }>, protected security = new RpcKernelSecurity(), protected peerExchange: RpcPeerExchange);
    close(): void;
    async onRequest(basePath: string, request: RpcHttpRequest, response: RpcHttpResponse);
    async onMessage(message: RpcMessage): Promise<void>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L410

### OnConnectionCallback (type)

```typescript
type OnConnectionCallback = (connection: RpcKernelConnection, injector: InjectorContext, logger: LoggerInterface) => void;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L633

### RpcKernel (class)

The kernel is responsible for parsing the message header, redirecting to peer if necessary, loading the body parser,
and encode/send outgoing messages.

```typescript
export class RpcKernel {
    readonly controllers;
    stats;
    injector: InjectorContext;
    constructor(injector?: InjectorContext | NormalizedProvider[], protected logger: Logger = new Logger());
    /**
     * Register a new event listener for given token.
     *
     * order: The lower the order, the sooner the listener is called. Default is 0.
     */
    listen<T extends EventToken<any>>(eventToken: T, callback: EventListenerCallback<T>, order: number = ): EventDispatcherUnsubscribe;
    getEventDispatcher(): EventDispatcher;
    onConnection(callback: OnConnectionCallback);
    /**
     * This registers the controller and when no custom InjectorContext was given adds it as provider to the injector.
     *
     * Note: Controllers can not be added to the injector when the injector was already built.
     */
    registerController(controller: ClassType, id?: string | ControllerDefinition<any>, module?: InjectorModule);
    createConnection(transport: TransportConnection, injector?: InjectorContext): RpcKernelBaseConnection;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/kernel.ts#L642

### Session (class)

```typescript
export class Session {
    constructor(public readonly username: string, public readonly token: any);
    isAnonymous(): boolean;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/security.ts#L14

### RpcControllerAccess (type)

```typescript
interface RpcControllerAccess {
    controllerName: string;
    controllerClassType: ClassType;
    actionName: string;
    actionGroups: string[];
    actionData: { [name: string]: any };
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/security.ts#L26

### RpcKernelSecurity (class)

```typescript
export class RpcKernelSecurity {
    async hasControllerAccess(session: Session, controllerAccess: RpcControllerAccess, connection: RpcKernelBaseConnection): Promise<boolean>;
    async isAllowedToRegisterAsPeer(session: Session, peerId: string): Promise<boolean>;
    async isAllowedToSendToPeer(session: Session, peerId: string): Promise<boolean>;
    async authenticate(token: any, connection: RpcKernelBaseConnection): Promise<Session>;
    transformError(err: Error);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/security.ts#L34

### SessionState (class)

```typescript
export class SessionState {
    setSession(session: Session);
    getSession(): Session;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/server/security.ts#L56

### FilterParameters (type)

```typescript
type FilterParameters = { [name: string]: any | undefined };
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L21

### QuerySelector (type)

```typescript
type QuerySelector<T> = {
    // Comparison
    $eq?: T;
    $gt?: T;
    $gte?: T;
    $in?: T[];
    $lt?: T;
    $lte?: T;
    $ne?: T;
    $nin?: T[];
    // Logical
    $not?: T extends string ? (QuerySelector<T> | RegExp) : QuerySelector<T>;
    $regex?: T extends string ? (RegExp | string) : never;

    //special deepkit/type type
    $parameter?: string;
};
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L23

### RootQuerySelector (type)

```typescript
type RootQuerySelector<T> = {
    $and?: Array<FilterQuery<T>>;
    $nor?: Array<FilterQuery<T>>;
    $or?: Array<FilterQuery<T>>;
    // we could not find a proper TypeScript generic to support nested queries e.g. 'user.friends.name'
    // this will mark all unrecognized properties as any (including nested queries)
    [key: string]: any;
};
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L41

### Condition (type)

```typescript
type Condition<T> = MongoAltQuery<T> | QuerySelector<MongoAltQuery<T>>;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L52

### FilterQuery (type)

```typescript
type FilterQuery<T> = {
    [P in keyof T & string]?: Condition<T[P]>;
} &
    RootQuerySelector<T>;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L55

### SORT_ORDER (type)

```typescript
type SORT_ORDER = 'asc' | 'desc' | any;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L61

### Sort (type)

```typescript
type Sort<T, ORDER extends SORT_ORDER = SORT_ORDER> = { [P in keyof T & string]?: ORDER };
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L62

### CollectionEventAdd (type)

```typescript
interface CollectionEventAdd<T> {
    type: 'add';
    items: T[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L64

### CollectionEventState (type)

```typescript
interface CollectionEventState {
    type: 'state';
    state: CollectionState;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L69

### CollectionEventRemove (type)

```typescript
interface CollectionEventRemove {
    type: 'remove';
    ids: (string | number)[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L74

### CollectionEventSet (type)

```typescript
interface CollectionEventSet {
    type: 'set';
    items: any[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L79

### CollectionEventUpdate (type)

```typescript
interface CollectionEventUpdate {
    type: 'update';
    items: any[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L84

### CollectionSetSort (type)

```typescript
interface CollectionSetSort {
    type: 'sort';
    ids: (string | number)[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L89

### CollectionEvent (type)

```typescript
type CollectionEvent<T> = CollectionEventAdd<T> | CollectionEventRemove | CollectionEventSet | CollectionEventState | CollectionEventUpdate | CollectionSetSort;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L94

### CollectionSortDirection (type)

```typescript
type CollectionSortDirection = 'asc' | 'desc';
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L96

### CollectionSort (type)

```typescript
interface CollectionSort {
    field: string;
    direction: CollectionSortDirection;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L98

### CollectionEntitySubjectFetcher (type)

```typescript
interface CollectionEntitySubjectFetcher {
    fetch<T extends IdInterface>(classType: ClassType<T>, id: string | number): EntitySubject<T>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L103

### CollectionQueryModelInterface (type)

```typescript
interface CollectionQueryModelInterface<T> {
    filter?: FilterQuery<T>;
    skip?: number;
    itemsPerPage: number;
    limit?: number;
    parameters: { [name: string]: any };
    sort?: Sort<T>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L107

### CollectionQueryModel (class)

internal note: This is aligned with

```typescript
export class CollectionQueryModel<T> implements CollectionQueryModelInterface<T> {
    filter?: FilterQuery<T>;
    skip?: number;
    itemsPerPage: number;
    limit?: number;
    parameters: {
        [name: string]: any;
    };
    sort?: Sort<T>;
    readonly change;
    set(model: CollectionQueryModelInterface<any>);
    changed(): void;
    hasSort(): boolean;
    /**
     * Whether limit/skip is activated.
     */
    hasPaging(): boolean;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L119

### CollectionState (class)

```typescript
export class CollectionState {
    /**
     * Total count in the database for the current query, regardless of paging (skip/limit) count.
     *
     * Use count() to get the items count on the current page (which is equal to all().length)
     */
    total: number;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L162

### Collection (class)

```typescript
export class Collection<T extends IdInterface> extends ReplaySubject<T[]> {
    readonly event: Subject<CollectionEvent<T>>;
    readonly removed;
    readonly added;
    state: CollectionState;
    readonly deepChange;
    model: CollectionQueryModel<T>;
    readonly entitySubjects;
    constructor(public readonly classType: ClassType<T>);
    getTotal();
    getItemsPerPage();
    getPages();
    getSort();
    getParameter(name: string);
    setParameter(name: string, value: any): this;
    orderByField(name: keyof T & string, order: SORT_ORDER = );
    setPage(page: number);
    getPage();
    apply();
    getEntitySubject(idOrItem: string | number | T): EntitySubject<T> | undefined;
    has(id: string | number);
    get(id: string | number): T | undefined;
    setState(state: CollectionState);
    setSort(ids: (string | number)[]);
    /**
     * Resolves when next change happened.
     */
    get nextStateChange(): Promise<void>;
    unsubscribe();
    addTeardown(teardown: TeardownLogic);
    index(item: T): number;
    /**
     * Returns the page zero-based of the current item.
     */
    getPageOf(item: T, itemsPerPage = ): number;
    reset();
    all(): T[];
    /**
     * Count of current page if paging is used, otherwise total count.
     */
    count();
    ids(): (string | number)[];
    empty();
    /**
     * All items from id -> value map.
     */
    map();
    loaded();
    set(items: T[], withEvent = true);
    removeMany(ids: (string | number)[], withEvent = true);
    update(items: T | T[], withEvent = true);
    add(items: T | T[], withEvent = true);
    remove(ids: (string | number) | (string | number)[], withEvent = true);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/collection.ts#L174

### getActions (function)

```typescript
<T>(target: ClassType<T>): Map<string, RpcAction>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/decorators.ts#L161

### RpcController (class)

```typescript
export class RpcController {
    name: string;
    classType?: ClassType;
    definition?: ControllerDefinition<any>;
    strictSerialization: boolean;
    logValidationErrors: boolean;
    actions;
    getPath(): string;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/decorators.ts#L22

### RpcAction (class)

```typescript
export class RpcAction {
    name: string;
    classType: ClassType;
    category: string;
    description: string;
    strictSerialization?: boolean;
    logValidationErrors?: boolean;
    groups: string[];
    data: {
        [name: string]: any;
    };
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/decorators.ts#L41

### rpcClass (function)

```typescript
ClassDecoratorResult<typeof RpcClass>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/decorators.ts#L107

### rpcProperty (function)

```typescript
PropertyDecoratorResult<typeof RpcProperty>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/decorators.ts#L157

### rpc (function)

```typescript
FluidDecorator<RpcClass, ClassDecoratorFn> & ClassDecoratorFn & { _fetch: (classType: AbstractClassType, property?: string | undefined, parameterIndexOrDescriptor?: any) => RpcController | undefined; } & FluidDecorator<...> & PropertyDecoratorFn & { ...; }
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/decorators.ts#L159

### isEntitySubject (function)

```typescript
(v: any): v is EntitySubject<any>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L231

### ControllerSymbol (function)

```typescript
<T>(path: string, entities?: ClassType[]): ControllerDefinition<T>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L291

### RpcError (error)

```typescript
export class RpcError extends CustomError {
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L17

### IdType (type)

```typescript
type IdType = string | number;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L20

### IdInterface (type)

```typescript
interface IdInterface {
    id: IdType;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L22

### IdVersionInterface (type)

```typescript
interface IdVersionInterface extends IdInterface {
    version: number;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L26

### NumericKeys (type)

```typescript
type NumericKeys<T> = {
    [K in keyof T]: T[K] extends number ? K : never;
}[keyof T];
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L32

### RpcTransportStats (class)

```typescript
export class RpcTransportStats {
    readonly incomingBytes: number;
    readonly outgoingBytes: number;
    /**
     * Amount of incoming and outgoing messages.
     */
    readonly incoming: number;
    readonly outgoing: number;
    increase(name: NumericKeys<RpcTransportStats>, count: number);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L36

### ActionStats (class)

```typescript
export class ActionStats {
    readonly observables: number;
    readonly subjects: number;
    readonly behaviorSubjects: number;
    readonly progressTrackers: number;
    readonly subscriptions: number;
    increase(name: NumericKeys<ActionStats>, count: number);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L51

### ForwardedActionStats (class)

```typescript
export class ForwardedActionStats extends ActionStats {
    constructor(protected forward: ActionStats);
    increase(name: NumericKeys<ActionStats>, count: number);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L63

### RpcStats (class)

```typescript
export class RpcStats extends RpcTransportStats {
    readonly connections: number;
    readonly totalConnections: number;
    /**
     * How many actions have been executed.
     */
    readonly actions: number;
    readonly active: ActionStats;
    readonly total: ActionStats;
    increase(name: NumericKeys<RpcStats>, count: number);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L74

### ForwardedRpcStats (class)

```typescript
export class ForwardedRpcStats extends RpcStats {
    readonly active;
    readonly total;
    constructor(protected forward: RpcStats);
    increase(name: NumericKeys<RpcStats>, count: number);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L91

### StreamBehaviorSubject (class)

```typescript
export class StreamBehaviorSubject<T> extends BehaviorSubject<T> {
    readonly appendSubject;
    constructor(item: T, teardown?: TeardownLogic);
    isUnsubscribed(): boolean;
    get nextStateChange();
    addTearDown(teardown: TeardownLogic);
    /**
     * This method differs to BehaviorSubject in the way that this does not throw an error
     * when the subject is closed/unsubscribed.
     */
    getValue(): T;
    next(value: T): void;
    activateNextOnAppend();
    toUTF8();
    append(value: T): void;
    unsubscribe(): void;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L105

### EntitySubject (class)

```typescript
export class EntitySubject<T extends IdInterface> extends StreamBehaviorSubject<T> {
    /**
     * Patches are in class format.
     */
    readonly patches;
    readonly delete;
    [IsEntitySubject];
    deleted: boolean;
    get id(): string | number;
    get onDeletion(): Observable<void>;
    next(value: T | undefined): void;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L236

### ControllerDefinition (class)

```typescript
export class ControllerDefinition<T> {
    constructor(public path: string, public entities: ClassType[] = []);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L283

### JSONError (class)

```typescript
@entity.name()
export class JSONError {
    constructor(public readonly json: any);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L295

### rpcClientId (type)

```typescript
interface rpcClientId {
    id: Uint8Array;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L373

### rpcChunk (type)

```typescript
interface rpcChunk {
    seq: number; //sequence number of this chunk
    total: number; //size in bytes
    v: Uint8Array;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L377

### rpcActionObservableSubscribeId (type)

```typescript
interface rpcActionObservableSubscribeId {
    id: number;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L383

### rpcActionObservableNext (type)

```typescript
interface rpcActionObservableNext {
    id: number;
    v: any;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L387

### rpcError (type)

```typescript
interface rpcError {
    classType: string;
    message: string;
    stack: string;
    properties?: Record<string, any>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L392

### rpcResponseActionObservableSubscriptionError (type)

```typescript
interface rpcResponseActionObservableSubscriptionError extends rpcError {
    id: number;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L399

### rpcSort (type)

```typescript
interface rpcSort {
    field: string;
    direction: 'asc' | 'desc';
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L410

### rpcResponseActionObservable (type)

```typescript
interface rpcResponseActionObservable {
    type: ActionObservableTypes;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L415

### rpcAuthenticate (type)

```typescript
interface rpcAuthenticate {
    token: any;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L419

### rpcResponseAuthenticate (type)

```typescript
interface rpcResponseAuthenticate {
    username: string;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L423

### rpcAction (type)

```typescript
interface rpcAction {
    controller: string;
    method: string;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L427

### rpcActionType (type)

```typescript
interface rpcActionType {
    controller: string;
    method: string;
    disableTypeReuse?: boolean;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L432

### ActionMode (type)

```typescript
type ActionMode = 'arbitrary' | 'collection' | 'entitySubject' | 'observable';
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L438

### rpcResponseActionType (type)

```typescript
interface rpcResponseActionType {
    mode: ActionMode;
    type: any; //Type as SerializedTypes
    parameters: any; //TypeTuple as SerializedTypes
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L440

### rpcPeerRegister (type)

```typescript
interface rpcPeerRegister {
    id: string;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L446

### rpcPeerDeregister (type)

```typescript
interface rpcPeerDeregister {
    id: string;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L450

### rpcResponseActionCollectionRemove (type)

```typescript
interface rpcResponseActionCollectionRemove {
    ids: (string | number)[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L454

### rpcResponseActionCollectionSort (type)

```typescript
interface rpcResponseActionCollectionSort {
    ids: (string | number)[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L458

### rpcEntityRemove (type)

```typescript
interface rpcEntityRemove {
    entityName: string;
    ids: (string | number)[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L462

### EntityPatch (type)

```typescript
interface EntityPatch {
    $set?: { [path: string]: any },
    $unset?: { [path: string]: number }
    $inc?: { [path: string]: number }
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L467

### rpcEntityPatch (type)

```typescript
interface rpcEntityPatch {
    entityName: string;
    id: string | number;
    version: number;
    patch: {
        $set?: Record<string, any>,
        $unset?: Record<string, number>,
        $inc?: Record<string, number>,
    };
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L473

### AuthenticationError (error)

```typescript
export class AuthenticationError extends CustomError {
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L484

### WrappedV (type)

```typescript
interface WrappedV {
    v: any;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/model.ts#L487

### createBodyDecoder (function)

```typescript
<T>(type?: ReceiveType<T>): BodyDecoder<T>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L30

### readBinaryRpcMessage (function)

```typescript
(buffer: Uint8Array): RpcMessage
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L211

### createRpcCompositeMessage (function)

```typescript
<T>(id: number, type: number, messages: RpcCreateMessageDef<any>[], routeType?: RpcMessageRouteType.client | RpcMessageRouteType.server): RpcMessageDefinition
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L249

### serializeBinaryRpcCompositeMessage (function)

```typescript
(message: RpcMessageDefinition): Uint8Array
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L263

### createRpcCompositeMessageSourceDest (function)

```typescript
(id: number, source: Uint8Array, destination: Uint8Array, type: number, messages: RpcCreateMessageDef<any>[]): RpcMessageDefinition
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L296

### serializeBinaryRpcCompositeMessageSourceDest (function)

```typescript
(message: RpcMessageDefinition): Uint8Array
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L313

### createRpcMessage (function)

```typescript
<T>(id: number, type: number, body?: T, routeType?: RpcMessageRouteType.client | RpcMessageRouteType.server, schema?: ReceiveType<T>): RpcMessageDefinition
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L366

### serializeBinaryRpcMessage (function)

```typescript
(message: RpcMessageDefinition): Uint8Array
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L397

### getPreSerializedPart (function)

For a message built from a PreSerialized value: the value and the offset at which its
`tail` starts in the message.

```typescript
(message: Uint8Array): { value: PreSerialized; offset: number; } | undefined
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L449

### preSerialize (function)

Serializes `value` once, to be sent through many messages whose body is
`{ ..., v: T }` without serializing it again: an action result, or an observable's
next value. Only single-body messages (not composite, not peer or source/dest
routed) support it.

```typescript
<T>(value: T, type?: ReceiveType<T>): PreSerialized
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L472

### serializeBinaryRpcMessageSingleBody (function)

```typescript
(message: RpcMessageDefinition): Uint8Array
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L531

### createRpcMessagePeer (function)

```typescript
<T>(id: number, type: number, source: Uint8Array, peerId: string, body?: T, schema?: ReceiveType<T>): RpcMessageDefinition
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L557

### serializeBinaryRpcMessagePeer (function)

```typescript
(message: RpcMessageDefinition): Uint8Array
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L577

### createRpcMessageSourceDest (function)

```typescript
<T>(id: number, type: number, source: Uint8Array, destination: Uint8Array, body?: T, schema?: ReceiveType<T>): RpcMessageDefinition
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L604

### serializeBinaryRpcMessageSourceDest (function)

```typescript
(message: RpcMessageDefinition): Uint8Array
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L625

### createRpcMessageSourceDestForBody (function)

```typescript
<T>(id: number, type: number, source: Uint8Array, destination: Uint8Array, body: Uint8Array): Uint8Array
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L652

### readUint32LE (function)

```typescript
(buffer: Uint8Array, offset?: number): number
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L788

### rpcEncodeError (function)

```typescript
(error: Error | string): EncodedError
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L799

### rpcDecodeError (function)

```typescript
(error: EncodedError): Error
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L823

### createErrorMessage (function)

```typescript
(id: number, error: Error | string, routeType: RpcMessageRouteType.client | RpcMessageRouteType.server): RpcMessageDefinition
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L851

### BodyDecoder (type)

```typescript
interface BodyDecoder<T> {
    type: Type;

    (buffer: Uint8Array, offset: number): T;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L24

### RpcMessage (class)

```typescript
export class RpcMessage {
    constructor(public id: number, public composite: boolean, public type: number, public routeType: RpcMessageRouteType, public bodyOffset: number = , public bodySize: number = , public buffer?: Uint8Array);
    debug();
    getBuffer(): Uint8Array;
    getPeerId(): string;
    getSource(): Uint8Array;
    getDestination(): Uint8Array;
    getError(): Error;
    isError(): boolean;
    parseGenericBody(): object;
    parseBody<T>(type?: ReceiveType<T>): T;
    decodeBody<T>(decoder: BodyDecoder<T>): T;
    getBodies(): RpcMessage[];
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L79

### ErroredRpcMessage (class)

```typescript
export class ErroredRpcMessage extends RpcMessage {
    constructor(public id: number, public error: Error);
    getError(): Error;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L198

### RpcCreateMessageDef (type)

```typescript
interface RpcCreateMessageDef<T> {
    type: number;
    schema?: Type;
    body?: T;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L243

### RpcMessageDefinition (type)

```typescript
interface RpcMessageDefinition {
    id: number;
    type: number;
    routeType: RpcMessageRouteType;
    composite?: RpcCreateMessageDef<any>[];
    peerId?: string;
    source?: Uint8Array;
    destination?: Uint8Array;
    body?: {
        type: Type;
        body: any;
    };
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L352

### PreSerialized (class)

A value serialized once, to be sent in many messages.

A message body whose `v` property is a PreSerialized value is written by splicing
the pre-encoded BSON element into the document instead of serializing the value
again. A producer that sends one value to many connections, e.g. the same
observable value to every subscriber, calls preSerialize() once and passes the
result where the value would go. The bytes are identical to serializing the value
in place, so clients need no change.

```typescript
export class PreSerialized {
    /**  BSON element for key "v": type byte, key, value. No document size, no terminator. */
    constructor(public readonly element: Uint8Array, public readonly tail: Uint8Array);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L428

### RpcBinaryMessageReader (class)

```typescript
export class RpcBinaryMessageReader {
    constructor(protected readonly onMessage: (response: RpcMessage) => void, protected readonly onChunk?: (id: number, abort: boolean) => void);
    cleanUp();
    onChunkAck(id: number, callback: (active: boolean) => void);
    removeChunkAck(id: number, aborted = false);
    registerProgress(id: number, progress: SingleProgress);
    feed(buffer: Uint8Array, bytes?: number);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L680

### EncodedError (type)

```typescript
interface EncodedError {
    classType: string;
    message: string;
    stack: string;
    properties?: { [name: string]: any };
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/protocol.ts#L792

### SingleProgress (class)

```typescript
export class SingleProgress extends Subject<SingleProgress> {
    done;
    total;
    current;
    stats;
    abortController: AbortController;
    finished;
    constructor();
    /**
     * Aborts the current progress (either upload or download).
     */
    abort();
    get aborted();
    /**
     * Acts like a BehaviorSubject.
     */
    _subscribe(subscriber: Subscriber<SingleProgress>): Subscription;
    setStart(total: number);
    setBatch(size: number);
    get progress(): number;
    set(total: number, current: number);
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/progress.ts#L13

### Progress (class)

```typescript
export class Progress extends BehaviorSubject<number> {
    readonly upload;
    readonly download;
    /**
     * Aborts both upload and download progress.
     */
    abort();
    constructor();
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/progress.ts#L85

### ClientProgress (class)

```typescript
export class ClientProgress {
    static nextProgress?: Progress;
    /**
     * Returns the current stack and sets a new one.
     */
    static getNext(): Progress | undefined;
    /**
     * Sets up a new Progress object for the next API request to be made.
     * Only the very next API call will be tracked.
     *
     * @example
     * ```typescript
     *
     * const progress = ClientProgress.track();
     * await api.myMethod();
     *
     * ```
     */
    static track(): Progress;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/progress.ts#L102

### createWriter (function)

```typescript
(transport: TransportConnection, options: TransportOptions, reader: RpcBinaryMessageReader): TransportMessageWriter
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/transport.ts#L155

### TransportOptions (class)

```typescript
export class TransportOptions {
    /**
     * Stores big buffers to the file system and stream it from there.
     * In bytes.
     * note: not implemented yet
     */
    cacheOnFileSystemWhenSizeIsAtLeast: number;
    /**
     * When back-pressure is bigger than this value, we wait with sending new data.
     * In bytes.
     * note: not implemented yet
     */
    stepBackWhenBackPressureBiggerThan: number;
    /**
     * Chunk size.
     * In bytes.
     */
    chunkSize: number;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/transport.ts#L6

### TransportMessageWriter (type)

```typescript
interface TransportMessageWriter {
    (message: RpcMessageDefinition, options: TransportOptions, stats: RpcTransportStats, progress?: SingleProgress): void;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/transport.ts#L31

### TransportConnection (type)

```typescript
interface TransportConnection {
    /**
     * Write is used either by Client->Server, or Server->Client.
     * The method is responsible to serialize the message and send it over the wire.
     */
    write?: TransportMessageWriter;

    /**
     * Same as write, but sends binary directly. This enables chunking automatically.
     */
    writeBinary?(message: Uint8Array): void;

    bufferedAmount?(): number;

    clientAddress?(): string;

    close(): void;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/transport.ts#L35

### TransportClientConnection (type)

```typescript
interface TransportClientConnection {
    token?: any;

    onConnected(established: TransportConnection): void;

    onClose(reason: string): void;

    onError(error: Error): void;

    /**
     * Called when data is received from the other side.
     * The method is responsible to deserialize the message.
     */
    read(message: RpcMessage): void;

    readBinary(message: Uint8Array, bytes?: number): void;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/transport.ts#L54

### RpcBinaryWriter (type)

```typescript
type RpcBinaryWriter = (buffer: Uint8Array) => void;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/transport.ts#L72

### TransportBinaryMessageChunkWriter (class)

This class acts as a layer between kernel/client and a connection writer.
It automatically chunks long messages into multiple smaller one using the RpcType.Chunks type.

todo:
It keeps track of the back-pressure and sends only when the pressure is not too big.
It automatically saves big buffer to the file system and streams data from there to not
block valuable memory.

```typescript
export class TransportBinaryMessageChunkWriter {
    constructor(protected reader: RpcBinaryMessageReader, protected options: TransportOptions);
    /**
     * Writes a message buffer to the connection and chunks if necessary.
     */
    write(writer: RpcBinaryWriter, message: Uint8Array, progress?: SingleProgress): void;
    async writeFull(writer: RpcBinaryWriter, buffer: Uint8Array, progress?: SingleProgress): Promise<void>;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/transport.ts#L83

### createSubject (function)

Create a Subject with teardown function that is called when
client disconnects or completes the subject.

The producer is called in the next tick, no matter if the client
subscribes to the subject or not. This is fundamentally different
from Observables, where the producer is only called when the Observable
is subscribed to.

Teardown is also called when the producer errors or completes.

You should normally prefer using Observables (with instantObservable)
over Subjects, as Subjects are not lazy and start emitting values
immediately when created.

```typescript
class Controller {

```typescript
<T>(producer: (subject: Subject<T>) => void | Promise<void>, teardown?: () => void): Subject<T>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/utils.ts#L34

### instantSubject (function)

Returns a Subject that is immediately subscribed to the given producer.

The producer can be a Promise or a function that returns a Promise.

Note that the Subject will be requested from the Promise right away.

```typescript
const client = new RpcClient();
const controller = client.controller<MyController>('controller');

// normally you would do this:
const subject = await controller.subscribeChats('asd');

// but with instantSubject you can do this, allowing you to get
// a Subject in a synchronous way.
const subject = instantSubject(controller.subscribeChats('asd'));
```

```typescript
<T>(producer: InstanceProducer<Subject<T>>): Subject<T>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/utils.ts#L81

### InstanceProducer (type)

```typescript
type InstanceProducer<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/utils.ts#L50

### WithFail (type)

```typescript
type WithFail<T> = Omit<T, 'phase'> & { phase: 'fail'; error: Error };
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L6

### RpcConnectionEvent (type)

```typescript
interface RpcConnectionEvent {
    context: {
        connection: RpcKernelBaseConnection;
        injector: InjectorContext;
    };
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L8

### onRpcConnection (event)

```typescript
EventTokenSync<DataEvent<RpcConnectionEvent>>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L15

### RpcConnectionCloseEvent (type)

```typescript
interface RpcConnectionCloseEvent extends RpcConnectionEvent {
    /**
     * There could be multiple reasons why a connection is closed. This could be a normal
     * close, an error, or a timeout.
     * If the connection was closed because of an error, this property contains the error object.
     */
    reason: string | Error;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L17

### onRpcConnectionClose (event)

```typescript
EventTokenSync<DataEvent<RpcConnectionCloseEvent>>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L26

### RpcActionTimings (type)

All times are in milliseconds (using performance.now()).

```typescript
interface RpcActionTimings {
    /**
     * The start of the action (performance.now())
     */
    start: number;

    /**
     * The end of the action (performance.now())
     */
    end: number;

    /**
     * Time it took to check the controller access (since start)
     */
    types?: number;

    /**
     * Time it took to parse the body (since start)
     */
    parseBody?: number;

    /**
     * Time it took to validate the parameters (since start)
     */
    validate?: number;

    /**
     * Time it took to check the controller access (since start)
     */
    controllerAccess?: number;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L31

### RpcActionEventBase (type)

```typescript
interface RpcActionEventBase extends RpcConnectionEvent {
    phase: 'start' | 'success';
    controller: RpcControllerAccess;
    timing: RpcActionTimings;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L63

### RpcActionEvent (type)

```typescript
type RpcActionEvent = RpcActionEventBase | WithFail<RpcActionEventBase>;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L69

### onRpcAction (event)

```typescript
EventTokenSync<DataEvent<RpcActionEvent>>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L71

### RpcAuthEventStart (type)

```typescript
interface RpcAuthEventStart extends RpcConnectionEvent {
    token: any;
    phase: 'start';
    /**
     * Set this to the session object if the authentication was successful.
     * If set this will bypass RpcKernelSecurity and directly use this session.
     */
    session?: Session;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L73

### RpcAuthEventSuccess (type)

```typescript
interface RpcAuthEventSuccess extends RpcConnectionEvent {
    token: any;
    phase: 'success';
    session: Session;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L83

### RpcAuthEvent (type)

```typescript
type RpcAuthEvent = RpcAuthEventStart | RpcAuthEventSuccess | WithFail<RpcAuthEventStart>;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L89

### onRpcAuth (event)

```typescript
EventToken<DataEvent<RpcAuthEvent>>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L91

### RpcControllerAccessEventStart (type)

```typescript
interface RpcControllerAccessEventStart extends RpcConnectionEvent {
    phase: 'start';
    session: Session;
    controller: RpcControllerAccess;
    /**
     * Set this to true if you want to grant access to the controller.
     * If set this will bypass RpcKernelSecurity and directly grant access.
     */
    granted?: boolean;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L93

### RpcControllerAccessEventBase (type)

```typescript
interface RpcControllerAccessEventBase extends RpcConnectionEvent {
    phase: 'success' | 'denied';
    session: Session;
    controller: RpcControllerAccess;
}
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L104

### RpcControllerAccessEvent (type)

```typescript
type RpcControllerAccessEvent = RpcControllerAccessEventStart | RpcControllerAccessEventBase | WithFail<RpcControllerAccessEventBase>;
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L110

### onRpcControllerAccess (event)

```typescript
EventToken<DataEvent<RpcControllerAccessEvent>>
```

Source: https://github.com/deepkit/deepkit-framework/blob/master/packages/rpc/src/events.ts#L112