spec-3nweb-server 1.6.4 → 1.7.1

package/build/config/cli/signup-cmd.js

@@ -0,0 +1,194 @@
+"use strict";
+/*
+ Copyright (C) 2023 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSignupArgs = exports.signupCmd = void 0;
+const utils_1 = require("./utils");
+exports.signupCmd = {
+    name: 'signup',
+    summary: 'controls adding new users to this instance'
+};
+function signupUsage(execName) {
+    return [
+        {
+            content: `This command controls parameters of adding new users to this instance.`
+        },
+        {
+            header: 'Usage:',
+            content: `${execName} ${exports.signupCmd.name} [command] [options] [config_file]`
+        },
+        {
+            header: 'Available commands:',
+            content: [
+                infoCmd,
+                listTokensCmd,
+                showTokenCmd,
+                createTokenCmd
+            ]
+        },
+        {
+            header: `${infoCmd.name} options:`,
+            optionList: infoOpts
+        },
+        {
+            header: `${listTokensCmd.name} options:`,
+            optionList: listTokensOpts
+        },
+        {
+            header: `${showTokenCmd.name} options:`,
+            optionList: showTokenOpts
+        },
+        {
+            header: `${createTokenCmd.name} options:`,
+            optionList: createTokenOpts
+        }
+    ];
+}
+const configOpt = {
+    name: 'config',
+    alias: 'c',
+    type: String,
+    typeLabel: '{underline <file>}',
+    description: `path of a configuration yaml file`
+};
+const infoCmd = {
+    name: 'info',
+    summary: 'shows state of signup subsystem'
+};
+const infoOpts = [
+    configOpt
+];
+const listTokensCmd = {
+    name: 'list-tokens',
+    summary: 'lists signup tokens'
+};
+const listTokensOpts = [
+    configOpt
+];
+const showTokenCmd = {
+    name: 'show-token',
+    summary: 'shows signup token with complete value'
+};
+const showTokenOpts = [
+    configOpt,
+    {
+        name: 'token',
+        alias: 't',
+        type: String,
+        typeLabel: '{underline <token_id>}',
+        description: `token id`
+    }
+];
+const createTokenCmd = {
+    name: 'create-token',
+    summary: 'creates signup token for single user, when user id is given, and for many users, when domain(s) are given'
+};
+const createTokenOpts = [
+    configOpt,
+    {
+        name: 'domain',
+        alias: 'd',
+        type: String,
+        typeLabel: '{underline <domain>}',
+        multiple: true,
+        description: `domain for new users. Several domain options will attach all domains to same token.`
+    },
+    {
+        name: 'user',
+        alias: 'u',
+        type: String,
+        typeLabel: '{underline <user_address>}',
+        description: `address of a single user`
+    }
+];
+function parseWithConfFile(args, optList) {
+    const opts = (0, utils_1.parseArgv)(args, optList, { partial: true });
+    if (opts.config) {
+        return opts;
+    }
+    else if (opts._unknown) {
+        opts.config = opts._unknown[0];
+        return opts;
+    }
+    else {
+        return;
+    }
+}
+function cmdUsageErr(execName, cmd, errTxt = `missing configuration file`) {
+    return (0, utils_1.toUsageDisplay)(-1, (0, utils_1.toErrorUsage)(signupUsage(execName), `Incorrect options for command '${exports.signupCmd.name} ${cmd}': ${errTxt}`));
+}
+function parseSignupArgs(args, execName) {
+    if (args.length === 0) {
+        return (0, utils_1.toUsageDisplay)(0, signupUsage(execName));
+    }
+    if (args[0] === infoCmd.name) {
+        const signupCmd = parseWithConfFile(args.slice(1), infoOpts);
+        if (signupCmd) {
+            signupCmd.info = true;
+            return { signupCmd };
+        }
+        else {
+            return cmdUsageErr(execName, infoCmd.name);
+        }
+    }
+    else if (args[0] === listTokensCmd.name) {
+        const signupCmd = parseWithConfFile(args.slice(1), listTokensOpts);
+        if (signupCmd) {
+            signupCmd.listTokens = true;
+            return { signupCmd };
+        }
+        else {
+            return cmdUsageErr(execName, listTokensCmd.name);
+        }
+    }
+    else if (args[0] === showTokenCmd.name) {
+        const signupCmd = parseWithConfFile(args.slice(1), showTokenOpts);
+        if (signupCmd) {
+            if (!signupCmd.token) {
+                return cmdUsageErr(execName, showTokenCmd.name, `missing token`);
+            }
+            signupCmd.showToken = true;
+            return { signupCmd };
+        }
+        else {
+            return cmdUsageErr(execName, showTokenCmd.name);
+        }
+    }
+    else if (args[0] === createTokenCmd.name) {
+        console.log(args);
+        const signupCmd = parseWithConfFile(args.slice(1), createTokenOpts);
+        if (signupCmd) {
+            if (!signupCmd.domain && !signupCmd.user) {
+                return cmdUsageErr(execName, createTokenCmd.name, `either user address, or domain(s) should be given`);
+            }
+            signupCmd.createToken = true;
+            return { signupCmd };
+        }
+        else {
+            return cmdUsageErr(execName, createTokenCmd.name);
+        }
+    }
+    else {
+        const opts = (0, utils_1.parseArgv)(args, [utils_1.helpOpt], { partial: true });
+        if (opts.help) {
+            return (0, utils_1.toUsageDisplay)(0, signupUsage(execName));
+        }
+        return (0, utils_1.toUsageDisplay)(-1, (0, utils_1.toErrorUsage)(signupUsage(execName), `Unknown command '${args[0]}'`));
+    }
+}
+exports.parseSignupArgs = parseSignupArgs;
+Object.freeze(exports);

package/build/config/cli/user-cmd.d.ts

@@ -0,0 +1,9 @@
+import { CliUsageDisplay, CommandDef } from "./utils";
+export declare const userCmd: CommandDef<'user'>;
+export interface ParsedUserArgs {
+    listAll?: true;
+}
+export declare function parseSignupArgs(args: string[], execName: string): {
+    userCmd?: ParsedUserArgs;
+    showUsage?: CliUsageDisplay;
+};

package/build/config/cli/user-cmd.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ Copyright (C) 2023 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSignupArgs = exports.userCmd = void 0;
+const utils_1 = require("./utils");
+exports.userCmd = {
+    name: 'user',
+    summary: 'provides information about existing users'
+};
+const listCmd = {
+    name: 'list',
+    summary: `lists users`
+};
+function userUsage(execName) {
+    return [
+        {
+            header: execName,
+            content: `Server of all 3NWeb utilities: MailerId, ASMail, 3NStorage.`
+        },
+        {
+            header: `Usage:`,
+            content: `${execName} user [command]`
+        },
+        {
+            header: 'Available commands:',
+            content: []
+        },
+        {
+            content: `Use "${execName} user [command] --help" for more information about a command.`
+        }
+    ];
+}
+function parseSignupArgs(args, execName) {
+    if (args.length === 0) {
+        return (0, utils_1.toUsageDisplay)(0, userUsage(execName));
+    }
+    // XXX
+    return {};
+}
+exports.parseSignupArgs = parseSignupArgs;

package/build/config/cli/utils.d.ts

@@ -0,0 +1,45 @@
+export interface CommandDef<T extends string> {
+    name: T;
+    summary: string;
+}
+export interface OptionDef {
+    name: string;
+    type: (typeof Boolean) | (typeof String) | (typeof Number) | ((value: string) => any);
+    alias?: string;
+    description?: string;
+    typeLabel?: string;
+    multiple?: boolean;
+    defaultOption?: boolean;
+}
+export interface UsageSection {
+    header?: string;
+    summary?: string;
+    optionList?: OptionDef[];
+    content?: string | UsageSectionContent | (string | UsageSection)[];
+}
+export interface UsageSectionContent {
+    options: any;
+    data: any;
+}
+export interface ParseOptions {
+    argv?: string[];
+    partial?: boolean;
+    stopAtFirstUnknown?: boolean;
+    camelCase?: boolean;
+    caseInsensitive?: boolean;
+}
+export interface CliUsageDisplay {
+    txtToDisplay: string;
+    exitStatus: number;
+}
+export declare const helpOpt: OptionDef;
+export interface HelpArg {
+    help?: boolean;
+}
+export declare function toUsageDisplay(exitStatus: number, usage: UsageSection[]): {
+    showUsage: CliUsageDisplay;
+};
+export declare function parseArgv<T>(argv: string[], argOpts: OptionDef[], opts?: ParseOptions): T & {
+    _unknown?: string[];
+};
+export declare function toErrorUsage(usage: UsageSection[], errTxt: string): UsageSection[];

package/build/config/cli/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+ Copyright (C) 2023 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toErrorUsage = exports.parseArgv = exports.toUsageDisplay = exports.helpOpt = void 0;
+const commandLineArgs = require("command-line-args");
+const commandLineUsage = require("command-line-usage");
+exports.helpOpt = {
+    name: 'help',
+    alias: 'h',
+    type: Boolean,
+    description: 'shows help'
+};
+function toUsageDisplay(exitStatus, usage) {
+    return {
+        showUsage: {
+            txtToDisplay: commandLineUsage(usage),
+            exitStatus
+        }
+    };
+}
+exports.toUsageDisplay = toUsageDisplay;
+function parseArgv(argv, argOpts, opts) {
+    if (opts) {
+        opts.argv = argv;
+    }
+    else {
+        opts = { argv };
+    }
+    return commandLineArgs(argOpts, opts);
+}
+exports.parseArgv = parseArgv;
+function toErrorUsage(usage, errTxt) {
+    usage[0] = { content: errTxt };
+    return usage;
+}
+exports.toErrorUsage = toErrorUsage;
+Object.freeze(exports);

package/build/config/from-yaml.d.ts

@@ -0,0 +1,2 @@
+import { Configurations } from '../services';
+export declare function readYamlConfFile(path: string): Configurations;

package/build/config/from-yaml.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ Copyright (C) 2023 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readYamlConfFile = void 0;
+const fs_1 = require("fs");
+const yaml = require("js-yaml");
+function readYamlConfFile(path) {
+    const txt = (0, fs_1.readFileSync)(path, 'utf8');
+    const conf = yaml.load(txt);
+    return conf;
+}
+exports.readYamlConfFile = readYamlConfFile;
+Object.freeze(exports);

package/build/config/letsencrypt.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { ServerOptions } from "https";
+export type CertsUpdateListener = (newOpts: ServerOptions, originalOpts: ServerOptions) => Promise<void>;
+export declare function sslOptsFromConfig(letsencrypt: string | undefined, sslOpts: ServerOptions | undefined, skipReloadOnCertsChange: boolean | undefined): {
+    sslOpts: ServerOptions;
+    onCertsUpdate?: (listener: CertsUpdateListener) => (() => void);
+} | undefined;

package/build/config/letsencrypt.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ Copyright (C) 2023 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sslOptsFromConfig = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function sslOptsFromConfig(letsencrypt, sslOpts, skipReloadOnCertsChange) {
+    if (!sslOpts) {
+        sslOpts = {};
+    }
+    if (letsencrypt) {
+        sslOpts.cert = (0, fs_1.readFileSync)((0, path_1.join)(letsencrypt, 'fullchain.pem'));
+        sslOpts.key = (0, fs_1.readFileSync)((0, path_1.join)(letsencrypt, 'privkey.pem'));
+        if (skipReloadOnCertsChange) {
+            return { sslOpts };
+        }
+        const onCertsUpdate = makeCertsUpdatesWatch();
+        return { sslOpts, onCertsUpdate };
+    }
+    else if (sslOpts.cert && sslOpts.key) {
+        sslOpts.cert = (0, fs_1.readFileSync)(sslOpts.cert);
+        sslOpts.key = (0, fs_1.readFileSync)(sslOpts.key);
+        if (skipReloadOnCertsChange) {
+            return { sslOpts };
+        }
+        const onCertsUpdate = makeCertsUpdatesWatch();
+        return { sslOpts, onCertsUpdate };
+    }
+    else if ((!sslOpts.cert && sslOpts.key)
+        || (sslOpts.cert && !sslOpts.key)) {
+        throw new Error(`servicesConnect.sslOpts section must have both key and cert fields pointing to respective files.`);
+    }
+    else {
+        return;
+    }
+}
+exports.sslOptsFromConfig = sslOptsFromConfig;
+function makeCertsUpdatesWatch(
+// XXX pass locations, or some fs watching object
+) {
+    return listener => {
+        // XXX start watching a signal
+        const stopWatching = () => { };
+        return stopWatching;
+    };
+}
+Object.freeze(exports);

package/build/config/signup.d.ts

@@ -0,0 +1,15 @@
+import { MultiDomainSignupCtx, SingleUserSignupCtx } from "../admin/signup-tokens";
+export declare function addSingleUserSignup(rootFolder: string, userId: string): Promise<string>;
+export declare function addMultiDomainSignup(rootFolder: string, domains: string[]): Promise<string>;
+export declare function readNoTokensFile(noTokenFile: string): Promise<MultiDomainSignupCtx>;
+export declare function readTokenFile(rootFolder: string, tokenId: string): Promise<SingleUserSignupCtx | MultiDomainSignupCtx | undefined>;
+export declare function readAllSignupTokens(rootFolder: string): Promise<{
+    singleUserTokens: {
+        tokenId: string;
+        ctx: SingleUserSignupCtx;
+    }[];
+    multiUserTokens: {
+        tokenId: string;
+        ctx: MultiDomainSignupCtx;
+    }[];
+}>;

package/build/config/signup.js

@@ -0,0 +1,133 @@
+"use strict";
+/*
+ Copyright (C) 2019 - 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAllSignupTokens = exports.readTokenFile = exports.readNoTokensFile = exports.addMultiDomainSignup = exports.addSingleUserSignup = void 0;
+const async_fs_node_1 = require("../lib-common/async-fs-node");
+const signup_tokens_1 = require("../admin/signup-tokens");
+const server_data_folders_1 = require("../lib-server/resources/server-data-folders");
+const error_1 = require("../lib-common/exceptions/error");
+const path_1 = require("path");
+async function addSingleUserSignup(rootFolder, userId) {
+    const token = await (0, signup_tokens_1.generateToken)();
+    const ctx = (0, signup_tokens_1.makeSingleUserSignupCtx)(token, userId);
+    const fPath = (0, signup_tokens_1.tokenPath)(rootFolder, token);
+    try {
+        await (0, async_fs_node_1.writeFile)(fPath, JSON.stringify(ctx), { encoding: 'utf8', flag: 'wx' });
+        return token;
+    }
+    catch (exc) {
+        if (exc.alreadyExists) {
+            return addSingleUserSignup(rootFolder, userId);
+        }
+        else if (exc.notFound) {
+            await (0, async_fs_node_1.mkdir)((0, server_data_folders_1.tokensInRootFolder)(rootFolder))
+                .catch((exc) => {
+                if (!exc.alreadyExists) {
+                    throw exc;
+                }
+            });
+            return addSingleUserSignup(rootFolder, userId);
+        }
+        else {
+            throw exc;
+        }
+    }
+}
+exports.addSingleUserSignup = addSingleUserSignup;
+async function addMultiDomainSignup(rootFolder, domains) {
+    const token = await (0, signup_tokens_1.generateToken)();
+    const ctx = (0, signup_tokens_1.makeMultiDomainSignupCtx)(domains, token);
+    const fPath = (0, signup_tokens_1.tokenPath)(rootFolder, token);
+    try {
+        await (0, async_fs_node_1.writeFile)(fPath, JSON.stringify(ctx), { encoding: 'utf8', flag: 'wx' });
+        return token;
+    }
+    catch (exc) {
+        if (exc.alreadyExists) {
+            return addMultiDomainSignup(rootFolder, domains);
+        }
+        else if (exc.notFound) {
+            await (0, async_fs_node_1.mkdir)((0, server_data_folders_1.tokensInRootFolder)(rootFolder))
+                .catch((exc) => {
+                if (!exc.alreadyExists) {
+                    throw exc;
+                }
+            });
+            return addMultiDomainSignup(rootFolder, domains);
+        }
+        else {
+            throw exc;
+        }
+    }
+}
+exports.addMultiDomainSignup = addMultiDomainSignup;
+async function readNoTokensFile(noTokenFile) {
+    try {
+        const str = await (0, async_fs_node_1.readFile)(noTokenFile, { encoding: 'utf8' });
+        return JSON.parse(str);
+    }
+    catch (err) {
+        throw (0, error_1.errWithCause)(err, `Fail to read "no tokens" signup context file ${noTokenFile}`);
+    }
+}
+exports.readNoTokensFile = readNoTokensFile;
+async function readTokenFile(rootFolder, tokenId) {
+    try {
+        const fPath = (0, path_1.join)((0, server_data_folders_1.tokensInRootFolder)(rootFolder), tokenId);
+        const str = await (0, async_fs_node_1.readFile)(fPath, { encoding: 'utf8' });
+        const ctx = JSON.parse(str);
+        if (!ctx.token) {
+            return;
+        }
+        else if (ctx.type === 'multi-domain') {
+            return (ctx.domains ? ctx : undefined);
+        }
+        else if (ctx.type === 'single-user') {
+            return (ctx.userId ? ctx : undefined);
+        }
+        else {
+            return;
+        }
+    }
+    catch (err) {
+        console.error(err);
+        return;
+    }
+}
+exports.readTokenFile = readTokenFile;
+async function readAllSignupTokens(rootFolder) {
+    const singleUserTokens = [];
+    const multiUserTokens = [];
+    const tokenIds = await (0, async_fs_node_1.readdir)((0, server_data_folders_1.tokensInRootFolder)(rootFolder));
+    for (const tokenId of tokenIds) {
+        const ctx = await readTokenFile(rootFolder, tokenId);
+        if (!ctx) {
+            continue;
+        }
+        if (ctx.type === 'multi-domain') {
+            multiUserTokens.push({ tokenId, ctx });
+        }
+        else {
+            singleUserTokens.push({ tokenId, ctx });
+        }
+    }
+    return { multiUserTokens, singleUserTokens };
+}
+exports.readAllSignupTokens = readAllSignupTokens;
+// XXX external qrencode command can be used to display QR code
+Object.freeze(exports);

package/build/lib-common/byte-streaming/common.d.ts

@@ -1,6 +1,6 @@
-export declare type ByteSource = web3n.ByteSource;
+export type ByteSource = web3n.ByteSource;
 export declare function wrapByteSourceImplementation(src: ByteSource): ByteSource;
-export declare type ByteSink = web3n.ByteSink;
+export type ByteSink = web3n.ByteSink;
 export declare function wrapByteSinkImplementation(sink: ByteSink): ByteSink;
 export declare class BytesFIFOBuffer {
     private queue;

package/build/lib-common/byte-streaming/common.js

@@ -45,17 +45,17 @@ function wrapByteSinkImplementation(sink) {
 }
 exports.wrapByteSinkImplementation = wrapByteSinkImplementation;
 class BytesFIFOBuffer {
-    constructor() {
-        this.queue = [];
-        this.bytesLen = 0;
-        Object.seal(this);
-    }
     get length() {
         return this.bytesLen;
     }
     get queueLength() {
         return this.queue.length;
     }
+    constructor() {
+        this.queue = [];
+        this.bytesLen = 0;
+        Object.seal(this);
+    }
     clear() {
         this.queue = [];
         this.bytesLen = 0;

package/build/lib-common/exceptions/file.d.ts

@@ -1,6 +1,6 @@
 export declare const fileExceptionType = "file";
 export declare const Code: web3n.files.exceptionCode;
-export declare type FileException = web3n.files.FileException;
+export type FileException = web3n.files.FileException;
 export declare function makeFileException(code: string | undefined, path: string, cause?: any): FileException;
 export declare function maskPathInExc(pathPrefixMaskLen: number, exc: any): FileException;
 export declare function ensureCorrectFS(fs: web3n.files.FS, type: web3n.files.FSType, writable: boolean): void;

package/build/lib-common/ipc/generic-ipc.d.ts

@@ -1,12 +1,12 @@
 import { Envelope } from '../service-api/ipc-api';
 export { Envelope, EventEnvelope, EventEndEnvelope, EventException, RequestEnvelope, ReplyEnvelope } from '../service-api/ipc-api';
-export declare type RequestHandler<TReq, TRes> = web3n.ipc.RequestHandler<TReq, TRes>;
-export declare type RequestingClient = web3n.ipc.RequestingClient;
-export declare type RequestServer = web3n.ipc.RequestServer;
-export declare type EventfulServer = web3n.ipc.EventfulServer;
-export declare type SubscribingClient = web3n.ipc.SubscribingClient;
-export declare type Observer<T> = web3n.Observer<T>;
-export declare type RawDuplex<T> = web3n.ipc.RawDuplex<T>;
+export type RequestHandler<TReq, TRes> = web3n.ipc.RequestHandler<TReq, TRes>;
+export type RequestingClient = web3n.ipc.RequestingClient;
+export type RequestServer = web3n.ipc.RequestServer;
+export type EventfulServer = web3n.ipc.EventfulServer;
+export type SubscribingClient = web3n.ipc.SubscribingClient;
+export type Observer<T> = web3n.Observer<T>;
+export type RawDuplex<T> = web3n.ipc.RawDuplex<T>;
 export declare function makeRequestingClient(channel: string | undefined, comm: RawDuplex<Envelope>): RequestingClient;
 export declare function makeRequestServer(channel: string | undefined, comm: RawDuplex<Envelope>): RequestServer;
 export declare function makeEventfulServer(channel: string | undefined, comm: RawDuplex<Envelope>): EventfulServer;