@ddd-qc/cell-proxy 0.10.0 → 0.10.1

package/README.md

@@ -1,8 +1,8 @@
 # cell-proxy
 
 **Compatible with:**
-- **HDK v0.1.0-beta-rc.1** & **HDI v0.2.0-beta-rc.2**
-- **@holochain/client v0.11.2**
+- **HDK v0.1.0-beta-rc.1** & **HDI v0.2.0-beta-rc.1**
+- **@holochain/client v0.11.9**
 - 
 Proxy classes and helpers for managing a [Holochain](https://www.npmjs.com/package/@holochain/client) AppWebsocket and calling zome functions on cells.
 The intent is to make the development of web UI of Holochain apps in javascript / typescript faster & easier by providing a straightforward API for communicating with a Conductor, and some basic logging features.

package/dist/CellProxy.d.ts

@@ -1,58 +1,58 @@
-import { CallZomeRequest, CapSecret, ZomeName, Cell } from "@holochain/client";
-import { ConductorAppProxy } from "./ConductorAppProxy";
-import { Empty } from "./mixins";
-export interface RequestLog {
-    request: CallZomeRequest;
-    timeout: number;
-    requestTimestamp: number;
-    executionTimestamp: number;
-}
-export interface ResponseLog {
-    success?: any;
-    failure?: any;
-    timestamp: number;
-    requestIndex: number;
-}
-declare const CellProxy_base: (abstract new (...args: any[]) => {
-    _cell?: Cell;
-    readonly cell: Cell;
-    readonly cellId: import("@holochain/client").CellId;
-    readonly dnaHash: string;
-    readonly agentPubKey: string; /** -- Fields -- */
-}) & typeof Empty;
-/**
- * Proxy for a running DNA.
- * It logs and queues ZomeCalls.
- * It holds a reference to its ConductorAppProxy and its InstalledCell.
- * This class is expected to be used by ZomeProxies.
- */
-export declare class CellProxy extends CellProxy_base {
-    private _conductor;
-    /** Ctor */
-    constructor(_conductor: ConductorAppProxy, cell: Cell, defaultTimeout?: number);
-    /** -- Fields -- */
-    defaultTimeout: number;
-    /** append only logs */
-    private _requestLog;
-    private _responseLog;
-    private _canCallBlocking;
-    /** -- Methods -- */
-    dumpSignals(): void;
-    /** Pass call request to conductor proxy and log it */
-    executeZomeCall(reqLog: RequestLog): Promise<ResponseLog>;
-    /**
-     * callZome() with "Mutex" (for calls that writes to source-chain)
-     * TODO: Implement call queue instead of mutex
-     */
-    callZomeBlocking(zome_name: ZomeName, fn_name: string, payload: any, cap_secret: CapSecret | null, timeout?: number): Promise<any>;
-    /** */
-    callZome(zome_name: ZomeName, fn_name: string, payload: any, cap_secret: CapSecret | null, timeout?: number): Promise<any>;
-    /**
-     * Calls the `entry_defs()` zome function and
-     * returns an array of all the zome's AppEntryDefNames and visibility
-     */
-    callEntryDefs(zomeName: ZomeName): Promise<[string, boolean][]>;
-    /**  */
-    dumpLogs(zomeName?: ZomeName): void;
-}
-export {};
+import { CallZomeRequest, CapSecret, ZomeName, Cell } from "@holochain/client";
+import { ConductorAppProxy } from "./ConductorAppProxy";
+import { Empty } from "./mixins";
+export interface RequestLog {
+    request: CallZomeRequest;
+    timeout: number;
+    requestTimestamp: number;
+    executionTimestamp: number;
+}
+export interface ResponseLog {
+    success?: any;
+    failure?: any;
+    timestamp: number;
+    requestIndex: number;
+}
+declare const CellProxy_base: (abstract new (...args: any[]) => {
+    _cell?: Cell;
+    readonly cell: Cell;
+    readonly cellId: import("@holochain/client").CellId;
+    readonly dnaHash: string;
+    readonly agentPubKey: string; /** -- Fields -- */
+}) & typeof Empty;
+/**
+ * Proxy for a running DNA.
+ * It logs and queues ZomeCalls.
+ * It holds a reference to its ConductorAppProxy and its InstalledCell.
+ * This class is expected to be used by ZomeProxies.
+ */
+export declare class CellProxy extends CellProxy_base {
+    private _conductor;
+    /** Ctor */
+    constructor(_conductor: ConductorAppProxy, cell: Cell, defaultTimeout?: number);
+    /** -- Fields -- */
+    defaultTimeout: number;
+    /** append only logs */
+    private _requestLog;
+    private _responseLog;
+    private _canCallBlocking;
+    /** -- Methods -- */
+    dumpSignals(): void;
+    /** Pass call request to conductor proxy and log it */
+    executeZomeCall(reqLog: RequestLog): Promise<ResponseLog>;
+    /**
+     * callZome() with "Mutex" (for calls that writes to source-chain)
+     * TODO: Implement call queue instead of mutex
+     */
+    callZomeBlocking(zome_name: ZomeName, fn_name: string, payload: any, cap_secret: CapSecret | null, timeout?: number): Promise<any>;
+    /** */
+    callZome(zome_name: ZomeName, fn_name: string, payload: any, cap_secret: CapSecret | null, timeout?: number): Promise<any>;
+    /**
+     * Calls the `entry_defs()` zome function and
+     * returns an array of all the zome's AppEntryDefNames and visibility
+     */
+    callEntryDefs(zomeName: ZomeName): Promise<[string, boolean][]>;
+    /**  */
+    dumpLogs(zomeName?: ZomeName): void;
+}
+export {};

package/dist/CellProxy.js

@@ -1,166 +1,166 @@
-import { __awaiter } from "tslib";
-import { encodeHashToBase64 } from "@holochain/client";
-import { anyToB64, delay, prettyDate, prettyDuration } from "./utils";
-import { CellMixin, Empty } from "./mixins";
-/**
- * Proxy for a running DNA.
- * It logs and queues ZomeCalls.
- * It holds a reference to its ConductorAppProxy and its InstalledCell.
- * This class is expected to be used by ZomeProxies.
- */
-export class CellProxy extends CellMixin(Empty) {
-    /** Ctor */
-    constructor(_conductor, cell, 
-    //public readonly dnaDef: MyDnaDef,
-    defaultTimeout) {
-        super();
-        this._conductor = _conductor;
-        //private _blockingRequestQueue: Queue<RequestLog> = new Queue();
-        /** append only logs */
-        this._requestLog = [];
-        this._responseLog = [];
-        this._canCallBlocking = true;
-        this._cell = cell;
-        console.log(`CellProxy.ctor`, cell);
-        this.defaultTimeout = defaultTimeout ? defaultTimeout : 10 * 1000;
-    }
-    // /** -- ICell interface -- */
-    //
-    // get dnaHash(): DnaHashB64 { return encodeHashToBase64(this.cell.cell_id[0]) }
-    // get agentPubKey(): AgentPubKeyB64 { return encodeHashToBase64(this.cell.cell_id[1]) }
-    /** -- Methods -- */
-    // /** */
-    // addSignalHandler(handler: AppSignalCb): SignalUnsubscriber {
-    //   return this._conductor.addSignalHandler(handler, this.cellId);
-    // }
-    dumpSignals() {
-        this._conductor.dumpSignals(this.cell.cell_id);
-    }
-    /** Pass call request to conductor proxy and log it */
-    executeZomeCall(reqLog) {
-        return __awaiter(this, void 0, void 0, function* () {
-            reqLog.executionTimestamp = Date.now();
-            const requestIndex = this._requestLog.length;
-            this._requestLog.push(reqLog);
-            try {
-                const response = yield this._conductor.callZome(reqLog.request, reqLog.timeout);
-                const respLog = { requestIndex, success: response, timestamp: Date.now() };
-                this._responseLog.push(respLog);
-                return respLog;
-            }
-            catch (e) {
-                const respLog = { requestIndex, failure: e, timestamp: Date.now() };
-                this._responseLog.push(respLog);
-                return respLog;
-            }
-        });
-    }
-    /**
-     * callZome() with "Mutex" (for calls that writes to source-chain)
-     * TODO: Implement call queue instead of mutex
-     */
-    callZomeBlocking(zome_name, fn_name, payload, cap_secret, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            timeout = timeout ? timeout : this.defaultTimeout;
-            const req = {
-                cap_secret, zome_name, fn_name, payload,
-                cell_id: this.cell.cell_id,
-                provenance: this.cell.cell_id[1],
-            };
-            const log = { request: req, timeout, requestTimestamp: Date.now() };
-            while (!this._canCallBlocking && Date.now() - log.requestTimestamp < timeout) {
-                yield delay(1);
-            }
-            if (Date.now() - log.requestTimestamp >= timeout) {
-                console.warn({ requestLogs: this._requestLog });
-                return Promise.reject("Waiting for zomeCall execution timed-out");
-            }
-            this._canCallBlocking = false;
-            const respLog = yield this.executeZomeCall(log);
-            this._canCallBlocking = true;
-            if (respLog.failure) {
-                this.dumpSignals();
-                this.dumpLogs(zome_name);
-                return Promise.reject(respLog.failure);
-            }
-            return respLog.success;
-        });
-    }
-    /** */
-    callZome(zome_name, fn_name, payload, cap_secret, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            timeout = timeout ? timeout : this.defaultTimeout;
-            const req = {
-                cap_secret, zome_name, fn_name, payload,
-                cell_id: this.cell.cell_id,
-                provenance: this.cell.cell_id[1],
-            };
-            const log = { request: req, timeout, requestTimestamp: Date.now() };
-            const respLog = yield this.executeZomeCall(log);
-            if (respLog.failure) {
-                this.dumpSignals();
-                this.dumpLogs(zome_name);
-                return Promise.reject(respLog.failure);
-            }
-            return respLog.success;
-        });
-    }
-    /**
-     * Calls the `entry_defs()` zome function and
-     * returns an array of all the zome's AppEntryDefNames and visibility
-     */
-    callEntryDefs(zomeName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //console.log("callEntryDefs()", zomeName)
-            try {
-                const entryDefs = yield this.callZome(zomeName, "entry_defs", null, null, 2 * 1000);
-                //console.debug("getEntryDefs() for " + this.zomeName + " result:")
-                //console.log({entryDefs})
-                let result = [];
-                for (const def of entryDefs.Defs) {
-                    const name = def.id.App;
-                    result.push([name, def.visibility.hasOwnProperty('Public')]);
-                }
-                //console.log({result})
-                return result;
-            }
-            catch (e) {
-                console.error("Calling getEntryDefs() on " + zomeName + " failed: ");
-                console.error({ e });
-                return Promise.reject(e);
-            }
-        });
-    }
-    // /** TODO once we have getDnaDefinition() api */
-    // dumpAllZomes() {
-    //   // FIXME get DNA DEF
-    //   for (const zomeName of dnaDef) {
-    //     this.dumpLogs(zomeName)
-    //   }
-    // }
-    /**  */
-    dumpLogs(zomeName) {
-        let result = [];
-        for (const response of this._responseLog) {
-            const requestLog = this._requestLog[response.requestIndex];
-            if (zomeName && requestLog.request.zome_name != zomeName) {
-                continue;
-            }
-            const startTime = prettyDate(new Date(requestLog.requestTimestamp));
-            const waitTime = prettyDuration(new Date(requestLog.executionTimestamp - requestLog.requestTimestamp));
-            const duration = prettyDuration(new Date(response.timestamp - requestLog.requestTimestamp));
-            const input = requestLog.request.payload instanceof Uint8Array ? encodeHashToBase64(requestLog.request.payload) : requestLog.request.payload;
-            const output = anyToB64(response.failure ? response.failure : response.success);
-            const log = zomeName
-                ? { startTime, fnName: requestLog.request.fn_name, input, output, duration, waitTime }
-                : { startTime, zomeName: requestLog.request.zome_name, fnName: requestLog.request.fn_name, input, output, duration, waitTime };
-            result.push(log);
-        }
-        console.warn(`Dumping logs for cell "${this._conductor.getLocations(this.cellId)}"`);
-        if (zomeName) {
-            console.warn(` - For zome "${zomeName}"`);
-        }
-        console.table(result);
-    }
-}
+import { __awaiter } from "tslib";
+import { encodeHashToBase64 } from "@holochain/client";
+import { anyToB64, delay, prettyDate, prettyDuration } from "./utils";
+import { CellMixin, Empty } from "./mixins";
+/**
+ * Proxy for a running DNA.
+ * It logs and queues ZomeCalls.
+ * It holds a reference to its ConductorAppProxy and its InstalledCell.
+ * This class is expected to be used by ZomeProxies.
+ */
+export class CellProxy extends CellMixin(Empty) {
+    /** Ctor */
+    constructor(_conductor, cell, 
+    //public readonly dnaDef: MyDnaDef,
+    defaultTimeout) {
+        super();
+        this._conductor = _conductor;
+        //private _blockingRequestQueue: Queue<RequestLog> = new Queue();
+        /** append only logs */
+        this._requestLog = [];
+        this._responseLog = [];
+        this._canCallBlocking = true;
+        this._cell = cell;
+        console.log(`CellProxy.ctor`, cell);
+        this.defaultTimeout = defaultTimeout ? defaultTimeout : 10 * 1000;
+    }
+    // /** -- ICell interface -- */
+    //
+    // get dnaHash(): DnaHashB64 { return encodeHashToBase64(this.cell.cell_id[0]) }
+    // get agentPubKey(): AgentPubKeyB64 { return encodeHashToBase64(this.cell.cell_id[1]) }
+    /** -- Methods -- */
+    // /** */
+    // addSignalHandler(handler: AppSignalCb): SignalUnsubscriber {
+    //   return this._conductor.addSignalHandler(handler, this.cellId);
+    // }
+    dumpSignals() {
+        this._conductor.dumpSignals(this.cell.cell_id);
+    }
+    /** Pass call request to conductor proxy and log it */
+    executeZomeCall(reqLog) {
+        return __awaiter(this, void 0, void 0, function* () {
+            reqLog.executionTimestamp = Date.now();
+            const requestIndex = this._requestLog.length;
+            this._requestLog.push(reqLog);
+            try {
+                const response = yield this._conductor.callZome(reqLog.request, reqLog.timeout);
+                const respLog = { requestIndex, success: response, timestamp: Date.now() };
+                this._responseLog.push(respLog);
+                return respLog;
+            }
+            catch (e) {
+                const respLog = { requestIndex, failure: e, timestamp: Date.now() };
+                this._responseLog.push(respLog);
+                return respLog;
+            }
+        });
+    }
+    /**
+     * callZome() with "Mutex" (for calls that writes to source-chain)
+     * TODO: Implement call queue instead of mutex
+     */
+    callZomeBlocking(zome_name, fn_name, payload, cap_secret, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            timeout = timeout ? timeout : this.defaultTimeout;
+            const req = {
+                cap_secret, zome_name, fn_name, payload,
+                cell_id: this.cell.cell_id,
+                provenance: this.cell.cell_id[1],
+            };
+            const log = { request: req, timeout, requestTimestamp: Date.now() };
+            while (!this._canCallBlocking && Date.now() - log.requestTimestamp < timeout) {
+                yield delay(1);
+            }
+            if (Date.now() - log.requestTimestamp >= timeout) {
+                console.warn({ requestLogs: this._requestLog });
+                return Promise.reject("Waiting for zomeCall execution timed-out");
+            }
+            this._canCallBlocking = false;
+            const respLog = yield this.executeZomeCall(log);
+            this._canCallBlocking = true;
+            if (respLog.failure) {
+                this.dumpSignals();
+                this.dumpLogs(zome_name);
+                return Promise.reject(respLog.failure);
+            }
+            return respLog.success;
+        });
+    }
+    /** */
+    callZome(zome_name, fn_name, payload, cap_secret, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            timeout = timeout ? timeout : this.defaultTimeout;
+            const req = {
+                cap_secret, zome_name, fn_name, payload,
+                cell_id: this.cell.cell_id,
+                provenance: this.cell.cell_id[1],
+            };
+            const log = { request: req, timeout, requestTimestamp: Date.now() };
+            const respLog = yield this.executeZomeCall(log);
+            if (respLog.failure) {
+                this.dumpSignals();
+                this.dumpLogs(zome_name);
+                return Promise.reject(respLog.failure);
+            }
+            return respLog.success;
+        });
+    }
+    /**
+     * Calls the `entry_defs()` zome function and
+     * returns an array of all the zome's AppEntryDefNames and visibility
+     */
+    callEntryDefs(zomeName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.log("callEntryDefs()", zomeName)
+            try {
+                const entryDefs = yield this.callZome(zomeName, "entry_defs", null, null, 2 * 1000);
+                //console.debug("getEntryDefs() for " + this.zomeName + " result:")
+                //console.log({entryDefs})
+                let result = [];
+                for (const def of entryDefs.Defs) {
+                    const name = def.id.App;
+                    result.push([name, def.visibility.hasOwnProperty('Public')]);
+                }
+                //console.log({result})
+                return result;
+            }
+            catch (e) {
+                console.error("Calling getEntryDefs() on " + zomeName + " failed: ");
+                console.error({ e });
+                return Promise.reject(e);
+            }
+        });
+    }
+    // /** TODO once we have getDnaDefinition() api */
+    // dumpAllZomes() {
+    //   // FIXME get DNA DEF
+    //   for (const zomeName of dnaDef) {
+    //     this.dumpLogs(zomeName)
+    //   }
+    // }
+    /**  */
+    dumpLogs(zomeName) {
+        let result = [];
+        for (const response of this._responseLog) {
+            const requestLog = this._requestLog[response.requestIndex];
+            if (zomeName && requestLog.request.zome_name != zomeName) {
+                continue;
+            }
+            const startTime = prettyDate(new Date(requestLog.requestTimestamp));
+            const waitTime = prettyDuration(new Date(requestLog.executionTimestamp - requestLog.requestTimestamp));
+            const duration = prettyDuration(new Date(response.timestamp - requestLog.requestTimestamp));
+            const input = requestLog.request.payload instanceof Uint8Array ? encodeHashToBase64(requestLog.request.payload) : requestLog.request.payload;
+            const output = anyToB64(response.failure ? response.failure : response.success);
+            const log = zomeName
+                ? { startTime, fnName: requestLog.request.fn_name, input, output, duration, waitTime }
+                : { startTime, zomeName: requestLog.request.zome_name, fnName: requestLog.request.fn_name, input, output, duration, waitTime };
+            result.push(log);
+        }
+        console.warn(`Dumping logs for cell "${this._conductor.getLocations(this.cellId)}"`);
+        if (zomeName) {
+            console.warn(` - For zome "${zomeName}"`);
+        }
+        console.table(result);
+    }
+}
 //# sourceMappingURL=CellProxy.js.map

package/dist/ConductorAppProxy.d.ts

@@ -1,74 +1,74 @@
-import { AppApi, AppInfoRequest, AppInfoResponse, AppSignal, AppSignalCb, AppWebsocket, CallZomeRequest, CellId, InstalledAppId, InstalledCell, CreateCloneCellRequest, DisableCloneCellRequest, EnableCloneCellRequest, Cell } from "@holochain/client";
-import { CellProxy } from "./CellProxy";
-import { RoleCellsMap, BaseRoleName, CellsForRole } from "./types";
-import { HCL, HCLString } from "./hcl";
-/** */
-export interface SignalUnsubscriber {
-    unsubscribe: () => void;
-}
-/**
- * Creates, connects and holds a appWebsocket.
- * Creates and holds Cell proxies for this appWebsocket.
- * Maintains a mapping between CellIds and HCLs
- * Handles SignalHandlers per HCL
- * Stores appSignal logs
- * TODO Implement Singleton per App port?
- */
-export declare class ConductorAppProxy implements AppApi {
-    defaultTimeout: number;
-    /** -- Fields -- */
-    private _appWs;
-    /** Signal log: [Timestamp, CellIdStr, Signal] */
-    private _signalLogs;
-    /** Map cells per App: InstalledAppId -> (BaseRoleName -> RoleInstalledCells) */
-    private _cellsByApp;
-    /** Map cell locations: CellIdStr -> HCL[] */
-    private _hclMap;
-    /** Store handlers per cell locaiton: HCLString -> AppSignalCb */
-    private _signalHandlers;
-    /** Store cell proxies per cell: CellIdStr -> CellProxy */
-    private _cellProxies;
-    /** -- Getters -- */
-    /** */
-    getAppCells(appId: InstalledAppId): RoleCellsMap | undefined;
-    /** */
-    getLocations(cellId: CellId): HCL[] | undefined;
-    /** */
-    getCell(hcl: HCL): Cell;
-    /** Get stored CellProxy or attempt to create it */
-    getCellProxy(cellIdOrLoc: HCL | CellId): CellProxy;
-    /** */
-    getAppRoles(installedAppId: InstalledAppId): BaseRoleName[] | undefined;
-    /** */
-    getClones(appId: InstalledAppId, baseRoleName: BaseRoleName): Cell[];
-    createCloneCell(request: CreateCloneCellRequest): Promise<InstalledCell>;
-    /** -- AppApi (Passthrough to appWebsocket) -- */
-    enableCloneCell(request: EnableCloneCellRequest): Promise<InstalledCell>;
-    disableCloneCell(request: DisableCloneCellRequest): Promise<void>;
-    appInfo(args: AppInfoRequest): Promise<AppInfoResponse>;
-    callZome(req: CallZomeRequest, timeout?: number): Promise<any>;
-    /** -- Creation -- */
-    /** async Factory */
-    static new(port_or_socket: number | AppWebsocket, defaultTimeout?: number): Promise<ConductorAppProxy>;
-    /** */
-    private static fromSocket;
-    /** Ctor */
-    private constructor();
-    /** -- Methods -- */
-    /** */
-    fetchCell(appId: InstalledAppId, cellId: CellId): Promise<Cell>;
-    /** */
-    fetchCells(appId: InstalledAppId, baseRoleName: BaseRoleName): Promise<CellsForRole>;
-    /** */
-    addClone(hcl: HCL, cloneCell: Cell): void;
-    /** */
-    createCellProxy(hcl: HCL): CellProxy;
-    /** */
-    onSignal(signal: AppSignal): void;
-    /** Store signalHandler to internal handler array */
-    addSignalHandler(handler: AppSignalCb, hcl?: HCLString): SignalUnsubscriber;
-    /** Log all signals received */
-    private logSignal;
-    /** */
-    dumpSignals(cellId?: CellId): void;
-}
+import { AppApi, AppInfoRequest, AppInfoResponse, AppSignal, AppSignalCb, AppWebsocket, CallZomeRequest, CellId, InstalledAppId, InstalledCell, CreateCloneCellRequest, DisableCloneCellRequest, EnableCloneCellRequest, Cell } from "@holochain/client";
+import { CellProxy } from "./CellProxy";
+import { RoleCellsMap, BaseRoleName, CellsForRole } from "./types";
+import { HCL, HCLString } from "./hcl";
+/** */
+export interface SignalUnsubscriber {
+    unsubscribe: () => void;
+}
+/**
+ * Creates, connects and holds a appWebsocket.
+ * Creates and holds Cell proxies for this appWebsocket.
+ * Maintains a mapping between CellIds and HCLs
+ * Handles SignalHandlers per HCL
+ * Stores appSignal logs
+ * TODO Implement Singleton per App port?
+ */
+export declare class ConductorAppProxy implements AppApi {
+    defaultTimeout: number;
+    /** -- Fields -- */
+    private _appWs;
+    /** Signal log: [Timestamp, CellIdStr, Signal] */
+    private _signalLogs;
+    /** Map cells per App: InstalledAppId -> (BaseRoleName -> RoleInstalledCells) */
+    private _cellsByApp;
+    /** Map cell locations: CellIdStr -> HCL[] */
+    private _hclMap;
+    /** Store handlers per cell locaiton: HCLString -> AppSignalCb */
+    private _signalHandlers;
+    /** Store cell proxies per cell: CellIdStr -> CellProxy */
+    private _cellProxies;
+    /** -- Getters -- */
+    /** */
+    getAppCells(appId: InstalledAppId): RoleCellsMap | undefined;
+    /** */
+    getLocations(cellId: CellId): HCL[] | undefined;
+    /** */
+    getCell(hcl: HCL): Cell;
+    /** Get stored CellProxy or attempt to create it */
+    getCellProxy(cellIdOrLoc: HCL | CellId): CellProxy;
+    /** */
+    getAppRoles(installedAppId: InstalledAppId): BaseRoleName[] | undefined;
+    /** */
+    getClones(appId: InstalledAppId, baseRoleName: BaseRoleName): Cell[];
+    createCloneCell(request: CreateCloneCellRequest): Promise<InstalledCell>;
+    /** -- AppApi (Passthrough to appWebsocket) -- */
+    enableCloneCell(request: EnableCloneCellRequest): Promise<InstalledCell>;
+    disableCloneCell(request: DisableCloneCellRequest): Promise<void>;
+    appInfo(args: AppInfoRequest): Promise<AppInfoResponse>;
+    callZome(req: CallZomeRequest, timeout?: number): Promise<any>;
+    /** -- Creation -- */
+    /** async Factory */
+    static new(port_or_socket: number | AppWebsocket, defaultTimeout?: number): Promise<ConductorAppProxy>;
+    /** */
+    private static fromSocket;
+    /** Ctor */
+    private constructor();
+    /** -- Methods -- */
+    /** */
+    fetchCell(appId: InstalledAppId, cellId: CellId): Promise<Cell>;
+    /** */
+    fetchCells(appId: InstalledAppId, baseRoleName: BaseRoleName): Promise<CellsForRole>;
+    /** */
+    addClone(hcl: HCL, cloneCell: Cell): void;
+    /** */
+    createCellProxy(hcl: HCL): CellProxy;
+    /** */
+    onSignal(signal: AppSignal): void;
+    /** Store signalHandler to internal handler array */
+    addSignalHandler(handler: AppSignalCb, hcl?: HCLString): SignalUnsubscriber;
+    /** Log all signals received */
+    private logSignal;
+    /** */
+    dumpSignals(cellId?: CellId): void;
+}