@ekhein/lamda-node-sdk 1.0.2 → 2.0.0

package/dist/{rpc → src/rpc}/services.d.ts

@@ -1,261 +1,259 @@
-import { StorageRequest, MessageFns as MessageFns$d } from './storage.js';
-import { FileRequest, FileStat, FileDataResponse, MessageFns as MessageFns$c } from './file.js';
-import { TouchSequence, PerformTouchRequest, ServerInfoResponse, CertifiRequest, ShowToastRequest, SetPropRequest, HexPatchRequest, HexPatchResponse, MessageFns as MessageFns$b } from './util.js';
-import { WifiStatus, WifiBlacklist, ScanResult, NetworkList, Network, NetworkConfig, WifiConfig, SignalPoll, MessageFns as MessageFns$a } from './wifi.js';
-import { ClickPointRequest, DragPointRequest, SwipePointRequest, SwipePointsRequest, ClipboardRequest, OrientationRequest, PressKeyRequest, DeviceInfo, TakeScreenshotRequest, SelectorTakeScreenshotRequest, SelectorOnlyRequest, SelectorSetTextRequest, SelectorClickRequest, ToastInfo, ObjInfo, ObjInfoList, SelectorDragToRequest, SelectorWaitRequest, SelectorSwipeRequest, SelectorFlingRequest, SelectorScrollRequest, SelectorPinchRequest, WatcherNameList, WatcherRegistRequest, FindImageRequest, FindImageResponse, MessageFns as MessageFns$9 } from './uiautomator.js';
-import { DiskUsage, BatteryInfo, CpuInfo, DiskIOInfo, NetIOInfo, MemInfo, MessageFns as MessageFns$8 } from './status.js';
-import { ShellRequest, ShellResult, ShellTask, MessageFns as MessageFns$7 } from './shell.js';
-import { SettingsRequest, MessageFns as MessageFns$6 } from './settings.js';
-import { SelinuxPolicyRequest, MessageFns as MessageFns$5 } from './policy.js';
-import { OpenVPNConfigRequest, GproxyConfigRequest, MessageFns as MessageFns$4 } from './proxy.js';
-import { ADBDConfigRequest, MessageFns as MessageFns$3 } from './debug.js';
-import { Empty, MessageFns as MessageFns$2 } from './google/protobuf/empty.js';
-import { Boolean, String, Bytes, Integer, MessageFns as MessageFns$1 } from './types.js';
-import { ApplicationRequest, ApplicationInfo, ApplicationPkgNames, ApplicationProcesses, ApplicationActivityInfo, ApplicationPermissions, ApplicationActivityInfoList, ApplicationActivityRequest, HookRpcRequest, HookRpcResponse, HookRequest, MessageFns } from './application.js';
-import { CallOptions, CallContext } from 'nice-grpc-common';
-import '@bufbuild/protobuf/wire';
-
-declare const protobufPackage = "lamda.rpc";
-type ApplicationDefinition = typeof ApplicationDefinition;
-declare const ApplicationDefinition: {
+import { type CallContext, type CallOptions } from "nice-grpc-common";
+import { ApplicationActivityInfo, ApplicationActivityInfoList, ApplicationActivityRequest, ApplicationInfo, ApplicationPermissions, ApplicationPkgNames, ApplicationProcesses, ApplicationRequest, HookRequest, HookRpcRequest, HookRpcResponse } from "./application";
+import { ADBDConfigRequest } from "./debug";
+import { FileDataResponse, FileRequest, FileStat } from "./file";
+import { Empty } from "./google/protobuf/empty";
+import { SelinuxPolicyRequest } from "./policy";
+import { GproxyConfigRequest, OpenVPNConfigRequest } from "./proxy";
+import { SettingsRequest } from "./settings";
+import { ShellRequest, ShellResult, ShellTask } from "./shell";
+import { BatteryInfo, CpuInfo, DiskIOInfo, DiskUsage, MemInfo, NetIOInfo } from "./status";
+import { StorageRequest } from "./storage";
+import { Boolean, Bytes, Integer, String } from "./types";
+import { ClickPointRequest, ClipboardRequest, DeviceInfo, DragPointRequest, FindImageRequest, FindImageResponse, ObjInfo, ObjInfoList, OrientationRequest, PressKeyRequest, SelectorClickRequest, SelectorDragToRequest, SelectorFlingRequest, SelectorOnlyRequest, SelectorPinchRequest, SelectorScrollRequest, SelectorSetTextRequest, SelectorSwipeRequest, SelectorTakeScreenshotRequest, SelectorWaitRequest, SwipePointRequest, SwipePointsRequest, TakeScreenshotRequest, ToastInfo, WatcherNameList, WatcherRegistRequest } from "./uiautomator";
+import { CertifiRequest, HexPatchRequest, HexPatchResponse, PerformTouchRequest, ServerInfoResponse, SetPropRequest, ShowToastRequest, TouchSequence } from "./util";
+import { Network, NetworkConfig, NetworkList, ScanResult, SignalPoll, WifiBlacklist, WifiConfig, WifiStatus } from "./wifi";
+export declare const protobufPackage = "lamda.rpc";
+export type ApplicationDefinition = typeof ApplicationDefinition;
+export declare const ApplicationDefinition: {
     readonly name: "Application";
     readonly fullName: "lamda.rpc.Application";
     readonly methods: {
         readonly isForeground: {
             readonly name: "isForeground";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly currentApplication: {
             readonly name: "currentApplication";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationInfo>;
+            readonly responseType: import("./application").MessageFns<ApplicationInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly enumerateAllPkgNames: {
             readonly name: "enumerateAllPkgNames";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationPkgNames>;
+            readonly responseType: import("./application").MessageFns<ApplicationPkgNames>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly enumerateRunningProcesses: {
             readonly name: "enumerateRunningProcesses";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationProcesses>;
+            readonly responseType: import("./application").MessageFns<ApplicationProcesses>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly queryLaunchActivity: {
             readonly name: "queryLaunchActivity";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationActivityInfo>;
+            readonly responseType: import("./application").MessageFns<ApplicationActivityInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getPermissions: {
             readonly name: "getPermissions";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationPermissions>;
+            readonly responseType: import("./application").MessageFns<ApplicationPermissions>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly resetApplicationData: {
             readonly name: "resetApplicationData";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly deleteApplicationCache: {
             readonly name: "deleteApplicationCache";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getLastActivities: {
             readonly name: "getLastActivities";
-            readonly requestType: MessageFns$1<Integer>;
+            readonly requestType: import("./types").MessageFns<Integer>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationActivityInfoList>;
+            readonly responseType: import("./application").MessageFns<ApplicationActivityInfoList>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly startActivity: {
             readonly name: "startActivity";
-            readonly requestType: MessageFns<ApplicationActivityRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationActivityRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly applicationInfo: {
             readonly name: "applicationInfo";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationInfo>;
+            readonly responseType: import("./application").MessageFns<ApplicationInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly startApplication: {
             readonly name: "startApplication";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly stopApplication: {
             readonly name: "stopApplication";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly uninstallApplication: {
             readonly name: "uninstallApplication";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly installFromLocalFile: {
             readonly name: "installFromLocalFile";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<ApplicationInfo>;
+            readonly responseType: import("./application").MessageFns<ApplicationInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly enableApplication: {
             readonly name: "enableApplication";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly disableApplication: {
             readonly name: "disableApplication";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly grantPermission: {
             readonly name: "grantPermission";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly revokePermission: {
             readonly name: "revokePermission";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isPermissionGranted: {
             readonly name: "isPermissionGranted";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isInstalled: {
             readonly name: "isInstalled";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly addToDozeModeWhiteList: {
             readonly name: "addToDozeModeWhiteList";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly removeFromDozeModeWhiteList: {
             readonly name: "removeFromDozeModeWhiteList";
-            readonly requestType: MessageFns<ApplicationRequest>;
+            readonly requestType: import("./application").MessageFns<ApplicationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getIdentifierByLabel: {
             readonly name: "getIdentifierByLabel";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<String>;
+            readonly responseType: import("./types").MessageFns<String>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly callScript: {
             readonly name: "callScript";
-            readonly requestType: MessageFns<HookRpcRequest>;
+            readonly requestType: import("./application").MessageFns<HookRpcRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns<HookRpcResponse>;
+            readonly responseType: import("./application").MessageFns<HookRpcResponse>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isScriptAlive: {
             readonly name: "isScriptAlive";
-            readonly requestType: MessageFns<HookRequest>;
+            readonly requestType: import("./application").MessageFns<HookRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isScriptAttached: {
             readonly name: "isScriptAttached";
-            readonly requestType: MessageFns<HookRequest>;
+            readonly requestType: import("./application").MessageFns<HookRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly attachScript: {
             readonly name: "attachScript";
-            readonly requestType: MessageFns<HookRequest>;
+            readonly requestType: import("./application").MessageFns<HookRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly detachScript: {
             readonly name: "detachScript";
-            readonly requestType: MessageFns<HookRequest>;
+            readonly requestType: import("./application").MessageFns<HookRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface ApplicationServiceImplementation<CallContextExt = {}> {
+export interface ApplicationServiceImplementation<CallContextExt = {}> {
     isForeground(request: ApplicationRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     currentApplication(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<ApplicationInfo>>;
     enumerateAllPkgNames(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<ApplicationPkgNames>>;
@@ -286,7 +284,7 @@ interface ApplicationServiceImplementation<CallContextExt = {}> {
     attachScript(request: HookRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     detachScript(request: HookRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
 }
-interface ApplicationClient<CallOptionsExt = {}> {
+export interface ApplicationClient<CallOptionsExt = {}> {
     isForeground(request: DeepPartial<ApplicationRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     currentApplication(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<ApplicationInfo>;
     enumerateAllPkgNames(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<ApplicationPkgNames>;
@@ -317,123 +315,123 @@ interface ApplicationClient<CallOptionsExt = {}> {
     attachScript(request: DeepPartial<HookRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     detachScript(request: DeepPartial<HookRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
 }
-type DebugDefinition = typeof DebugDefinition;
-declare const DebugDefinition: {
+export type DebugDefinition = typeof DebugDefinition;
+export declare const DebugDefinition: {
     readonly name: "Debug";
     readonly fullName: "lamda.rpc.Debug";
     readonly methods: {
         readonly isAndroidDebugBridgeRunning: {
             readonly name: "isAndroidDebugBridgeRunning";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly installADBPubKey: {
             readonly name: "installADBPubKey";
-            readonly requestType: MessageFns$3<ADBDConfigRequest>;
+            readonly requestType: import("./debug").MessageFns<ADBDConfigRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly uninstallADBPubKey: {
             readonly name: "uninstallADBPubKey";
-            readonly requestType: MessageFns$3<ADBDConfigRequest>;
+            readonly requestType: import("./debug").MessageFns<ADBDConfigRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly startAndroidDebugBridge: {
             readonly name: "startAndroidDebugBridge";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly stopAndroidDebugBridge: {
             readonly name: "stopAndroidDebugBridge";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface DebugServiceImplementation<CallContextExt = {}> {
+export interface DebugServiceImplementation<CallContextExt = {}> {
     isAndroidDebugBridgeRunning(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     installADBPubKey(request: ADBDConfigRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     uninstallADBPubKey(request: ADBDConfigRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     startAndroidDebugBridge(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     stopAndroidDebugBridge(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
 }
-interface DebugClient<CallOptionsExt = {}> {
+export interface DebugClient<CallOptionsExt = {}> {
     isAndroidDebugBridgeRunning(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     installADBPubKey(request: DeepPartial<ADBDConfigRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     uninstallADBPubKey(request: DeepPartial<ADBDConfigRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     startAndroidDebugBridge(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     stopAndroidDebugBridge(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
 }
-type ProxyDefinition = typeof ProxyDefinition;
-declare const ProxyDefinition: {
+export type ProxyDefinition = typeof ProxyDefinition;
+export declare const ProxyDefinition: {
     readonly name: "Proxy";
     readonly fullName: "lamda.rpc.Proxy";
     readonly methods: {
         readonly isOpenVPNRunning: {
             readonly name: "isOpenVPNRunning";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isGproxyRunning: {
             readonly name: "isGproxyRunning";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly stopOpenVPN: {
             readonly name: "stopOpenVPN";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly stopGproxy: {
             readonly name: "stopGproxy";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly startOpenVPN: {
             readonly name: "startOpenVPN";
-            readonly requestType: MessageFns$4<OpenVPNConfigRequest>;
+            readonly requestType: import("./proxy").MessageFns<OpenVPNConfigRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly startGproxy: {
             readonly name: "startGproxy";
-            readonly requestType: MessageFns$4<GproxyConfigRequest>;
+            readonly requestType: import("./proxy").MessageFns<GproxyConfigRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface ProxyServiceImplementation<CallContextExt = {}> {
+export interface ProxyServiceImplementation<CallContextExt = {}> {
     isOpenVPNRunning(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     isGproxyRunning(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     stopOpenVPN(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
@@ -441,7 +439,7 @@ interface ProxyServiceImplementation<CallContextExt = {}> {
     startOpenVPN(request: OpenVPNConfigRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     startGproxy(request: GproxyConfigRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
 }
-interface ProxyClient<CallOptionsExt = {}> {
+export interface ProxyClient<CallOptionsExt = {}> {
     isOpenVPNRunning(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     isGproxyRunning(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     stopOpenVPN(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
@@ -449,78 +447,78 @@ interface ProxyClient<CallOptionsExt = {}> {
     startOpenVPN(request: DeepPartial<OpenVPNConfigRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     startGproxy(request: DeepPartial<GproxyConfigRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
 }
-type SelinuxPolicyDefinition = typeof SelinuxPolicyDefinition;
-declare const SelinuxPolicyDefinition: {
+export type SelinuxPolicyDefinition = typeof SelinuxPolicyDefinition;
+export declare const SelinuxPolicyDefinition: {
     readonly name: "SelinuxPolicy";
     readonly fullName: "lamda.rpc.SelinuxPolicy";
     readonly methods: {
         readonly setEnforce: {
             readonly name: "setEnforce";
-            readonly requestType: MessageFns$1<Boolean>;
+            readonly requestType: import("./types").MessageFns<Boolean>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Integer>;
+            readonly responseType: import("./types").MessageFns<Integer>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getEnforce: {
             readonly name: "getEnforce";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Integer>;
+            readonly responseType: import("./types").MessageFns<Integer>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isEnabled: {
             readonly name: "isEnabled";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly policySetEnforce: {
             readonly name: "policySetEnforce";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly policySetPermissive: {
             readonly name: "policySetPermissive";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly policySetAllow: {
             readonly name: "policySetAllow";
-            readonly requestType: MessageFns$5<SelinuxPolicyRequest>;
+            readonly requestType: import("./policy").MessageFns<SelinuxPolicyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly policySetDisallow: {
             readonly name: "policySetDisallow";
-            readonly requestType: MessageFns$5<SelinuxPolicyRequest>;
+            readonly requestType: import("./policy").MessageFns<SelinuxPolicyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly policyCreateDomain: {
             readonly name: "policyCreateDomain";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface SelinuxPolicyServiceImplementation<CallContextExt = {}> {
+export interface SelinuxPolicyServiceImplementation<CallContextExt = {}> {
     setEnforce(request: Boolean, context: CallContext & CallContextExt): Promise<DeepPartial<Integer>>;
     getEnforce(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Integer>>;
     isEnabled(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
@@ -530,7 +528,7 @@ interface SelinuxPolicyServiceImplementation<CallContextExt = {}> {
     policySetDisallow(request: SelinuxPolicyRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     policyCreateDomain(request: String, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
 }
-interface SelinuxPolicyClient<CallOptionsExt = {}> {
+export interface SelinuxPolicyClient<CallOptionsExt = {}> {
     setEnforce(request: DeepPartial<Boolean>, options?: CallOptions & CallOptionsExt): Promise<Integer>;
     getEnforce(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Integer>;
     isEnabled(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
@@ -540,168 +538,168 @@ interface SelinuxPolicyClient<CallOptionsExt = {}> {
     policySetDisallow(request: DeepPartial<SelinuxPolicyRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     policyCreateDomain(request: DeepPartial<String>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
 }
-type SettingsDefinition = typeof SettingsDefinition;
-declare const SettingsDefinition: {
+export type SettingsDefinition = typeof SettingsDefinition;
+export declare const SettingsDefinition: {
     readonly name: "Settings";
     readonly fullName: "lamda.rpc.Settings";
     readonly methods: {
         readonly putSettings: {
             readonly name: "putSettings";
-            readonly requestType: MessageFns$6<SettingsRequest>;
+            readonly requestType: import("./settings").MessageFns<SettingsRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getSettings: {
             readonly name: "getSettings";
-            readonly requestType: MessageFns$6<SettingsRequest>;
+            readonly requestType: import("./settings").MessageFns<SettingsRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<String>;
+            readonly responseType: import("./types").MessageFns<String>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface SettingsServiceImplementation<CallContextExt = {}> {
+export interface SettingsServiceImplementation<CallContextExt = {}> {
     putSettings(request: SettingsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     getSettings(request: SettingsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<String>>;
 }
-interface SettingsClient<CallOptionsExt = {}> {
+export interface SettingsClient<CallOptionsExt = {}> {
     putSettings(request: DeepPartial<SettingsRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     getSettings(request: DeepPartial<SettingsRequest>, options?: CallOptions & CallOptionsExt): Promise<String>;
 }
-type ShellDefinition = typeof ShellDefinition;
-declare const ShellDefinition: {
+export type ShellDefinition = typeof ShellDefinition;
+export declare const ShellDefinition: {
     readonly name: "Shell";
     readonly fullName: "lamda.rpc.Shell";
     readonly methods: {
         readonly executeForeground: {
             readonly name: "executeForeground";
-            readonly requestType: MessageFns$7<ShellRequest>;
+            readonly requestType: import("./shell").MessageFns<ShellRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$7<ShellResult>;
+            readonly responseType: import("./shell").MessageFns<ShellResult>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly executeBackground: {
             readonly name: "executeBackground";
-            readonly requestType: MessageFns$7<ShellRequest>;
+            readonly requestType: import("./shell").MessageFns<ShellRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$7<ShellTask>;
+            readonly responseType: import("./shell").MessageFns<ShellTask>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isBackgroundFinished: {
             readonly name: "isBackgroundFinished";
-            readonly requestType: MessageFns$7<ShellTask>;
+            readonly requestType: import("./shell").MessageFns<ShellTask>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly killBackground: {
             readonly name: "killBackground";
-            readonly requestType: MessageFns$7<ShellTask>;
+            readonly requestType: import("./shell").MessageFns<ShellTask>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface ShellServiceImplementation<CallContextExt = {}> {
+export interface ShellServiceImplementation<CallContextExt = {}> {
     executeForeground(request: ShellRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ShellResult>>;
     executeBackground(request: ShellRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ShellTask>>;
     isBackgroundFinished(request: ShellTask, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     killBackground(request: ShellTask, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
 }
-interface ShellClient<CallOptionsExt = {}> {
+export interface ShellClient<CallOptionsExt = {}> {
     executeForeground(request: DeepPartial<ShellRequest>, options?: CallOptions & CallOptionsExt): Promise<ShellResult>;
     executeBackground(request: DeepPartial<ShellRequest>, options?: CallOptions & CallOptionsExt): Promise<ShellTask>;
     isBackgroundFinished(request: DeepPartial<ShellTask>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     killBackground(request: DeepPartial<ShellTask>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
 }
-type StatusDefinition = typeof StatusDefinition;
-declare const StatusDefinition: {
+export type StatusDefinition = typeof StatusDefinition;
+export declare const StatusDefinition: {
     readonly name: "Status";
     readonly fullName: "lamda.rpc.Status";
     readonly methods: {
         readonly getBootTime: {
             readonly name: "getBootTime";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Integer>;
+            readonly responseType: import("./types").MessageFns<Integer>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getDiskUsage: {
             readonly name: "getDiskUsage";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<DiskUsage>;
+            readonly responseType: import("./status").MessageFns<DiskUsage>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getBatteryInfo: {
             readonly name: "getBatteryInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<BatteryInfo>;
+            readonly responseType: import("./status").MessageFns<BatteryInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getCpuInfo: {
             readonly name: "getCpuInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<CpuInfo>;
+            readonly responseType: import("./status").MessageFns<CpuInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getOverallDiskIOInfo: {
             readonly name: "getOverallDiskIOInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<DiskIOInfo>;
+            readonly responseType: import("./status").MessageFns<DiskIOInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getOverallNetIOInfo: {
             readonly name: "getOverallNetIOInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<NetIOInfo>;
+            readonly responseType: import("./status").MessageFns<NetIOInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getMemInfo: {
             readonly name: "getMemInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<MemInfo>;
+            readonly responseType: import("./status").MessageFns<MemInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getUserDataDiskIOInfo: {
             readonly name: "getUserDataDiskIOInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<DiskIOInfo>;
+            readonly responseType: import("./status").MessageFns<DiskIOInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getNetIOInfo: {
             readonly name: "getNetIOInfo";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$8<NetIOInfo>;
+            readonly responseType: import("./status").MessageFns<NetIOInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface StatusServiceImplementation<CallContextExt = {}> {
+export interface StatusServiceImplementation<CallContextExt = {}> {
     getBootTime(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Integer>>;
     getDiskUsage(request: String, context: CallContext & CallContextExt): Promise<DeepPartial<DiskUsage>>;
     getBatteryInfo(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<BatteryInfo>>;
@@ -712,7 +710,7 @@ interface StatusServiceImplementation<CallContextExt = {}> {
     getUserDataDiskIOInfo(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<DiskIOInfo>>;
     getNetIOInfo(request: String, context: CallContext & CallContextExt): Promise<DeepPartial<NetIOInfo>>;
 }
-interface StatusClient<CallOptionsExt = {}> {
+export interface StatusClient<CallOptionsExt = {}> {
     getBootTime(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Integer>;
     getDiskUsage(request: DeepPartial<String>, options?: CallOptions & CallOptionsExt): Promise<DiskUsage>;
     getBatteryInfo(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<BatteryInfo>;
@@ -723,470 +721,470 @@ interface StatusClient<CallOptionsExt = {}> {
     getUserDataDiskIOInfo(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<DiskIOInfo>;
     getNetIOInfo(request: DeepPartial<String>, options?: CallOptions & CallOptionsExt): Promise<NetIOInfo>;
 }
-type UiAutomatorDefinition = typeof UiAutomatorDefinition;
-declare const UiAutomatorDefinition: {
+export type UiAutomatorDefinition = typeof UiAutomatorDefinition;
+export declare const UiAutomatorDefinition: {
     readonly name: "UiAutomator";
     readonly fullName: "lamda.rpc.UiAutomator";
     readonly methods: {
         readonly click: {
             readonly name: "click";
-            readonly requestType: MessageFns$9<ClickPointRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<ClickPointRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly drag: {
             readonly name: "drag";
-            readonly requestType: MessageFns$9<DragPointRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<DragPointRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly swipe: {
             readonly name: "swipe";
-            readonly requestType: MessageFns$9<SwipePointRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SwipePointRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly swipePoints: {
             readonly name: "swipePoints";
-            readonly requestType: MessageFns$9<SwipePointsRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SwipePointsRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly openNotification: {
             readonly name: "openNotification";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly openQuickSettings: {
             readonly name: "openQuickSettings";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly wakeUp: {
             readonly name: "wakeUp";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly sleep: {
             readonly name: "sleep";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isScreenOn: {
             readonly name: "isScreenOn";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isScreenLocked: {
             readonly name: "isScreenLocked";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setClipboard: {
             readonly name: "setClipboard";
-            readonly requestType: MessageFns$9<ClipboardRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<ClipboardRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getClipboard: {
             readonly name: "getClipboard";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<String>;
+            readonly responseType: import("./types").MessageFns<String>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly freezeRotation: {
             readonly name: "freezeRotation";
-            readonly requestType: MessageFns$1<Boolean>;
+            readonly requestType: import("./types").MessageFns<Boolean>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setOrientation: {
             readonly name: "setOrientation";
-            readonly requestType: MessageFns$9<OrientationRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<OrientationRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly pressKey: {
             readonly name: "pressKey";
-            readonly requestType: MessageFns$9<PressKeyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<PressKeyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly pressKeyCode: {
             readonly name: "pressKeyCode";
-            readonly requestType: MessageFns$9<PressKeyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<PressKeyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly deviceInfo: {
             readonly name: "deviceInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$9<DeviceInfo>;
+            readonly responseType: import("./uiautomator").MessageFns<DeviceInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly takeScreenshot: {
             readonly name: "takeScreenshot";
-            readonly requestType: MessageFns$9<TakeScreenshotRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<TakeScreenshotRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Bytes>;
+            readonly responseType: import("./types").MessageFns<Bytes>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly dumpWindowHierarchy: {
             readonly name: "dumpWindowHierarchy";
-            readonly requestType: MessageFns$1<Boolean>;
+            readonly requestType: import("./types").MessageFns<Boolean>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Bytes>;
+            readonly responseType: import("./types").MessageFns<Bytes>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly waitForIdle: {
             readonly name: "waitForIdle";
-            readonly requestType: MessageFns$1<Integer>;
+            readonly requestType: import("./types").MessageFns<Integer>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorTakeScreenshot: {
             readonly name: "selectorTakeScreenshot";
-            readonly requestType: MessageFns$9<SelectorTakeScreenshotRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorTakeScreenshotRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Bytes>;
+            readonly responseType: import("./types").MessageFns<Bytes>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorGetText: {
             readonly name: "selectorGetText";
-            readonly requestType: MessageFns$9<SelectorOnlyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorOnlyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<String>;
+            readonly responseType: import("./types").MessageFns<String>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorClearTextField: {
             readonly name: "selectorClearTextField";
-            readonly requestType: MessageFns$9<SelectorOnlyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorOnlyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorSetText: {
             readonly name: "selectorSetText";
-            readonly requestType: MessageFns$9<SelectorSetTextRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorSetTextRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorClick: {
             readonly name: "selectorClick";
-            readonly requestType: MessageFns$9<SelectorClickRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorClickRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorClickExists: {
             readonly name: "selectorClickExists";
-            readonly requestType: MessageFns$9<SelectorClickRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorClickRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorLongClick: {
             readonly name: "selectorLongClick";
-            readonly requestType: MessageFns$9<SelectorClickRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorClickRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorExists: {
             readonly name: "selectorExists";
-            readonly requestType: MessageFns$9<SelectorOnlyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorOnlyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getLastToast: {
             readonly name: "getLastToast";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$9<ToastInfo>;
+            readonly responseType: import("./uiautomator").MessageFns<ToastInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorObjInfo: {
             readonly name: "selectorObjInfo";
-            readonly requestType: MessageFns$9<SelectorOnlyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorOnlyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$9<ObjInfo>;
+            readonly responseType: import("./uiautomator").MessageFns<ObjInfo>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorObjInfoOfAllInstances: {
             readonly name: "selectorObjInfoOfAllInstances";
-            readonly requestType: MessageFns$9<SelectorOnlyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorOnlyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$9<ObjInfoList>;
+            readonly responseType: import("./uiautomator").MessageFns<ObjInfoList>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorCount: {
             readonly name: "selectorCount";
-            readonly requestType: MessageFns$9<SelectorOnlyRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorOnlyRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Integer>;
+            readonly responseType: import("./types").MessageFns<Integer>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorDragTo: {
             readonly name: "selectorDragTo";
-            readonly requestType: MessageFns$9<SelectorDragToRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorDragToRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorWaitForExists: {
             readonly name: "selectorWaitForExists";
-            readonly requestType: MessageFns$9<SelectorWaitRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorWaitRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorWaitUntilGone: {
             readonly name: "selectorWaitUntilGone";
-            readonly requestType: MessageFns$9<SelectorWaitRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorWaitRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorSwipe: {
             readonly name: "selectorSwipe";
-            readonly requestType: MessageFns$9<SelectorSwipeRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorSwipeRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorFlingToBeginning: {
             readonly name: "selectorFlingToBeginning";
-            readonly requestType: MessageFns$9<SelectorFlingRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorFlingRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorFlingToEnd: {
             readonly name: "selectorFlingToEnd";
-            readonly requestType: MessageFns$9<SelectorFlingRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorFlingRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorFlingBackward: {
             readonly name: "selectorFlingBackward";
-            readonly requestType: MessageFns$9<SelectorFlingRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorFlingRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorFlingForward: {
             readonly name: "selectorFlingForward";
-            readonly requestType: MessageFns$9<SelectorFlingRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorFlingRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorScrollToBeginning: {
             readonly name: "selectorScrollToBeginning";
-            readonly requestType: MessageFns$9<SelectorScrollRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorScrollRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorScrollToEnd: {
             readonly name: "selectorScrollToEnd";
-            readonly requestType: MessageFns$9<SelectorScrollRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorScrollRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorScrollBackward: {
             readonly name: "selectorScrollBackward";
-            readonly requestType: MessageFns$9<SelectorScrollRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorScrollRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorScrollForward: {
             readonly name: "selectorScrollForward";
-            readonly requestType: MessageFns$9<SelectorScrollRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorScrollRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorScrollTo: {
             readonly name: "selectorScrollTo";
-            readonly requestType: MessageFns$9<SelectorScrollRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorScrollRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorPinchOut: {
             readonly name: "selectorPinchOut";
-            readonly requestType: MessageFns$9<SelectorPinchRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorPinchRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectorPinchIn: {
             readonly name: "selectorPinchIn";
-            readonly requestType: MessageFns$9<SelectorPinchRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<SelectorPinchRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setWatcherLoopEnabled: {
             readonly name: "setWatcherLoopEnabled";
-            readonly requestType: MessageFns$1<Boolean>;
+            readonly requestType: import("./types").MessageFns<Boolean>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getWatcherLoopEnabled: {
             readonly name: "getWatcherLoopEnabled";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getWatcherTriggeredCount: {
             readonly name: "getWatcherTriggeredCount";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Integer>;
+            readonly responseType: import("./types").MessageFns<Integer>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly resetWatcherTriggeredCount: {
             readonly name: "resetWatcherTriggeredCount";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly removeWatcher: {
             readonly name: "removeWatcher";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getAppliedWatchers: {
             readonly name: "getAppliedWatchers";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$9<WatcherNameList>;
+            readonly responseType: import("./uiautomator").MessageFns<WatcherNameList>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly registerClickUiObjectWatcher: {
             readonly name: "registerClickUiObjectWatcher";
-            readonly requestType: MessageFns$9<WatcherRegistRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<WatcherRegistRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly registerPressKeysWatcher: {
             readonly name: "registerPressKeysWatcher";
-            readonly requestType: MessageFns$9<WatcherRegistRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<WatcherRegistRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly registerNoneOpWatcher: {
             readonly name: "registerNoneOpWatcher";
-            readonly requestType: MessageFns$9<WatcherRegistRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<WatcherRegistRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly findSimilarImage: {
             readonly name: "findSimilarImage";
-            readonly requestType: MessageFns$9<FindImageRequest>;
+            readonly requestType: import("./uiautomator").MessageFns<FindImageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$9<FindImageResponse>;
+            readonly responseType: import("./uiautomator").MessageFns<FindImageResponse>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface UiAutomatorServiceImplementation<CallContextExt = {}> {
+export interface UiAutomatorServiceImplementation<CallContextExt = {}> {
     click(request: ClickPointRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     drag(request: DragPointRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     swipe(request: SwipePointRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
@@ -1245,7 +1243,7 @@ interface UiAutomatorServiceImplementation<CallContextExt = {}> {
     registerNoneOpWatcher(request: WatcherRegistRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     findSimilarImage(request: FindImageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<FindImageResponse>>;
 }
-interface UiAutomatorClient<CallOptionsExt = {}> {
+export interface UiAutomatorClient<CallOptionsExt = {}> {
     click(request: DeepPartial<ClickPointRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     drag(request: DeepPartial<DragPointRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     swipe(request: DeepPartial<SwipePointRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
@@ -1304,182 +1302,182 @@ interface UiAutomatorClient<CallOptionsExt = {}> {
     registerNoneOpWatcher(request: DeepPartial<WatcherRegistRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     findSimilarImage(request: DeepPartial<FindImageRequest>, options?: CallOptions & CallOptionsExt): Promise<FindImageResponse>;
 }
-type WifiDefinition = typeof WifiDefinition;
-declare const WifiDefinition: {
+export type WifiDefinition = typeof WifiDefinition;
+export declare const WifiDefinition: {
     readonly name: "Wifi";
     readonly fullName: "lamda.rpc.Wifi";
     readonly methods: {
         readonly status: {
             readonly name: "status";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$a<WifiStatus>;
+            readonly responseType: import("./wifi").MessageFns<WifiStatus>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly blacklistAdd: {
             readonly name: "blacklistAdd";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly blacklistClear: {
             readonly name: "blacklistClear";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly blacklistAll: {
             readonly name: "blacklistAll";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$a<WifiBlacklist>;
+            readonly responseType: import("./wifi").MessageFns<WifiBlacklist>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly scan: {
             readonly name: "scan";
-            readonly requestType: MessageFns$1<Boolean>;
+            readonly requestType: import("./types").MessageFns<Boolean>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly scanResults: {
             readonly name: "scanResults";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$a<ScanResult>;
+            readonly responseType: import("./wifi").MessageFns<ScanResult>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly listNetworks: {
             readonly name: "listNetworks";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$a<NetworkList>;
+            readonly responseType: import("./wifi").MessageFns<NetworkList>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly selectNetwork: {
             readonly name: "selectNetwork";
-            readonly requestType: MessageFns$a<Network>;
+            readonly requestType: import("./wifi").MessageFns<Network>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly enableNetwork: {
             readonly name: "enableNetwork";
-            readonly requestType: MessageFns$a<Network>;
+            readonly requestType: import("./wifi").MessageFns<Network>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly disableNetwork: {
             readonly name: "disableNetwork";
-            readonly requestType: MessageFns$a<Network>;
+            readonly requestType: import("./wifi").MessageFns<Network>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly addNetwork: {
             readonly name: "addNetwork";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$a<Network>;
+            readonly responseType: import("./wifi").MessageFns<Network>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly removeNetwork: {
             readonly name: "removeNetwork";
-            readonly requestType: MessageFns$a<Network>;
+            readonly requestType: import("./wifi").MessageFns<Network>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setNetworkConfig: {
             readonly name: "setNetworkConfig";
-            readonly requestType: MessageFns$a<NetworkConfig>;
+            readonly requestType: import("./wifi").MessageFns<NetworkConfig>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getNetworkConfig: {
             readonly name: "getNetworkConfig";
-            readonly requestType: MessageFns$a<NetworkConfig>;
+            readonly requestType: import("./wifi").MessageFns<NetworkConfig>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$a<NetworkConfig>;
+            readonly responseType: import("./wifi").MessageFns<NetworkConfig>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly disconnect: {
             readonly name: "disconnect";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly reconnect: {
             readonly name: "reconnect";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setConfig: {
             readonly name: "setConfig";
-            readonly requestType: MessageFns$a<WifiConfig>;
+            readonly requestType: import("./wifi").MessageFns<WifiConfig>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setAutoConnect: {
             readonly name: "setAutoConnect";
-            readonly requestType: MessageFns$1<Boolean>;
+            readonly requestType: import("./types").MessageFns<Boolean>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly saveConfig: {
             readonly name: "saveConfig";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getMacAddr: {
             readonly name: "getMacAddr";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<String>;
+            readonly responseType: import("./types").MessageFns<String>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly signalPoll: {
             readonly name: "signalPoll";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$a<SignalPoll>;
+            readonly responseType: import("./wifi").MessageFns<SignalPoll>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface WifiServiceImplementation<CallContextExt = {}> {
+export interface WifiServiceImplementation<CallContextExt = {}> {
     status(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<WifiStatus>>;
     blacklistAdd(request: String, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     blacklistClear(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
@@ -1502,7 +1500,7 @@ interface WifiServiceImplementation<CallContextExt = {}> {
     getMacAddr(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<String>>;
     signalPoll(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<SignalPoll>>;
 }
-interface WifiClient<CallOptionsExt = {}> {
+export interface WifiClient<CallOptionsExt = {}> {
     status(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<WifiStatus>;
     blacklistAdd(request: DeepPartial<String>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     blacklistClear(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
@@ -1525,134 +1523,134 @@ interface WifiClient<CallOptionsExt = {}> {
     getMacAddr(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<String>;
     signalPoll(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<SignalPoll>;
 }
-type UtilDefinition = typeof UtilDefinition;
-declare const UtilDefinition: {
+export type UtilDefinition = typeof UtilDefinition;
+export declare const UtilDefinition: {
     readonly name: "Util";
     readonly fullName: "lamda.rpc.Util";
     readonly methods: {
         readonly recordTouch: {
             readonly name: "recordTouch";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$b<TouchSequence>;
+            readonly responseType: import("./util").MessageFns<TouchSequence>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly performTouch: {
             readonly name: "performTouch";
-            readonly requestType: MessageFns$b<PerformTouchRequest>;
+            readonly requestType: import("./util").MessageFns<PerformTouchRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly serverInfo: {
             readonly name: "serverInfo";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$b<ServerInfoResponse>;
+            readonly responseType: import("./util").MessageFns<ServerInfoResponse>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly reboot: {
             readonly name: "reboot";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly beepBeep: {
             readonly name: "beepBeep";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly isCACertificateInstalled: {
             readonly name: "isCACertificateInstalled";
-            readonly requestType: MessageFns$b<CertifiRequest>;
+            readonly requestType: import("./util").MessageFns<CertifiRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly installCACertificate: {
             readonly name: "installCACertificate";
-            readonly requestType: MessageFns$b<CertifiRequest>;
+            readonly requestType: import("./util").MessageFns<CertifiRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly uninstallCACertificate: {
             readonly name: "uninstallCACertificate";
-            readonly requestType: MessageFns$b<CertifiRequest>;
+            readonly requestType: import("./util").MessageFns<CertifiRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly shutdown: {
             readonly name: "shutdown";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly showToast: {
             readonly name: "showToast";
-            readonly requestType: MessageFns$b<ShowToastRequest>;
+            readonly requestType: import("./util").MessageFns<ShowToastRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly reload: {
             readonly name: "reload";
-            readonly requestType: MessageFns$1<Boolean>;
+            readonly requestType: import("./types").MessageFns<Boolean>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly exit: {
             readonly name: "exit";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setProp: {
             readonly name: "setProp";
-            readonly requestType: MessageFns$b<SetPropRequest>;
+            readonly requestType: import("./util").MessageFns<SetPropRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getProp: {
             readonly name: "getProp";
-            readonly requestType: MessageFns$1<String>;
+            readonly requestType: import("./types").MessageFns<String>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<String>;
+            readonly responseType: import("./types").MessageFns<String>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly hexPatch: {
             readonly name: "hexPatch";
-            readonly requestType: MessageFns$b<HexPatchRequest>;
+            readonly requestType: import("./util").MessageFns<HexPatchRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$b<HexPatchResponse>;
+            readonly responseType: import("./util").MessageFns<HexPatchResponse>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface UtilServiceImplementation<CallContextExt = {}> {
+export interface UtilServiceImplementation<CallContextExt = {}> {
     recordTouch(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<TouchSequence>>;
     performTouch(request: PerformTouchRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     serverInfo(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<ServerInfoResponse>>;
@@ -1669,7 +1667,7 @@ interface UtilServiceImplementation<CallContextExt = {}> {
     getProp(request: String, context: CallContext & CallContextExt): Promise<DeepPartial<String>>;
     hexPatch(request: HexPatchRequest, context: CallContext & CallContextExt): Promise<DeepPartial<HexPatchResponse>>;
 }
-interface UtilClient<CallOptionsExt = {}> {
+export interface UtilClient<CallOptionsExt = {}> {
     recordTouch(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<TouchSequence>;
     performTouch(request: DeepPartial<PerformTouchRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     serverInfo(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<ServerInfoResponse>;
@@ -1686,206 +1684,206 @@ interface UtilClient<CallOptionsExt = {}> {
     getProp(request: DeepPartial<String>, options?: CallOptions & CallOptionsExt): Promise<String>;
     hexPatch(request: DeepPartial<HexPatchRequest>, options?: CallOptions & CallOptionsExt): Promise<HexPatchResponse>;
 }
-type FileDefinition = typeof FileDefinition;
-declare const FileDefinition: {
+export type FileDefinition = typeof FileDefinition;
+export declare const FileDefinition: {
     readonly name: "File";
     readonly fullName: "lamda.rpc.File";
     readonly methods: {
         readonly uploadFile: {
             readonly name: "uploadFile";
-            readonly requestType: MessageFns$c<FileRequest>;
+            readonly requestType: import("./file").MessageFns<FileRequest>;
             readonly requestStream: true;
-            readonly responseType: MessageFns$c<FileStat>;
+            readonly responseType: import("./file").MessageFns<FileStat>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly downloadFile: {
             readonly name: "downloadFile";
-            readonly requestType: MessageFns$c<FileRequest>;
+            readonly requestType: import("./file").MessageFns<FileRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$c<FileDataResponse>;
+            readonly responseType: import("./file").MessageFns<FileDataResponse>;
             readonly responseStream: true;
             readonly options: {};
         };
         readonly deleteFile: {
             readonly name: "deleteFile";
-            readonly requestType: MessageFns$c<FileRequest>;
+            readonly requestType: import("./file").MessageFns<FileRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly fileChmod: {
             readonly name: "fileChmod";
-            readonly requestType: MessageFns$c<FileRequest>;
+            readonly requestType: import("./file").MessageFns<FileRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$c<FileStat>;
+            readonly responseType: import("./file").MessageFns<FileStat>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly fileStat: {
             readonly name: "fileStat";
-            readonly requestType: MessageFns$c<FileRequest>;
+            readonly requestType: import("./file").MessageFns<FileRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$c<FileStat>;
+            readonly responseType: import("./file").MessageFns<FileStat>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface FileServiceImplementation<CallContextExt = {}> {
+export interface FileServiceImplementation<CallContextExt = {}> {
     uploadFile(request: AsyncIterable<FileRequest>, context: CallContext & CallContextExt): Promise<DeepPartial<FileStat>>;
     downloadFile(request: FileRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<FileDataResponse>>;
     deleteFile(request: FileRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     fileChmod(request: FileRequest, context: CallContext & CallContextExt): Promise<DeepPartial<FileStat>>;
     fileStat(request: FileRequest, context: CallContext & CallContextExt): Promise<DeepPartial<FileStat>>;
 }
-interface FileClient<CallOptionsExt = {}> {
+export interface FileClient<CallOptionsExt = {}> {
     uploadFile(request: AsyncIterable<DeepPartial<FileRequest>>, options?: CallOptions & CallOptionsExt): Promise<FileStat>;
     downloadFile(request: DeepPartial<FileRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<FileDataResponse>;
     deleteFile(request: DeepPartial<FileRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     fileChmod(request: DeepPartial<FileRequest>, options?: CallOptions & CallOptionsExt): Promise<FileStat>;
     fileStat(request: DeepPartial<FileRequest>, options?: CallOptions & CallOptionsExt): Promise<FileStat>;
 }
-type LockDefinition = typeof LockDefinition;
-declare const LockDefinition: {
+export type LockDefinition = typeof LockDefinition;
+export declare const LockDefinition: {
     readonly name: "Lock";
     readonly fullName: "lamda.rpc.Lock";
     readonly methods: {
         readonly releaseLock: {
             readonly name: "releaseLock";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly getSessionToken: {
             readonly name: "getSessionToken";
-            readonly requestType: MessageFns$2<Empty>;
+            readonly requestType: import("./google/protobuf/empty").MessageFns<Empty>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<String>;
+            readonly responseType: import("./types").MessageFns<String>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly acquireLock: {
             readonly name: "acquireLock";
-            readonly requestType: MessageFns$1<Integer>;
+            readonly requestType: import("./types").MessageFns<Integer>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly refreshLock: {
             readonly name: "refreshLock";
-            readonly requestType: MessageFns$1<Integer>;
+            readonly requestType: import("./types").MessageFns<Integer>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface LockServiceImplementation<CallContextExt = {}> {
+export interface LockServiceImplementation<CallContextExt = {}> {
     releaseLock(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     getSessionToken(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<String>>;
     acquireLock(request: Integer, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     refreshLock(request: Integer, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
 }
-interface LockClient<CallOptionsExt = {}> {
+export interface LockClient<CallOptionsExt = {}> {
     releaseLock(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     getSessionToken(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<String>;
     acquireLock(request: DeepPartial<Integer>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     refreshLock(request: DeepPartial<Integer>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
 }
-type StorageDefinition = typeof StorageDefinition;
-declare const StorageDefinition: {
+export type StorageDefinition = typeof StorageDefinition;
+export declare const StorageDefinition: {
     readonly name: "Storage";
     readonly fullName: "lamda.rpc.Storage";
     readonly methods: {
         readonly clearAll: {
             readonly name: "clearAll";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly clearContainer: {
             readonly name: "clearContainer";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly exists: {
             readonly name: "exists";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly delete: {
             readonly name: "delete";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly expire: {
             readonly name: "expire";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly ttl: {
             readonly name: "ttl";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Integer>;
+            readonly responseType: import("./types").MessageFns<Integer>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly set: {
             readonly name: "set";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setnx: {
             readonly name: "setnx";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly setex: {
             readonly name: "setex";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Boolean>;
+            readonly responseType: import("./types").MessageFns<Boolean>;
             readonly responseStream: false;
             readonly options: {};
         };
         readonly get: {
             readonly name: "get";
-            readonly requestType: MessageFns$d<StorageRequest>;
+            readonly requestType: import("./storage").MessageFns<StorageRequest>;
             readonly requestStream: false;
-            readonly responseType: MessageFns$1<Bytes>;
+            readonly responseType: import("./types").MessageFns<Bytes>;
             readonly responseStream: false;
             readonly options: {};
         };
     };
 };
-interface StorageServiceImplementation<CallContextExt = {}> {
+export interface StorageServiceImplementation<CallContextExt = {}> {
     clearAll(request: StorageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     clearContainer(request: StorageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     exists(request: StorageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
@@ -1897,7 +1895,7 @@ interface StorageServiceImplementation<CallContextExt = {}> {
     setex(request: StorageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Boolean>>;
     get(request: StorageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Bytes>>;
 }
-interface StorageClient<CallOptionsExt = {}> {
+export interface StorageClient<CallOptionsExt = {}> {
     clearAll(request: DeepPartial<StorageRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     clearContainer(request: DeepPartial<StorageRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
     exists(request: DeepPartial<StorageRequest>, options?: CallOptions & CallOptionsExt): Promise<Boolean>;
@@ -1910,11 +1908,10 @@ interface StorageClient<CallOptionsExt = {}> {
     get(request: DeepPartial<StorageRequest>, options?: CallOptions & CallOptionsExt): Promise<Bytes>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;
-type ServerStreamingMethodResult<Response> = {
+export type ServerStreamingMethodResult<Response> = {
     [Symbol.asyncIterator](): AsyncIterator<Response, void>;
 };
-
-export { type ApplicationClient, ApplicationDefinition, type ApplicationServiceImplementation, type DebugClient, DebugDefinition, type DebugServiceImplementation, type DeepPartial, type FileClient, FileDefinition, type FileServiceImplementation, type LockClient, LockDefinition, type LockServiceImplementation, type ProxyClient, ProxyDefinition, type ProxyServiceImplementation, type SelinuxPolicyClient, SelinuxPolicyDefinition, type SelinuxPolicyServiceImplementation, type ServerStreamingMethodResult, type SettingsClient, SettingsDefinition, type SettingsServiceImplementation, type ShellClient, ShellDefinition, type ShellServiceImplementation, type StatusClient, StatusDefinition, type StatusServiceImplementation, type StorageClient, StorageDefinition, type StorageServiceImplementation, type UiAutomatorClient, UiAutomatorDefinition, type UiAutomatorServiceImplementation, type UtilClient, UtilDefinition, type UtilServiceImplementation, type WifiClient, WifiDefinition, type WifiServiceImplementation, protobufPackage };
+export {};