SYMBOL INDEX (415 symbols across 38 files)

FILE: add-http-pages/index.js
  function readHello (line 5) | async function readHello() {
  function addHttpPages (line 12) | function addHttpPages(server) {

FILE: add-http-pages/index.test.ts
  constant DEFAULT_OPTIONS (line 12) | const DEFAULT_OPTIONS = {
  function createServer (line 19) | function createServer(
  class RequestError (line 45) | class RequestError extends Error {
    method constructor (line 48) | constructor(statusCode: number | undefined, body: string) {
  type HttpResponse (line 55) | interface HttpResponse {
  function request (line 60) | function request(
  function requestError (line 93) | async function requestError(

FILE: add-sync-map/index.d.ts
  type WithTime (line 18) | type WithTime<Value extends SyncMapTypes | SyncMapTypes[]> = {
  type WithoutTime (line 24) | type WithoutTime<Value extends SyncMapTypes | SyncMapTypes[]> = {
  type SyncMapData (line 30) | type SyncMapData<Value extends SyncMapValues> = {
  type SyncMapActionFilter (line 59) | interface SyncMapActionFilter<Value extends SyncMapValues> {
  type SyncMapOperations (line 70) | interface SyncMapOperations<Value extends SyncMapValues> {
  type SyncMapFilterOperations (line 116) | interface SyncMapFilterOperations<Value extends SyncMapValues> {

FILE: add-sync-map/index.js
  constant WITH_TIME (line 1) | const WITH_TIME = Symbol('WITH_TIME')
  function ChangedAt (line 3) | function ChangedAt(value, time) {
  function NoConflictResolution (line 7) | function NoConflictResolution(value) {
  function addFinished (line 11) | async function addFinished(server, ctx, type, action, meta) {
  function resendFinished (line 18) | function resendFinished(server, plural, type, all = true) {
  function buildFilter (line 40) | function buildFilter(filter) {
  function sendMap (line 58) | async function sendMap(server, changedType, data, since) {
  function addSyncMap (line 90) | function addSyncMap(server, plural, operations) {
  function addSyncMapFilter (line 177) | function addSyncMapFilter(server, plural, operations) {

FILE: add-sync-map/index.test.ts
  type TaskValue (line 20) | type TaskValue = {
  type TaskRecord (line 25) | type TaskRecord = {
  type CommentValue (line 39) | type CommentValue = {
  function getTime (line 56) | function getTime(client: TestClient, creator: { type: string }): number[] {
  function getServer (line 63) | function getServer(): TestServer {
  method access (line 333) | access() {
  method load (line 336) | load(ctx, id, since) {
  method access (line 352) | access() {
  method initial (line 355) | initial() {
  method access (line 383) | access() {
  method change (line 386) | change(ctx, id) {
  method create (line 389) | create(ctx, id) {
  method delete (line 392) | delete(ctx, id) {
  method load (line 395) | load(ctx, id) {
  method access (line 400) | access() {
  method initial (line 403) | initial() {
  method access (line 434) | access() {
  method load (line 437) | load(ctx, id) {
  method access (line 464) | access() {
  method load (line 468) | load(ctx, id) {

FILE: allowed-meta/index.d.ts
  constant ALLOWED_META (line 17) | const ALLOWED_META: string[]

FILE: allowed-meta/index.js
  constant ALLOWED_META (line 1) | const ALLOWED_META = ['id', 'time', 'subprotocol']

FILE: base-server/index.d.ts
  type LogFn (line 31) | interface LogFn {
  type TypeOptions (line 35) | interface TypeOptions {
  type ChannelOptions (line 43) | interface ChannelOptions {
  type ConnectLoader (line 51) | interface ConnectLoader<Headers extends object = unknown> {
  type ServerNodeConstructor (line 66) | type ServerNodeConstructor = new (...args: unknown[]) => ServerNode
  type ServerMeta (line 68) | interface ServerMeta extends Meta {
  type BaseServerOptions (line 125) | interface BaseServerOptions {
  type AuthenticatorOptions (line 253) | interface AuthenticatorOptions<Headers extends object> {
  type SendBackActions (line 261) | type SendBackActions =
  type ServerAuthenticator (line 275) | interface ServerAuthenticator<Headers extends object> {
  type Authorizer (line 287) | interface Authorizer<
  type Resender (line 307) | interface Resender<
  type Processor (line 327) | interface Processor<
  type ActionFinally (line 347) | interface ActionFinally<
  type ChannelFilter (line 367) | interface ChannelFilter<Headers extends object> {
  type ChannelAuthorizer (line 383) | interface ChannelAuthorizer<
  type FilterCreator (line 404) | interface FilterCreator<
  type ChannelLoader (line 425) | interface ChannelLoader<
  type ChannelFinally (line 446) | interface ChannelFinally<
  type ChannelUnsubscribe (line 467) | interface ChannelUnsubscribe<
  type ActionCallbacks (line 479) | type ActionCallbacks<
  type ChannelCallbacks (line 496) | type ChannelCallbacks<
  type ActionReporter (line 520) | interface ActionReporter {
  type SubscriptionReporter (line 525) | interface SubscriptionReporter {
  type CleanReporter (line 530) | interface CleanReporter {
  type AuthenticationReporter (line 534) | interface AuthenticationReporter {
  type ReportersArguments (line 540) | interface ReportersArguments {
  type Reporter (line 598) | interface Reporter {
  type Resend (line 605) | type Resend =
  type Logger (line 620) | interface Logger {
  class BaseServer (line 648) | class BaseServer<

FILE: base-server/index.js
  constant SKIP_PROCESS (line 16) | const SKIP_PROCESS = Symbol('skipProcess')
  constant RESEND_META (line 17) | const RESEND_META = ['channels', 'users', 'clients', 'nodes']
  function optionError (line 19) | function optionError(msg) {
  function wasNot403 (line 26) | async function wasNot403(cb) {
  function normalizeTypeCallbacks (line 38) | function normalizeTypeCallbacks(name, callbacks) {
  function normalizeChannelCallbacks (line 55) | function normalizeChannelCallbacks(pattern, callbacks) {
  function subscriberFilterId (line 85) | function subscriberFilterId(action) {
  class BaseServer (line 89) | class BaseServer {
    method constructor (line 90) | constructor(opts = {}) {
    method addClient (line 410) | addClient(connection) {
    method auth (line 418) | auth(authenticator) {
    method buildUndo (line 422) | buildUndo(action, meta, reason, extra) {
    method channel (line 444) | channel(pattern, callbacks, options = {}) {
    method createContext (line 459) | createContext(action, meta) {
    method debugActionError (line 468) | debugActionError(meta, msg) {
    method debugError (line 477) | debugError(error) {
    method denyAction (line 487) | denyAction(action, meta) {
    method destroy (line 493) | destroy() {
    method finally (line 499) | finally(processor, ctx, action, meta) {
    method getProcessor (line 510) | getProcessor(type) {
    method getRegexProcessor (line 516) | getRegexProcessor(type) {
    method handleClient (line 525) | handleClient(ws, req) {
    method http (line 530) | http(method, url, listener) {
    method internalUnknownType (line 543) | internalUnknownType(action, meta) {
    method internalWrongChannel (line 556) | internalWrongChannel(action, meta) {
    method isBruteforce (line 566) | isBruteforce(ip) {
    method isUseless (line 571) | isUseless(action, meta) {
    method listen (line 585) | async listen() {
    method markAsProcessed (line 648) | markAsProcessed(meta) {
    method on (line 659) | on(event, listener) {
    method otherChannel (line 667) | otherChannel(callbacks) {
    method otherType (line 681) | otherType(callbacks) {
    method performUnsubscribe (line 689) | performUnsubscribe(clientNodeId, action, meta) {
    method process (line 715) | process(action, meta = {}) {
    method processAction (line 735) | async processAction(processor, action, meta, start) {
    method processHttp (line 756) | async processHttp(req, res) {
    method rememberBadAuth (line 782) | rememberBadAuth(ip) {
    method replaceResendShortcuts (line 793) | replaceResendShortcuts(meta) {
    method sendAction (line 812) | async sendAction(action, meta) {
    method sendOnConnect (line 879) | sendOnConnect(loader) {
    method setTimeout (line 883) | setTimeout(callback, ms) {
    method subscribe (line 892) | subscribe(nodeId, channel) {
    method subscribeAction (line 903) | async subscribeAction(action, meta, start) {
    method type (line 1008) | type(name, callbacks, options = {}) {
    method undo (line 1025) | undo(action, meta, reason = 'error', extra = {}) {
    method unknownType (line 1032) | unknownType(action, meta) {
    method unsubscribe (line 1037) | unsubscribe(action, meta) {
    method unsubscribeAction (line 1042) | unsubscribeAction(action, meta) {
    method wrongChannel (line 1054) | wrongChannel(action, meta) {

FILE: base-server/index.test.ts
  constant ROOT (line 24) | const ROOT = join(import.meta.dirname, '..')
  constant DEFAULT_OPTIONS (line 26) | const DEFAULT_OPTIONS = {
  constant CERT (line 30) | const CERT = join(ROOT, 'test/fixtures/cert.pem')
  constant KEY (line 31) | const KEY = join(ROOT, 'test/fixtures/key.pem')
  function createServer (line 35) | function createServer(
  function createReporter (line 62) | function createReporter(opts: Partial<BaseServerOptions> = {}): {
  function privateMethods (line 83) | function privateMethods(obj: object): any {
  function emit (line 87) | function emit(obj: any, event: string, ...args: any): void {
  function catchError (line 91) | async function catchError(cb: () => Promise<any>): Promise<Error> {
  function calls (line 100) | function calls(fn: Function | undefined): any[][] {
  function called (line 104) | function called(fn: Function | undefined): boolean {
  function callCount (line 108) | function callCount(fn: Function | undefined): number {
  method process (line 594) | async process(ctx, action, meta) {
  method process (line 623) | async process(ctx, action, meta) {
  method process (line 669) | process() {
  method process (line 702) | process() {
  method onAdd (line 817) | onAdd() {}
  method access (line 874) | access(ctx, action, meta) {
  method send (line 881) | send() {}
  method onAdd (line 882) | onAdd() {}
  method access (line 909) | async access(ctx) {
  method finally (line 913) | finally() {
  method access (line 946) | access() {
  method access (line 979) | access(ctx, action, meta) {
  method access (line 991) | access() {
  method filter (line 994) | async filter() {
  method access (line 1086) | access() {
  method filter (line 1089) | async filter() {
  method access (line 1151) | access() {
  method filter (line 1156) | filter() {
  method load (line 1159) | load() {
  method load (line 1184) | load() {
  method load (line 1228) | load(ctx, action, meta) {
  method access (line 1285) | access(ctx) {
  method process (line 1444) | process() {
  type ActionA (line 1463) | type ActionA = { aValue: string; type: 'A' }
  method process (line 1470) | process(ctx, action) {

FILE: context/index.d.ts
  class ConnectContext (line 7) | class ConnectContext<Headers extends object = unknown> {
  class Context (line 82) | class Context<
  class ChannelContext (line 126) | class ChannelContext<

FILE: context/index.js
  class Context (line 3) | class Context {
    method constructor (line 4) | constructor(server, meta) {
    method sendBack (line 36) | sendBack(action, meta = {}) {

FILE: context/index.test.ts
  constant FAKE_SERVER (line 8) | const FAKE_SERVER: any = {
  method add (line 17) | add(action: Action, meta: ServerMeta) {
  function createContext (line 28) | function createContext(

FILE: create-http-server/index.js
  constant PEM_PREAMBLE (line 6) | const PEM_PREAMBLE = '-----BEGIN'
  function isPem (line 8) | function isPem(content) {
  function readFrom (line 16) | function readFrom(root, file) {
  function createHttpServer (line 22) | async function createHttpServer(opts) {

FILE: create-reporter/index.js
  constant ERROR_CODES (line 6) | const ERROR_CODES = {
  constant REPORTERS (line 48) | const REPORTERS = {
  function cleanFromKeys (line 175) | function cleanFromKeys(obj, regexp, seen) {
  function createRecord (line 195) | function createRecord(level, details, msg) {
  function createReporter (line 210) | function createReporter(options) {

FILE: create-reporter/index.test.ts
  class MemoryStream (line 8) | class MemoryStream {
    method constructor (line 13) | constructor(flushSync: boolean) {
    method write (line 22) | write(chunk: string): void {
  function clean (line 27) | function clean(str: string): string {
  function check (line 38) | function check(type: string, details?: object): void {
  function createError (line 54) | function createError(name: string, message: string): Error {
  method info (line 391) | info(details: object, msg: string) {

FILE: filter-meta/index.js
  function filterMeta (line 3) | function filterMeta(meta) {

FILE: filtered-node/index.js
  function has (line 3) | function has(array, item) {
  class FilteredNode (line 7) | class FilteredNode extends ServerNode {
    method constructor (line 8) | constructor(client, nodeId, log, connection, options) {
    method syncFilter (line 19) | syncFilter(action, meta) {

FILE: filtered-node/index.test.ts
  type Test (line 6) | type Test = {
  function createTest (line 11) | function createTest(): Test {

FILE: human-formatter/index.js
  constant INDENT (line 6) | const INDENT = '  '
  constant PADDING (line 7) | const PADDING = '        '
  constant SEPARATOR (line 8) | const SEPARATOR = os.EOL + os.EOL
  constant NEXT_LINE (line 9) | const NEXT_LINE = os.EOL === '\n' ? '\r\v' : os.EOL
  constant PARAMS_BLACKLIST (line 11) | const PARAMS_BLACKLIST = {
  constant LABELS (line 27) | const LABELS = {
  constant COLORS (line 35) | const COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan']
  function formatNow (line 37) | function formatNow() {
  function rightPag (line 48) | function rightPag(str, length) {
  function label (line 54) | function label(type, color, labelBg, labelText, message) {
  function formatName (line 61) | function formatName(key) {
  function shuffledColors (line 70) | function shuffledColors(str) {
  function splitAndColorize (line 87) | function splitAndColorize(partLength, str) {
  function formatNodeId (line 109) | function formatNodeId(nodeId) {
  function formatValue (line 121) | function formatValue(value) {
  function formatObject (line 133) | function formatObject(obj) {
  function formatArray (line 138) | function formatArray(array) {
  function formatActionId (line 143) | function formatActionId(id) {
  function formatParams (line 154) | function formatParams(params, parent) {
  function splitByLength (line 197) | function splitByLength(string, max) {
  function prettyStackTrace (line 211) | function prettyStackTrace(stack, basepath) {
  function humanFormatter (line 233) | function humanFormatter(options) {

FILE: human-formatter/utils.js
  function onceXmur3 (line 1) | function onceXmur3(str) {
  function mulberry32 (line 12) | function mulberry32(a) {

FILE: options-loader/index.js
  function loadOptions (line 5) | function loadOptions(spec, process, env) {
  function gatherCliArgs (line 39) | function gatherCliArgs(argv) {
  function parseValues (line 67) | function parseValues(spec, args) {
  function loadEnv (line 84) | function loadEnv(file) {
  function mapArgs (line 110) | function mapArgs(parsedCliArgs, argsSpec) {
  function composeHelp (line 121) | function composeHelp(spec, argv) {
  function composeEnvName (line 160) | function composeEnvName(prefix, name) {
  function composeCliFullName (line 167) | function composeCliFullName(name) {
  function composeCliAliasName (line 171) | function composeCliAliasName(name) {
  function toKebabCase (line 175) | function toKebabCase(word) {
  function oneOf (line 179) | function oneOf(options, rawValue) {
  function number (line 192) | function number(rawValue) {
  function string (line 205) | function string(rawValue) {

FILE: options-loader/index.test.js
  function fakeProcess (line 8) | function fakeProcess(argv, env = {}) {

FILE: request/index.d.ts
  class ResponseError (line 5) | class ResponseError extends Error {

FILE: request/index.js
  class ResponseError (line 1) | class ResponseError extends Error {
    method constructor (line 2) | constructor(statusCode, url) {

FILE: server-client/index.d.ts
  class ServerClient (line 12) | class ServerClient {

FILE: server-client/index.js
  function onSend (line 10) | async function onSend(action, meta) {
  function reportDetails (line 14) | function reportDetails(client) {
  function denyBack (line 22) | function denyBack(app, clientId, action, meta) {
  function queueWorker (line 30) | async function queueWorker(task, next) {
  class ServerClient (line 67) | class ServerClient {
    method constructor (line 68) | constructor(app, connection, key) {
    method auth (line 128) | async auth(nodeId, token) {
    method destroy (line 209) | destroy() {
    method onReceive (line 242) | onReceive(action, meta) {

FILE: server-client/index.test.ts
  function privateMethods (line 27) | function privateMethods(obj: object): any {
  function getPair (line 31) | function getPair(client: ServerClient): TestPair {
  function sendTo (line 35) | async function sendTo(client: ServerClient, msg: Message): Promise<void> {
  function connect (line 41) | async function connect(
  function createConnection (line 57) | function createConnection(): ServerConnection {
  function createServer (line 70) | function createServer(
  function createReporter (line 93) | function createReporter(opts: Partial<BaseServerOptions> = {}): {
  function createClient (line 109) | function createClient(app: BaseServer): ServerClient {
  function connectClient (line 117) | async function connectClient(
  function sent (line 127) | function sent(client: ServerClient): Message[] {
  function sentNames (line 131) | function sentNames(client: ServerClient): string[] {
  function actions (line 135) | function actions(client: ServerClient): Action[] {
  function connectNext (line 376) | async function connectNext(num: number): Promise<void> {
  method finally (line 564) | finally() {
  type FooAction (line 723) | type FooAction = {
  method access (line 728) | async access(ctx, action, meta) {
  method process (line 779) | process(ctx) {
  method access (line 797) | access() {
  method finally (line 800) | finally() {
  method resend (line 842) | resend(ctx, action, meta) {
  method resend (line 898) | resend() {
  method resend (line 904) | resend() {
  method access (line 1240) | access() {
  method process (line 1244) | process() {
  method access (line 1264) | access(ctx, action, meta) {
  method process (line 1269) | process() {
  method access (line 1289) | access(ctx, action, meta) {
  method finally (line 1333) | finally() {
  method finally (line 1343) | finally() {
  method finally (line 1354) | finally() {
  method resend (line 1357) | resend() {
  method access (line 1366) | access() {
  method finally (line 1369) | finally() {
  method finally (line 1379) | finally() {
  method process (line 1383) | process() {
  method access (line 1473) | access(ctx) {
  method finally (line 1477) | finally(ctx) {
  method process (line 1480) | process(ctx) {
  method load (line 1533) | async load(ctx) {
  function meta (line 1546) | function meta(time: number): object {
  method load (line 1561) | load() {
  method load (line 1567) | load() {
  method load (line 1573) | load() {
  function meta (line 1598) | function meta(time: number): object {
  method load (line 1619) | load() {
  method process (line 1628) | process(ctx, action) {
  method resend (line 1631) | resend(ctx, action) {
  method load (line 1665) | load() {
  method process (line 1671) | process(ctx, action, meta) {
  method accessAndProcess (line 1700) | async accessAndProcess(ctx, action, meta) {
  method accessAndProcess (line 1707) | async accessAndProcess(ctx, action, meta) {
  method accessAndLoad (line 1716) | async accessAndLoad(ctx, action, meta) {
  method accessAndLoad (line 1723) | accessAndLoad(ctx, action, meta) {
  method accessAndProcess (line 1781) | async accessAndProcess(ctx) {
  method accessAndProcess (line 1786) | async accessAndProcess(ctx, action) {
  method accessAndProcess (line 1833) | accessAndProcess() {
  method accessAndProcess (line 1838) | accessAndProcess() {
  method accessAndProcess (line 1843) | async accessAndProcess() {
  method accessAndLoad (line 1908) | accessAndLoad() {
  method accessAndLoad (line 1913) | accessAndLoad() {
  method accessAndLoad (line 1918) | accessAndLoad() {
  method accessAndLoad (line 1923) | accessAndLoad() {
  method accessAndLoad (line 2000) | accessAndLoad() {
  method process (line 2035) | process() {
  method process (line 2045) | async process() {
  method process (line 2057) | process() {
  method process (line 2067) | process() {
  method process (line 2170) | process() {
  method process (line 2181) | async process() {
  method process (line 2192) | process() {
  method access (line 2220) | async access() {
  method process (line 2225) | async process() {
  method resend (line 2229) | async resend() {
  method access (line 2236) | async access() {
  method process (line 2240) | async process() {
  method resend (line 2243) | async resend() {
  method access (line 2318) | async access() {
  method process (line 2321) | async process() {
  method access (line 2331) | async access() {
  method process (line 2334) | async process() {
  method access (line 2344) | async access() {
  method process (line 2348) | async process() {
  method access (line 2357) | async access() {
  method process (line 2360) | async process() {
  method access (line 2367) | async access() {
  method process (line 2370) | async process() {
  class OtherNode (line 2478) | class OtherNode extends FilteredNode {
    method syncSinceQuery (line 2479) | syncSinceQuery(): { added: number; entries: [Action, Meta][] } {

FILE: server/errors.ts
  class User (line 19) | class User {
    method constructor (line 23) | constructor(id: string) {
    method save (line 28) | async save(): Promise<void> {}
  type UserRenameAction (line 31) | type UserRenameAction = Action & {
  type UserSubscribeAction (line 37) | type UserSubscribeAction = LoguxSubscribeAction & {
  type UserData (line 41) | type UserData = {
  type UserParams (line 45) | type UserParams = {
  type BadParams (line 49) | type BadParams = number
  method access (line 52) | access(ctx, action) {
  method resend (line 58) | resend(_, action) {
  method process (line 64) | async process(ctx, action) {
  method process (line 76) | async process(_, action) {
  method access (line 85) | access() {
  method access (line 91) | access() {
  method filter (line 95) | async filter(_, action) {
  method load (line 106) | async load(ctx) {
  method access (line 116) | access(ctx, action, meta) {
  method access (line 125) | access() {
  method access (line 135) | access(ctx, action) {

FILE: server/index.d.ts
  type LogStream (line 7) | interface LogStream {
  type LoggerOptions (line 16) | interface LoggerOptions {
  type ServerOptions (line 33) | interface ServerOptions extends BaseServerOptions {
  class Server (line 64) | class Server<

FILE: server/index.js
  class Server (line 48) | class Server extends BaseServer {
    method constructor (line 49) | constructor(opts = {}) {
    method loadOptions (line 96) | static loadOptions(process, defaults) {
    method autoloadModules (line 119) | async autoloadModules(
    method listen (line 148) | async listen(...args) {

FILE: server/index.test.ts
  constant ROOT (line 8) | const ROOT = join(import.meta.dirname, '..')
  constant DATE (line 9) | const DATE = /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/g
  function start (line 13) | function start(name: string, args?: string[]): Promise<void> {
  function check (line 28) | function check(
  function fakeProcess (line 68) | function fakeProcess(argv: string[] = [], env: object = {}): any {
  function checkOut (line 72) | async function checkOut(
  function checkError (line 86) | async function checkError(

FILE: server/types.ts
  class User (line 17) | class User {
    method constructor (line 21) | constructor(id: string) {
    method save (line 26) | async save(): Promise<void> {}
  type UserRenameAction (line 29) | type UserRenameAction = {
  type UserSubscribeAction (line 35) | type UserSubscribeAction = {
  type UserData (line 39) | type UserData = {
  type UserParams (line 43) | type UserParams = {
  method access (line 48) | access(ctx, action, meta) {
  method process (line 54) | async process(ctx, action) {
  method resend (line 59) | resend(ctx, action) {
  method access (line 67) | access(ctx, action, meta) {
  method filter (line 72) | filter(ctx, action) {
  method load (line 83) | async load(ctx) {
  method access (line 98) | access(ctx, action, meta) {
  method access (line 113) | access(ctx, action) {

FILE: test-client/index.d.ts
  class LoguxActionError (line 16) | class LoguxActionError extends Error {
  type TestClientOptions (line 20) | interface TestClientOptions {
  class TestClient (line 69) | class TestClient {

FILE: test-client/index.js
  class TestClient (line 7) | class TestClient {
    method constructor (line 8) | constructor(server, userId, opts = {}) {
    method collect (line 46) | async collect(test) {
    method connect (line 58) | connect() {
    method disconnect (line 79) | disconnect() {
    method process (line 84) | process(action, meta) {
    method received (line 136) | async received(test) {
    method subscribe (line 149) | async subscribe(channel, filter, since) {
    method unsubscribe (line 164) | unsubscribe(channel, filter) {

FILE: test-client/index.test.ts
  function catchError (line 14) | async function catchError(cb: () => Promise<any>): Promise<LoguxActionEr...
  function privateMethods (line 25) | function privateMethods(obj: object): any {
  method process (line 47) | process(ctx) {
  method process (line 95) | process() {
  method process (line 104) | process(ctx, action, meta) {
  method load (line 200) | load(ctx, action) {
  method write (line 249) | write() {}
  method process (line 317) | process(ctx) {

FILE: test-server/index.d.ts
  type TestServerOptions (line 12) | interface TestServerOptions extends Omit<
  class TestServer (line 50) | class TestServer<

FILE: test-server/index.js
  class TestServer (line 8) | class TestServer extends BaseServer {
    method constructor (line 9) | constructor(opts = {}) {
    method connect (line 42) | async connect(userId, opts = {}) {
    method expectDenied (line 48) | async expectDenied(test) {
    method expectError (line 52) | async expectError(text, test) {
    method expectUndo (line 66) | async expectUndo(reason, test) {
    method expectWrongCredentials (line 85) | async expectWrongCredentials(userId, opts = {}) {
    method fetch (line 96) | async fetch(path, init) {
    method isBruteforce (line 108) | isBruteforce() {