// @flow

// This file is auto-generated by client/protocol/Makefile.
import * as gregor1 from './flow-types-gregor'

import engine from '../../engine'
import {RPCError} from '../../util/errors'
import {putOnChannelMap, createChannelMap, closeChannelMap} from '../../util/saga'
import {Buffer} from 'buffer'
import type {Exact} from './more'
import type {ChannelConfig, ChannelMap} from './saga'
export type int = number
export type int64 = number
export type uint = number
export type uint64 = number
export type long = number
export type double = number
export type bytes = Buffer
export type WaitingHandlerType = (waiting: boolean, method: string, sessionID: number) => void

const engineRpcOutgoing = (method: string, params: any, callbackOverride: any, incomingCallMapOverride: any) => engine()._rpcOutgoing(method, params, callbackOverride, incomingCallMapOverride)

type requestCommon = {
  waitingHandler?: WaitingHandlerType,
  incomingCallMap?: incomingCallMapType,
}

type requestErrorCallback = {
  callback?: ?(err: ?RPCError) => void
}

type RPCErrorHandler = (err: RPCError) => void

type CommonResponseHandler = {
  error: RPCErrorHandler,
  result: (...rest: Array<void>) => void,
}

function _channelMapRpcHelper(channelConfig: ChannelConfig<*>, partialRpcCall: (incomingCallMap: any, callback: Function) => void): ChannelMap<*> {
  const channelMap = createChannelMap(channelConfig)
  const incomingCallMap = Object.keys(channelMap).reduce((acc, k) => {
    acc[k] = (params, response) => {
      putOnChannelMap(channelMap, k, {params, response})
    }
    return acc
  }, {})
  const callback = (error, params) => {
    channelMap['finished'] && putOnChannelMap(channelMap, 'finished', {error, params})
    closeChannelMap(channelMap)
  }
  partialRpcCall(incomingCallMap, callback)
  return channelMap
}


export const BackendCommonBlockType = {
  data: 0,
  md: 1,
}

export const CommonClientType = {
  none: 0,
  cli: 1,
  guiMain: 2,
  kbfs: 3,
  guiHelper: 4,
}

export const CommonDeviceType = {
  desktop: 0,
  mobile: 1,
}

export const CommonLogLevel = {
  none: 0,
  debug: 1,
  info: 2,
  notice: 3,
  warn: 4,
  error: 5,
  critical: 6,
  fatal: 7,
}

export const CommonMerkleTreeID = {
  master: 0,
  kbfsPublic: 1,
  kbfsPrivate: 2,
}

export const ConfigForkType = {
  none: 0,
  auto: 1,
  watchdog: 2,
  launchd: 3,
}

export const ConstantsStatusCode = {
  scok: 0,
  scinputerror: 100,
  scloginrequired: 201,
  scbadsession: 202,
  scbadloginusernotfound: 203,
  scbadloginpassword: 204,
  scnotfound: 205,
  scthrottlecontrol: 210,
  scdeleted: 216,
  scgeneric: 218,
  scalreadyloggedin: 235,
  scexists: 230,
  sccanceled: 237,
  scinputcanceled: 239,
  screloginrequired: 274,
  scresolutionfailed: 275,
  scprofilenotpublic: 276,
  scidentifyfailed: 277,
  sctrackingbroke: 278,
  scwrongcryptoformat: 279,
  scdecryptionerror: 280,
  scinvalidaddress: 281,
  scnosession: 283,
  scbademail: 472,
  scbadsignupusernametaken: 701,
  scbadinvitationcode: 707,
  scmissingresult: 801,
  sckeynotfound: 901,
  sckeyinuse: 907,
  sckeybadgen: 913,
  sckeynosecret: 914,
  sckeybaduids: 915,
  sckeynoactive: 916,
  sckeynosig: 917,
  sckeybadsig: 918,
  sckeybadeldest: 919,
  sckeynoeldest: 920,
  sckeyduplicateupdate: 921,
  scsibkeyalreadyexists: 922,
  scdecryptionkeynotfound: 924,
  sckeynopgpencryption: 927,
  sckeynonaclencryption: 928,
  sckeysyncedpgpnotfound: 929,
  sckeynomatchinggpg: 930,
  sckeyrevoked: 931,
  scbadtracksession: 1301,
  scdevicebadname: 1404,
  scdevicenameinuse: 1408,
  scdevicenotfound: 1409,
  scdevicemismatch: 1410,
  scdevicerequired: 1411,
  scdeviceprevprovisioned: 1413,
  scdevicenoprovision: 1414,
  scstreamexists: 1501,
  scstreamnotfound: 1502,
  scstreamwrongkind: 1503,
  scstreameof: 1504,
  scgenericapierror: 1600,
  scapinetworkerror: 1601,
  sctimeout: 1602,
  scprooferror: 1701,
  scidentificationexpired: 1702,
  scselfnotfound: 1703,
  scbadkexphrase: 1704,
  scnouidelegation: 1705,
  scnoui: 1706,
  scgpgunavailable: 1707,
  scinvalidversionerror: 1800,
  scoldversionerror: 1801,
  scinvalidlocationerror: 1802,
  scservicestatuserror: 1803,
  scinstallerror: 1804,
  scchatinternal: 2500,
  scchatratelimit: 2501,
  scchatconvexists: 2502,
  scchatunknowntlfid: 2503,
  scchatnotinconv: 2504,
  scchatbadmsg: 2505,
  scchatbroadcast: 2506,
  scchatalreadysuperseded: 2507,
  scchatalreadydeleted: 2508,
  scchattlffinalized: 2509,
  scchatcollision: 2510,
  scidentifysummaryerror: 2511,
  scneedselfrekey: 2512,
  scneedotherrekey: 2513,
  scchatmessagecollision: 2514,
}

export const CtlDbType = {
  main: 0,
  chat: 1,
}

export const CtlExitCode = {
  ok: 0,
  notok: 2,
  restart: 4,
}

export const GregorUIPushReason = {
  none: 0,
  reconnected: 1,
  newData: 2,
}

export const IdentifyCommonIdentifyReasonType = {
  none: 0,
  id: 1,
  track: 2,
  encrypt: 3,
  decrypt: 4,
  verify: 5,
  resource: 6,
  background: 7,
}

export const IdentifyCommonTrackDiffType = {
  none: 0,
  error: 1,
  clash: 2,
  revoked: 3,
  upgraded: 4,
  new: 5,
  remoteFail: 6,
  remoteWorking: 7,
  remoteChanged: 8,
  newEldest: 9,
  noneViaTemporary: 10,
}

export const IdentifyCommonTrackStatus = {
  newOk: 1,
  newZeroProofs: 2,
  newFailProofs: 3,
  updateBrokenFailedProofs: 4,
  updateNewProofs: 5,
  updateOk: 6,
  updateBrokenRevoked: 7,
}

export const IdentifyUiCheckResultFreshness = {
  fresh: 0,
  aged: 1,
  rancid: 2,
}

export const IdentifyUiDismissReasonType = {
  none: 0,
  handledElsewhere: 1,
}

export const InstallInstallAction = {
  unknown: 0,
  none: 1,
  upgrade: 2,
  reinstall: 3,
  install: 4,
}

export const InstallInstallStatus = {
  unknown: 0,
  error: 1,
  notInstalled: 2,
  installed: 4,
}

export const KbfsCommonFSErrorType = {
  accessDenied: 0,
  userNotFound: 1,
  revokedDataDetected: 2,
  notLoggedIn: 3,
  timeout: 4,
  rekeyNeeded: 5,
  badFolder: 6,
  notImplemented: 7,
  oldVersion: 8,
  overQuota: 9,
  noSigChain: 10,
  tooManyFolders: 11,
  exdevNotSupported: 12,
}

export const KbfsCommonFSNotificationType = {
  encrypting: 0,
  decrypting: 1,
  signing: 2,
  verifying: 3,
  rekeying: 4,
  connection: 5,
  mdReadSuccess: 6,
  fileCreated: 7,
  fileModified: 8,
  fileDeleted: 9,
  fileRenamed: 10,
}

export const KbfsCommonFSStatusCode = {
  start: 0,
  finish: 1,
  error: 2,
}

export const PassphraseCommonPassphraseType = {
  none: 0,
  paperKey: 1,
  passPhrase: 2,
  verifyPassPhrase: 3,
}

export const PgpSignMode = {
  attached: 0,
  detached: 1,
  clear: 2,
}

export const ProcessFileType = {
  unknown: 0,
  directory: 1,
  file: 2,
}

export const ProveCommonProofState = {
  none: 0,
  ok: 1,
  tempFailure: 2,
  permFailure: 3,
  looking: 4,
  superseded: 5,
  posted: 6,
  revoked: 7,
  deleted: 8,
  unknownType: 9,
  sigHintMissing: 10,
  unchecked: 11,
}

export const ProveCommonProofStatus = {
  none: 0,
  ok: 1,
  local: 2,
  found: 3,
  baseError: 100,
  hostUnreachable: 101,
  permissionDenied: 103,
  failedParse: 106,
  dnsError: 107,
  authFailed: 108,
  http429: 129,
  http500: 150,
  timeout: 160,
  internalError: 170,
  unchecked: 171,
  missingPvl: 172,
  baseHardError: 200,
  notFound: 201,
  contentFailure: 202,
  badUsername: 203,
  badRemoteId: 204,
  textNotFound: 205,
  badArgs: 206,
  contentMissing: 207,
  titleNotFound: 208,
  serviceError: 209,
  torSkipped: 210,
  torIncompatible: 211,
  http300: 230,
  http400: 240,
  httpOther: 260,
  emptyJson: 270,
  deleted: 301,
  serviceDead: 302,
  badSignature: 303,
  badApiUrl: 304,
  unknownType: 305,
  noHint: 306,
  badHintText: 307,
  invalidPvl: 308,
}

export const ProveCommonProofType = {
  none: 0,
  keybase: 1,
  twitter: 2,
  github: 3,
  reddit: 4,
  coinbase: 5,
  hackernews: 6,
  facebook: 8,
  genericWebSite: 1000,
  dns: 1001,
  pgp: 1002,
  rooter: 100001,
}

export const ProveUiPromptOverwriteType = {
  social: 0,
  site: 1,
}

export const ProvisionUiChooseType = {
  existingDevice: 0,
  newDevice: 1,
}

export const ProvisionUiGPGMethod = {
  gpgNone: 0,
  gpgImport: 1,
  gpgSign: 2,
}

export const ProvisionUiProvisionMethod = {
  device: 0,
  paperKey: 1,
  passphrase: 2,
  gpgImport: 3,
  gpgSign: 4,
}

export const ReachabilityReachable = {
  unknown: 0,
  yes: 1,
  no: 2,
}

export const RekeyOutcome = {
  none: 0,
  fixed: 1,
  ignored: 2,
}

export const RekeyUIRekeyEventType = {
  none: 0,
  notLoggedIn: 1,
  apiError: 2,
  noProblems: 3,
  loadMeError: 4,
  currentDeviceCanRekey: 5,
  deviceLoadError: 6,
  harass: 7,
  noGregorMessages: 8,
}

export const SaltpackUiSaltpackSenderType = {
  notTracked: 0,
  unknown: 1,
  anonymous: 2,
  trackingBroke: 3,
  trackingOk: 4,
  self: 5,
  revoked: 6,
  expired: 7,
}

export const SimpleFSAsyncOps = {
  list: 0,
  listRecursive: 1,
  read: 2,
  write: 3,
  copy: 4,
  move: 5,
  remove: 6,
}

export const SimpleFSDirentType = {
  file: 0,
  dir: 1,
  sym: 2,
  exec: 3,
}

export const SimpleFSOpenFlags = {
  read: 0,
  replace: 1,
  existing: 2,
  write: 4,
  append: 8,
  directory: 16,
}

export const SimpleFSPathType = {
  local: 0,
  kbfs: 1,
}

export const TlfKeysTLFIdentifyBehavior = {
  defaultKbfs: 0,
  chatCli: 1,
  chatGui: 2,
  chatGuiStrict: 3,
  kbfsRekey: 4,
  kbfsQr: 5,
  chatSkip: 6,
}

export const UiPromptDefault = {
  none: 0,
  yes: 1,
  no: 2,
}

export function BTCRegisterBTCRpc (request: Exact<requestCommon & requestErrorCallback & {param: BTCRegisterBTCRpcParam}>) {
  engineRpcOutgoing('keybase.1.BTC.registerBTC', request)
}

export function BTCRegisterBTCRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: BTCRegisterBTCRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.BTC.registerBTC', request, callback, incomingCallMap) })
}

export function BTCRegisterBTCRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: BTCRegisterBTCRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.BTC.registerBTC', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function Kex2Provisionee2DidCounterSign2Rpc (request: Exact<requestCommon & requestErrorCallback & {param: Kex2Provisionee2DidCounterSign2RpcParam}>) {
  engineRpcOutgoing('keybase.1.Kex2Provisionee2.didCounterSign2', request)
}

export function Kex2Provisionee2DidCounterSign2RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: Kex2Provisionee2DidCounterSign2RpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.Kex2Provisionee2.didCounterSign2', request, callback, incomingCallMap) })
}

export function Kex2Provisionee2DidCounterSign2RpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: Kex2Provisionee2DidCounterSign2RpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.Kex2Provisionee2.didCounterSign2', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function Kex2Provisionee2Hello2Rpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: Kex2Provisionee2Hello2Result) => void} & {param: Kex2Provisionee2Hello2RpcParam}>) {
  engineRpcOutgoing('keybase.1.Kex2Provisionee2.hello2', request)
}

export function Kex2Provisionee2Hello2RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: Kex2Provisionee2Hello2Result) => void} & {param: Kex2Provisionee2Hello2RpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.Kex2Provisionee2.hello2', request, callback, incomingCallMap) })
}

export function Kex2Provisionee2Hello2RpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: Kex2Provisionee2Hello2Result) => void} & {param: Kex2Provisionee2Hello2RpcParam}>): Promise<Kex2Provisionee2Hello2Result> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.Kex2Provisionee2.hello2', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function Kex2ProvisioneeDidCounterSignRpc (request: Exact<requestCommon & requestErrorCallback & {param: Kex2ProvisioneeDidCounterSignRpcParam}>) {
  engineRpcOutgoing('keybase.1.Kex2Provisionee.didCounterSign', request)
}

export function Kex2ProvisioneeDidCounterSignRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: Kex2ProvisioneeDidCounterSignRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.Kex2Provisionee.didCounterSign', request, callback, incomingCallMap) })
}

export function Kex2ProvisioneeDidCounterSignRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: Kex2ProvisioneeDidCounterSignRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.Kex2Provisionee.didCounterSign', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function Kex2ProvisioneeHelloRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: Kex2ProvisioneeHelloResult) => void} & {param: Kex2ProvisioneeHelloRpcParam}>) {
  engineRpcOutgoing('keybase.1.Kex2Provisionee.hello', request)
}

export function Kex2ProvisioneeHelloRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: Kex2ProvisioneeHelloResult) => void} & {param: Kex2ProvisioneeHelloRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.Kex2Provisionee.hello', request, callback, incomingCallMap) })
}

export function Kex2ProvisioneeHelloRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: Kex2ProvisioneeHelloResult) => void} & {param: Kex2ProvisioneeHelloRpcParam}>): Promise<Kex2ProvisioneeHelloResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.Kex2Provisionee.hello', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function Kex2ProvisionerKexStartRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.Kex2Provisioner.kexStart', request)
}

export function Kex2ProvisionerKexStartRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.Kex2Provisioner.kexStart', request, callback, incomingCallMap) })
}

export function Kex2ProvisionerKexStartRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.Kex2Provisioner.kexStart', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function NotifyFSRequestFSEditListRequestRpc (request: Exact<requestCommon & requestErrorCallback & {param: NotifyFSRequestFSEditListRequestRpcParam}>) {
  engineRpcOutgoing('keybase.1.NotifyFSRequest.FSEditListRequest', request)
}

export function NotifyFSRequestFSEditListRequestRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: NotifyFSRequestFSEditListRequestRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.NotifyFSRequest.FSEditListRequest', request, callback, incomingCallMap) })
}

export function NotifyFSRequestFSEditListRequestRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: NotifyFSRequestFSEditListRequestRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.NotifyFSRequest.FSEditListRequest', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function NotifyFSRequestFSSyncStatusRequestRpc (request: Exact<requestCommon & requestErrorCallback & {param: NotifyFSRequestFSSyncStatusRequestRpcParam}>) {
  engineRpcOutgoing('keybase.1.NotifyFSRequest.FSSyncStatusRequest', request)
}

export function NotifyFSRequestFSSyncStatusRequestRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: NotifyFSRequestFSSyncStatusRequestRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.NotifyFSRequest.FSSyncStatusRequest', request, callback, incomingCallMap) })
}

export function NotifyFSRequestFSSyncStatusRequestRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: NotifyFSRequestFSSyncStatusRequestRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.NotifyFSRequest.FSSyncStatusRequest', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ScanProofsScanProofsRpc (request: Exact<requestCommon & requestErrorCallback & {param: ScanProofsScanProofsRpcParam}>) {
  engineRpcOutgoing('keybase.1.ScanProofs.scanProofs', request)
}

export function ScanProofsScanProofsRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: ScanProofsScanProofsRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ScanProofs.scanProofs', request, callback, incomingCallMap) })
}

export function ScanProofsScanProofsRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: ScanProofsScanProofsRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ScanProofs.scanProofs', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SecretKeysGetSecretKeysRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: SecretKeysGetSecretKeysResult) => void}>) {
  engineRpcOutgoing('keybase.1.SecretKeys.getSecretKeys', request)
}

export function SecretKeysGetSecretKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SecretKeysGetSecretKeysResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SecretKeys.getSecretKeys', request, callback, incomingCallMap) })
}

export function SecretKeysGetSecretKeysRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SecretKeysGetSecretKeysResult) => void}>): Promise<SecretKeysGetSecretKeysResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SecretKeys.getSecretKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSCancelRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCancelRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCancel', request)
}

export function SimpleFSSimpleFSCancelRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCancelRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCancel', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSCancelRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCancelRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCancel', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSCheckRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSCheckResult) => void} & {param: SimpleFSSimpleFSCheckRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCheck', request)
}

export function SimpleFSSimpleFSCheckRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSCheckResult) => void} & {param: SimpleFSSimpleFSCheckRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCheck', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSCheckRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSCheckResult) => void} & {param: SimpleFSSimpleFSCheckRpcParam}>): Promise<SimpleFSSimpleFSCheckResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCheck', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSCloseRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCloseRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSClose', request)
}

export function SimpleFSSimpleFSCloseRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCloseRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSClose', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSCloseRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCloseRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSClose', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSCopyRecursiveRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCopyRecursiveRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCopyRecursive', request)
}

export function SimpleFSSimpleFSCopyRecursiveRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCopyRecursiveRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCopyRecursive', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSCopyRecursiveRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCopyRecursiveRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCopyRecursive', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSCopyRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCopyRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCopy', request)
}

export function SimpleFSSimpleFSCopyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCopyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCopy', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSCopyRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSCopyRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSCopy', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSGetOpsRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSGetOpsResult) => void}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSGetOps', request)
}

export function SimpleFSSimpleFSGetOpsRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSGetOpsResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSGetOps', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSGetOpsRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSGetOpsResult) => void}>): Promise<SimpleFSSimpleFSGetOpsResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSGetOps', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSListRecursiveRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSListRecursiveRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSListRecursive', request)
}

export function SimpleFSSimpleFSListRecursiveRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSListRecursiveRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSListRecursive', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSListRecursiveRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSListRecursiveRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSListRecursive', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSListRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSListRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSList', request)
}

export function SimpleFSSimpleFSListRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSListRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSList', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSListRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSListRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSList', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSMakeOpidRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSMakeOpidResult) => void}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSMakeOpid', request)
}

export function SimpleFSSimpleFSMakeOpidRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSMakeOpidResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSMakeOpid', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSMakeOpidRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSMakeOpidResult) => void}>): Promise<SimpleFSSimpleFSMakeOpidResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSMakeOpid', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSMoveRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSMoveRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSMove', request)
}

export function SimpleFSSimpleFSMoveRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSMoveRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSMove', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSMoveRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSMoveRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSMove', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSOpenRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSOpenRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSOpen', request)
}

export function SimpleFSSimpleFSOpenRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSOpenRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSOpen', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSOpenRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSOpenRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSOpen', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSReadListRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSReadListResult) => void} & {param: SimpleFSSimpleFSReadListRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSReadList', request)
}

export function SimpleFSSimpleFSReadListRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSReadListResult) => void} & {param: SimpleFSSimpleFSReadListRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSReadList', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSReadListRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSReadListResult) => void} & {param: SimpleFSSimpleFSReadListRpcParam}>): Promise<SimpleFSSimpleFSReadListResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSReadList', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSReadRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSReadResult) => void} & {param: SimpleFSSimpleFSReadRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRead', request)
}

export function SimpleFSSimpleFSReadRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSReadResult) => void} & {param: SimpleFSSimpleFSReadRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRead', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSReadRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSReadResult) => void} & {param: SimpleFSSimpleFSReadRpcParam}>): Promise<SimpleFSSimpleFSReadResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRead', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSRemoveRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSRemoveRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRemove', request)
}

export function SimpleFSSimpleFSRemoveRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSRemoveRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRemove', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSRemoveRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSRemoveRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRemove', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSRenameRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSRenameRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRename', request)
}

export function SimpleFSSimpleFSRenameRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSRenameRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRename', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSRenameRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSRenameRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSRename', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSSetStatRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSSetStatRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSSetStat', request)
}

export function SimpleFSSimpleFSSetStatRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSSetStatRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSSetStat', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSSetStatRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSSetStatRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSSetStat', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSStatRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSStatResult) => void} & {param: SimpleFSSimpleFSStatRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSStat', request)
}

export function SimpleFSSimpleFSStatRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSStatResult) => void} & {param: SimpleFSSimpleFSStatRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSStat', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSStatRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: SimpleFSSimpleFSStatResult) => void} & {param: SimpleFSSimpleFSStatRpcParam}>): Promise<SimpleFSSimpleFSStatResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSStat', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSWaitRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSWaitRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSWait', request)
}

export function SimpleFSSimpleFSWaitRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSWaitRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSWait', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSWaitRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSWaitRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSWait', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function SimpleFSSimpleFSWriteRpc (request: Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSWriteRpcParam}>) {
  engineRpcOutgoing('keybase.1.SimpleFS.simpleFSWrite', request)
}

export function SimpleFSSimpleFSWriteRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSWriteRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.SimpleFS.simpleFSWrite', request, callback, incomingCallMap) })
}

export function SimpleFSSimpleFSWriteRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: SimpleFSSimpleFSWriteRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.SimpleFS.simpleFSWrite', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function accountEmailChangeRpc (request: Exact<requestCommon & requestErrorCallback & {param: accountEmailChangeRpcParam}>) {
  engineRpcOutgoing('keybase.1.account.emailChange', request)
}

export function accountEmailChangeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: accountEmailChangeRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.account.emailChange', request, callback, incomingCallMap) })
}

export function accountEmailChangeRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: accountEmailChangeRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.account.emailChange', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function accountHasServerKeysRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: accountHasServerKeysResult) => void}>) {
  engineRpcOutgoing('keybase.1.account.hasServerKeys', request)
}

export function accountHasServerKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: accountHasServerKeysResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.account.hasServerKeys', request, callback, incomingCallMap) })
}

export function accountHasServerKeysRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: accountHasServerKeysResult) => void}>): Promise<accountHasServerKeysResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.account.hasServerKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function accountPassphraseChangeRpc (request: Exact<requestCommon & requestErrorCallback & {param: accountPassphraseChangeRpcParam}>) {
  engineRpcOutgoing('keybase.1.account.passphraseChange', request)
}

export function accountPassphraseChangeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: accountPassphraseChangeRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.account.passphraseChange', request, callback, incomingCallMap) })
}

export function accountPassphraseChangeRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: accountPassphraseChangeRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.account.passphraseChange', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function accountPassphrasePromptRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: accountPassphrasePromptResult) => void} & {param: accountPassphrasePromptRpcParam}>) {
  engineRpcOutgoing('keybase.1.account.passphrasePrompt', request)
}

export function accountPassphrasePromptRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: accountPassphrasePromptResult) => void} & {param: accountPassphrasePromptRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.account.passphrasePrompt', request, callback, incomingCallMap) })
}

export function accountPassphrasePromptRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: accountPassphrasePromptResult) => void} & {param: accountPassphrasePromptRpcParam}>): Promise<accountPassphrasePromptResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.account.passphrasePrompt', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function accountResetAccountRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.account.resetAccount', request)
}

export function accountResetAccountRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.account.resetAccount', request, callback, incomingCallMap) })
}

export function accountResetAccountRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.account.resetAccount', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function apiserverGetRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverGetResult) => void} & {param: apiserverGetRpcParam}>) {
  engineRpcOutgoing('keybase.1.apiserver.Get', request)
}

export function apiserverGetRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverGetResult) => void} & {param: apiserverGetRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.apiserver.Get', request, callback, incomingCallMap) })
}

export function apiserverGetRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverGetResult) => void} & {param: apiserverGetRpcParam}>): Promise<apiserverGetResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.apiserver.Get', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function apiserverPostJSONRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverPostJSONResult) => void} & {param: apiserverPostJSONRpcParam}>) {
  engineRpcOutgoing('keybase.1.apiserver.PostJSON', request)
}

export function apiserverPostJSONRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverPostJSONResult) => void} & {param: apiserverPostJSONRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.apiserver.PostJSON', request, callback, incomingCallMap) })
}

export function apiserverPostJSONRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverPostJSONResult) => void} & {param: apiserverPostJSONRpcParam}>): Promise<apiserverPostJSONResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.apiserver.PostJSON', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function apiserverPostRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverPostResult) => void} & {param: apiserverPostRpcParam}>) {
  engineRpcOutgoing('keybase.1.apiserver.Post', request)
}

export function apiserverPostRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverPostResult) => void} & {param: apiserverPostRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.apiserver.Post', request, callback, incomingCallMap) })
}

export function apiserverPostRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: apiserverPostResult) => void} & {param: apiserverPostRpcParam}>): Promise<apiserverPostResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.apiserver.Post', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockAddReferenceRpc (request: Exact<requestCommon & requestErrorCallback & {param: blockAddReferenceRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.addReference', request)
}

export function blockAddReferenceRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: blockAddReferenceRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.addReference', request, callback, incomingCallMap) })
}

export function blockAddReferenceRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: blockAddReferenceRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.addReference', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockArchiveReferenceRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: blockArchiveReferenceResult) => void} & {param: blockArchiveReferenceRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.archiveReference', request)
}

export function blockArchiveReferenceRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockArchiveReferenceResult) => void} & {param: blockArchiveReferenceRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.archiveReference', request, callback, incomingCallMap) })
}

export function blockArchiveReferenceRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockArchiveReferenceResult) => void} & {param: blockArchiveReferenceRpcParam}>): Promise<blockArchiveReferenceResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.archiveReference', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockArchiveReferenceWithCountRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: blockArchiveReferenceWithCountResult) => void} & {param: blockArchiveReferenceWithCountRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.archiveReferenceWithCount', request)
}

export function blockArchiveReferenceWithCountRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockArchiveReferenceWithCountResult) => void} & {param: blockArchiveReferenceWithCountRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.archiveReferenceWithCount', request, callback, incomingCallMap) })
}

export function blockArchiveReferenceWithCountRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockArchiveReferenceWithCountResult) => void} & {param: blockArchiveReferenceWithCountRpcParam}>): Promise<blockArchiveReferenceWithCountResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.archiveReferenceWithCount', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockAuthenticateSessionRpc (request: Exact<requestCommon & requestErrorCallback & {param: blockAuthenticateSessionRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.authenticateSession', request)
}

export function blockAuthenticateSessionRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: blockAuthenticateSessionRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.authenticateSession', request, callback, incomingCallMap) })
}

export function blockAuthenticateSessionRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: blockAuthenticateSessionRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.authenticateSession', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockBlockPingRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: blockBlockPingResult) => void}>) {
  engineRpcOutgoing('keybase.1.block.blockPing', request)
}

export function blockBlockPingRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockBlockPingResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.blockPing', request, callback, incomingCallMap) })
}

export function blockBlockPingRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockBlockPingResult) => void}>): Promise<blockBlockPingResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.blockPing', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockDelReferenceRpc (request: Exact<requestCommon & requestErrorCallback & {param: blockDelReferenceRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.delReference', request)
}

export function blockDelReferenceRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: blockDelReferenceRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.delReference', request, callback, incomingCallMap) })
}

export function blockDelReferenceRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: blockDelReferenceRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.delReference', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockDelReferenceWithCountRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: blockDelReferenceWithCountResult) => void} & {param: blockDelReferenceWithCountRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.delReferenceWithCount', request)
}

export function blockDelReferenceWithCountRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockDelReferenceWithCountResult) => void} & {param: blockDelReferenceWithCountRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.delReferenceWithCount', request, callback, incomingCallMap) })
}

export function blockDelReferenceWithCountRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockDelReferenceWithCountResult) => void} & {param: blockDelReferenceWithCountRpcParam}>): Promise<blockDelReferenceWithCountResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.delReferenceWithCount', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockGetBlockRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetBlockResult) => void} & {param: blockGetBlockRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.getBlock', request)
}

export function blockGetBlockRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetBlockResult) => void} & {param: blockGetBlockRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.getBlock', request, callback, incomingCallMap) })
}

export function blockGetBlockRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetBlockResult) => void} & {param: blockGetBlockRpcParam}>): Promise<blockGetBlockResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.getBlock', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockGetSessionChallengeRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetSessionChallengeResult) => void}>) {
  engineRpcOutgoing('keybase.1.block.getSessionChallenge', request)
}

export function blockGetSessionChallengeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetSessionChallengeResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.getSessionChallenge', request, callback, incomingCallMap) })
}

export function blockGetSessionChallengeRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetSessionChallengeResult) => void}>): Promise<blockGetSessionChallengeResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.getSessionChallenge', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockGetUserQuotaInfoRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetUserQuotaInfoResult) => void}>) {
  engineRpcOutgoing('keybase.1.block.getUserQuotaInfo', request)
}

export function blockGetUserQuotaInfoRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetUserQuotaInfoResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.getUserQuotaInfo', request, callback, incomingCallMap) })
}

export function blockGetUserQuotaInfoRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: blockGetUserQuotaInfoResult) => void}>): Promise<blockGetUserQuotaInfoResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.getUserQuotaInfo', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function blockPutBlockRpc (request: Exact<requestCommon & requestErrorCallback & {param: blockPutBlockRpcParam}>) {
  engineRpcOutgoing('keybase.1.block.putBlock', request)
}

export function blockPutBlockRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: blockPutBlockRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.block.putBlock', request, callback, incomingCallMap) })
}

export function blockPutBlockRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: blockPutBlockRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.block.putBlock', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configCheckAPIServerOutOfDateWarningRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: configCheckAPIServerOutOfDateWarningResult) => void}>) {
  engineRpcOutgoing('keybase.1.config.checkAPIServerOutOfDateWarning', request)
}

export function configCheckAPIServerOutOfDateWarningRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configCheckAPIServerOutOfDateWarningResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.checkAPIServerOutOfDateWarning', request, callback, incomingCallMap) })
}

export function configCheckAPIServerOutOfDateWarningRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configCheckAPIServerOutOfDateWarningResult) => void}>): Promise<configCheckAPIServerOutOfDateWarningResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.checkAPIServerOutOfDateWarning', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configClearValueRpc (request: Exact<requestCommon & requestErrorCallback & {param: configClearValueRpcParam}>) {
  engineRpcOutgoing('keybase.1.config.clearValue', request)
}

export function configClearValueRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: configClearValueRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.clearValue', request, callback, incomingCallMap) })
}

export function configClearValueRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: configClearValueRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.clearValue', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configGetConfigRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: configGetConfigResult) => void}>) {
  engineRpcOutgoing('keybase.1.config.getConfig', request)
}

export function configGetConfigRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetConfigResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.getConfig', request, callback, incomingCallMap) })
}

export function configGetConfigRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetConfigResult) => void}>): Promise<configGetConfigResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.getConfig', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configGetCurrentStatusRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: configGetCurrentStatusResult) => void}>) {
  engineRpcOutgoing('keybase.1.config.getCurrentStatus', request)
}

export function configGetCurrentStatusRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetCurrentStatusResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.getCurrentStatus', request, callback, incomingCallMap) })
}

export function configGetCurrentStatusRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetCurrentStatusResult) => void}>): Promise<configGetCurrentStatusResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.getCurrentStatus', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configGetExtendedStatusRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: configGetExtendedStatusResult) => void}>) {
  engineRpcOutgoing('keybase.1.config.getExtendedStatus', request)
}

export function configGetExtendedStatusRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetExtendedStatusResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.getExtendedStatus', request, callback, incomingCallMap) })
}

export function configGetExtendedStatusRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetExtendedStatusResult) => void}>): Promise<configGetExtendedStatusResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.getExtendedStatus', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configGetValueRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: configGetValueResult) => void} & {param: configGetValueRpcParam}>) {
  engineRpcOutgoing('keybase.1.config.getValue', request)
}

export function configGetValueRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetValueResult) => void} & {param: configGetValueRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.getValue', request, callback, incomingCallMap) })
}

export function configGetValueRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configGetValueResult) => void} & {param: configGetValueRpcParam}>): Promise<configGetValueResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.getValue', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configHelloIAmRpc (request: Exact<requestCommon & requestErrorCallback & {param: configHelloIAmRpcParam}>) {
  engineRpcOutgoing('keybase.1.config.helloIAm', request)
}

export function configHelloIAmRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: configHelloIAmRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.helloIAm', request, callback, incomingCallMap) })
}

export function configHelloIAmRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: configHelloIAmRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.helloIAm', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configSetPathRpc (request: Exact<requestCommon & requestErrorCallback & {param: configSetPathRpcParam}>) {
  engineRpcOutgoing('keybase.1.config.setPath', request)
}

export function configSetPathRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: configSetPathRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.setPath', request, callback, incomingCallMap) })
}

export function configSetPathRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: configSetPathRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.setPath', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configSetUserConfigRpc (request: Exact<requestCommon & requestErrorCallback & {param: configSetUserConfigRpcParam}>) {
  engineRpcOutgoing('keybase.1.config.setUserConfig', request)
}

export function configSetUserConfigRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: configSetUserConfigRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.setUserConfig', request, callback, incomingCallMap) })
}

export function configSetUserConfigRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: configSetUserConfigRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.setUserConfig', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configSetValueRpc (request: Exact<requestCommon & requestErrorCallback & {param: configSetValueRpcParam}>) {
  engineRpcOutgoing('keybase.1.config.setValue', request)
}

export function configSetValueRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: configSetValueRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.setValue', request, callback, incomingCallMap) })
}

export function configSetValueRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: configSetValueRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.setValue', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function configWaitForClientRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: configWaitForClientResult) => void} & {param: configWaitForClientRpcParam}>) {
  engineRpcOutgoing('keybase.1.config.waitForClient', request)
}

export function configWaitForClientRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configWaitForClientResult) => void} & {param: configWaitForClientRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.config.waitForClient', request, callback, incomingCallMap) })
}

export function configWaitForClientRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: configWaitForClientResult) => void} & {param: configWaitForClientRpcParam}>): Promise<configWaitForClientResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.config.waitForClient', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function cryptoSignED25519ForKBFSRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignED25519ForKBFSResult) => void} & {param: cryptoSignED25519ForKBFSRpcParam}>) {
  engineRpcOutgoing('keybase.1.crypto.signED25519ForKBFS', request)
}

export function cryptoSignED25519ForKBFSRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignED25519ForKBFSResult) => void} & {param: cryptoSignED25519ForKBFSRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.crypto.signED25519ForKBFS', request, callback, incomingCallMap) })
}

export function cryptoSignED25519ForKBFSRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignED25519ForKBFSResult) => void} & {param: cryptoSignED25519ForKBFSRpcParam}>): Promise<cryptoSignED25519ForKBFSResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.crypto.signED25519ForKBFS', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function cryptoSignED25519Rpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignED25519Result) => void} & {param: cryptoSignED25519RpcParam}>) {
  engineRpcOutgoing('keybase.1.crypto.signED25519', request)
}

export function cryptoSignED25519RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignED25519Result) => void} & {param: cryptoSignED25519RpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.crypto.signED25519', request, callback, incomingCallMap) })
}

export function cryptoSignED25519RpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignED25519Result) => void} & {param: cryptoSignED25519RpcParam}>): Promise<cryptoSignED25519Result> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.crypto.signED25519', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function cryptoSignToStringRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignToStringResult) => void} & {param: cryptoSignToStringRpcParam}>) {
  engineRpcOutgoing('keybase.1.crypto.signToString', request)
}

export function cryptoSignToStringRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignToStringResult) => void} & {param: cryptoSignToStringRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.crypto.signToString', request, callback, incomingCallMap) })
}

export function cryptoSignToStringRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoSignToStringResult) => void} & {param: cryptoSignToStringRpcParam}>): Promise<cryptoSignToStringResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.crypto.signToString', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function cryptoUnboxBytes32AnyRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoUnboxBytes32AnyResult) => void} & {param: cryptoUnboxBytes32AnyRpcParam}>) {
  engineRpcOutgoing('keybase.1.crypto.unboxBytes32Any', request)
}

export function cryptoUnboxBytes32AnyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoUnboxBytes32AnyResult) => void} & {param: cryptoUnboxBytes32AnyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.crypto.unboxBytes32Any', request, callback, incomingCallMap) })
}

export function cryptoUnboxBytes32AnyRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoUnboxBytes32AnyResult) => void} & {param: cryptoUnboxBytes32AnyRpcParam}>): Promise<cryptoUnboxBytes32AnyResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.crypto.unboxBytes32Any', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function cryptoUnboxBytes32Rpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoUnboxBytes32Result) => void} & {param: cryptoUnboxBytes32RpcParam}>) {
  engineRpcOutgoing('keybase.1.crypto.unboxBytes32', request)
}

export function cryptoUnboxBytes32RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoUnboxBytes32Result) => void} & {param: cryptoUnboxBytes32RpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.crypto.unboxBytes32', request, callback, incomingCallMap) })
}

export function cryptoUnboxBytes32RpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptoUnboxBytes32Result) => void} & {param: cryptoUnboxBytes32RpcParam}>): Promise<cryptoUnboxBytes32Result> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.crypto.unboxBytes32', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function cryptocurrencyRegisterAddressRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: cryptocurrencyRegisterAddressResult) => void} & {param: cryptocurrencyRegisterAddressRpcParam}>) {
  engineRpcOutgoing('keybase.1.cryptocurrency.registerAddress', request)
}

export function cryptocurrencyRegisterAddressRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptocurrencyRegisterAddressResult) => void} & {param: cryptocurrencyRegisterAddressRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.cryptocurrency.registerAddress', request, callback, incomingCallMap) })
}

export function cryptocurrencyRegisterAddressRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: cryptocurrencyRegisterAddressResult) => void} & {param: cryptocurrencyRegisterAddressRpcParam}>): Promise<cryptocurrencyRegisterAddressResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.cryptocurrency.registerAddress', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlAppExitRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.ctl.appExit', request)
}

export function ctlAppExitRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.appExit', request, callback, incomingCallMap) })
}

export function ctlAppExitRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.appExit', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlDbDeleteRpc (request: Exact<requestCommon & requestErrorCallback & {param: ctlDbDeleteRpcParam}>) {
  engineRpcOutgoing('keybase.1.ctl.dbDelete', request)
}

export function ctlDbDeleteRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: ctlDbDeleteRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.dbDelete', request, callback, incomingCallMap) })
}

export function ctlDbDeleteRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: ctlDbDeleteRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.dbDelete', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlDbGetRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: ctlDbGetResult) => void} & {param: ctlDbGetRpcParam}>) {
  engineRpcOutgoing('keybase.1.ctl.dbGet', request)
}

export function ctlDbGetRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: ctlDbGetResult) => void} & {param: ctlDbGetRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.dbGet', request, callback, incomingCallMap) })
}

export function ctlDbGetRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: ctlDbGetResult) => void} & {param: ctlDbGetRpcParam}>): Promise<ctlDbGetResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.dbGet', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlDbNukeRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.ctl.dbNuke', request)
}

export function ctlDbNukeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.dbNuke', request, callback, incomingCallMap) })
}

export function ctlDbNukeRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.dbNuke', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlDbPutRpc (request: Exact<requestCommon & requestErrorCallback & {param: ctlDbPutRpcParam}>) {
  engineRpcOutgoing('keybase.1.ctl.dbPut', request)
}

export function ctlDbPutRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: ctlDbPutRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.dbPut', request, callback, incomingCallMap) })
}

export function ctlDbPutRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: ctlDbPutRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.dbPut', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlLogRotateRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.ctl.logRotate', request)
}

export function ctlLogRotateRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.logRotate', request, callback, incomingCallMap) })
}

export function ctlLogRotateRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.logRotate', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlReloadRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.ctl.reload', request)
}

export function ctlReloadRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.reload', request, callback, incomingCallMap) })
}

export function ctlReloadRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.reload', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function ctlStopRpc (request: Exact<requestCommon & requestErrorCallback & {param: ctlStopRpcParam}>) {
  engineRpcOutgoing('keybase.1.ctl.stop', request)
}

export function ctlStopRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: ctlStopRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.ctl.stop', request, callback, incomingCallMap) })
}

export function ctlStopRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: ctlStopRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.ctl.stop', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function debuggingFirstStepRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingFirstStepResult) => void} & {param: debuggingFirstStepRpcParam}>) {
  engineRpcOutgoing('keybase.1.debugging.firstStep', request)
}

export function debuggingFirstStepRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingFirstStepResult) => void} & {param: debuggingFirstStepRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.debugging.firstStep', request, callback, incomingCallMap) })
}

export function debuggingFirstStepRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingFirstStepResult) => void} & {param: debuggingFirstStepRpcParam}>): Promise<debuggingFirstStepResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.debugging.firstStep', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function debuggingIncrementRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingIncrementResult) => void} & {param: debuggingIncrementRpcParam}>) {
  engineRpcOutgoing('keybase.1.debugging.increment', request)
}

export function debuggingIncrementRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingIncrementResult) => void} & {param: debuggingIncrementRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.debugging.increment', request, callback, incomingCallMap) })
}

export function debuggingIncrementRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingIncrementResult) => void} & {param: debuggingIncrementRpcParam}>): Promise<debuggingIncrementResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.debugging.increment', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function debuggingSecondStepRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingSecondStepResult) => void} & {param: debuggingSecondStepRpcParam}>) {
  engineRpcOutgoing('keybase.1.debugging.secondStep', request)
}

export function debuggingSecondStepRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingSecondStepResult) => void} & {param: debuggingSecondStepRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.debugging.secondStep', request, callback, incomingCallMap) })
}

export function debuggingSecondStepRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: debuggingSecondStepResult) => void} & {param: debuggingSecondStepRpcParam}>): Promise<debuggingSecondStepResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.debugging.secondStep', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function delegateUiCtlRegisterGregorFirehoseRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.delegateUiCtl.registerGregorFirehose', request)
}

export function delegateUiCtlRegisterGregorFirehoseRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.delegateUiCtl.registerGregorFirehose', request, callback, incomingCallMap) })
}

export function delegateUiCtlRegisterGregorFirehoseRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.delegateUiCtl.registerGregorFirehose', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function delegateUiCtlRegisterIdentifyUIRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.delegateUiCtl.registerIdentifyUI', request)
}

export function delegateUiCtlRegisterIdentifyUIRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.delegateUiCtl.registerIdentifyUI', request, callback, incomingCallMap) })
}

export function delegateUiCtlRegisterIdentifyUIRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.delegateUiCtl.registerIdentifyUI', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function delegateUiCtlRegisterRekeyUIRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.delegateUiCtl.registerRekeyUI', request)
}

export function delegateUiCtlRegisterRekeyUIRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.delegateUiCtl.registerRekeyUI', request, callback, incomingCallMap) })
}

export function delegateUiCtlRegisterRekeyUIRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.delegateUiCtl.registerRekeyUI', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function delegateUiCtlRegisterSecretUIRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.delegateUiCtl.registerSecretUI', request)
}

export function delegateUiCtlRegisterSecretUIRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.delegateUiCtl.registerSecretUI', request, callback, incomingCallMap) })
}

export function delegateUiCtlRegisterSecretUIRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.delegateUiCtl.registerSecretUI', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function delegateUiCtlRegisterUpdateUIRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.delegateUiCtl.registerUpdateUI', request)
}

export function delegateUiCtlRegisterUpdateUIRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.delegateUiCtl.registerUpdateUI', request, callback, incomingCallMap) })
}

export function delegateUiCtlRegisterUpdateUIRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.delegateUiCtl.registerUpdateUI', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function deviceCheckDeviceNameForUserRpc (request: Exact<requestCommon & requestErrorCallback & {param: deviceCheckDeviceNameForUserRpcParam}>) {
  engineRpcOutgoing('keybase.1.device.checkDeviceNameForUser', request)
}

export function deviceCheckDeviceNameForUserRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: deviceCheckDeviceNameForUserRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.device.checkDeviceNameForUser', request, callback, incomingCallMap) })
}

export function deviceCheckDeviceNameForUserRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: deviceCheckDeviceNameForUserRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.device.checkDeviceNameForUser', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function deviceCheckDeviceNameFormatRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: deviceCheckDeviceNameFormatResult) => void} & {param: deviceCheckDeviceNameFormatRpcParam}>) {
  engineRpcOutgoing('keybase.1.device.checkDeviceNameFormat', request)
}

export function deviceCheckDeviceNameFormatRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: deviceCheckDeviceNameFormatResult) => void} & {param: deviceCheckDeviceNameFormatRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.device.checkDeviceNameFormat', request, callback, incomingCallMap) })
}

export function deviceCheckDeviceNameFormatRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: deviceCheckDeviceNameFormatResult) => void} & {param: deviceCheckDeviceNameFormatRpcParam}>): Promise<deviceCheckDeviceNameFormatResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.device.checkDeviceNameFormat', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function deviceDeviceAddRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.device.deviceAdd', request)
}

export function deviceDeviceAddRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.device.deviceAdd', request, callback, incomingCallMap) })
}

export function deviceDeviceAddRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.device.deviceAdd', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function deviceDeviceHistoryListRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: deviceDeviceHistoryListResult) => void}>) {
  engineRpcOutgoing('keybase.1.device.deviceHistoryList', request)
}

export function deviceDeviceHistoryListRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: deviceDeviceHistoryListResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.device.deviceHistoryList', request, callback, incomingCallMap) })
}

export function deviceDeviceHistoryListRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: deviceDeviceHistoryListResult) => void}>): Promise<deviceDeviceHistoryListResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.device.deviceHistoryList', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function deviceDeviceListRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: deviceDeviceListResult) => void}>) {
  engineRpcOutgoing('keybase.1.device.deviceList', request)
}

export function deviceDeviceListRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: deviceDeviceListResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.device.deviceList', request, callback, incomingCallMap) })
}

export function deviceDeviceListRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: deviceDeviceListResult) => void}>): Promise<deviceDeviceListResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.device.deviceList', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function favoriteFavoriteAddRpc (request: Exact<requestCommon & requestErrorCallback & {param: favoriteFavoriteAddRpcParam}>) {
  engineRpcOutgoing('keybase.1.favorite.favoriteAdd', request)
}

export function favoriteFavoriteAddRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: favoriteFavoriteAddRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.favorite.favoriteAdd', request, callback, incomingCallMap) })
}

export function favoriteFavoriteAddRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: favoriteFavoriteAddRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.favorite.favoriteAdd', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function favoriteFavoriteIgnoreRpc (request: Exact<requestCommon & requestErrorCallback & {param: favoriteFavoriteIgnoreRpcParam}>) {
  engineRpcOutgoing('keybase.1.favorite.favoriteIgnore', request)
}

export function favoriteFavoriteIgnoreRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: favoriteFavoriteIgnoreRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.favorite.favoriteIgnore', request, callback, incomingCallMap) })
}

export function favoriteFavoriteIgnoreRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: favoriteFavoriteIgnoreRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.favorite.favoriteIgnore', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function favoriteGetFavoritesRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: favoriteGetFavoritesResult) => void}>) {
  engineRpcOutgoing('keybase.1.favorite.getFavorites', request)
}

export function favoriteGetFavoritesRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: favoriteGetFavoritesResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.favorite.getFavorites', request, callback, incomingCallMap) })
}

export function favoriteGetFavoritesRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: favoriteGetFavoritesResult) => void}>): Promise<favoriteGetFavoritesResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.favorite.getFavorites', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function fsListRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: fsListResult) => void} & {param: fsListRpcParam}>) {
  engineRpcOutgoing('keybase.1.fs.List', request)
}

export function fsListRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: fsListResult) => void} & {param: fsListRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.fs.List', request, callback, incomingCallMap) })
}

export function fsListRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: fsListResult) => void} & {param: fsListRpcParam}>): Promise<fsListResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.fs.List', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function gregorGetStateRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: gregorGetStateResult) => void}>) {
  engineRpcOutgoing('keybase.1.gregor.getState', request)
}

export function gregorGetStateRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: gregorGetStateResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.gregor.getState', request, callback, incomingCallMap) })
}

export function gregorGetStateRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: gregorGetStateResult) => void}>): Promise<gregorGetStateResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.gregor.getState', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function identifyIdentify2Rpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: identifyIdentify2Result) => void} & {param: identifyIdentify2RpcParam}>) {
  engineRpcOutgoing('keybase.1.identify.identify2', request)
}

export function identifyIdentify2RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyIdentify2Result) => void} & {param: identifyIdentify2RpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.identify.identify2', request, callback, incomingCallMap) })
}

export function identifyIdentify2RpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyIdentify2Result) => void} & {param: identifyIdentify2RpcParam}>): Promise<identifyIdentify2Result> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.identify.identify2', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function identifyIdentifyRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: identifyIdentifyResult) => void} & {param: identifyIdentifyRpcParam}>) {
  engineRpcOutgoing('keybase.1.identify.identify', request)
}

export function identifyIdentifyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyIdentifyResult) => void} & {param: identifyIdentifyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.identify.identify', request, callback, incomingCallMap) })
}

export function identifyIdentifyRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyIdentifyResult) => void} & {param: identifyIdentifyRpcParam}>): Promise<identifyIdentifyResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.identify.identify', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function identifyResolve2Rpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: identifyResolve2Result) => void} & {param: identifyResolve2RpcParam}>) {
  engineRpcOutgoing('keybase.1.identify.Resolve2', request)
}

export function identifyResolve2RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyResolve2Result) => void} & {param: identifyResolve2RpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.identify.Resolve2', request, callback, incomingCallMap) })
}

export function identifyResolve2RpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyResolve2Result) => void} & {param: identifyResolve2RpcParam}>): Promise<identifyResolve2Result> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.identify.Resolve2', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function identifyResolveRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: identifyResolveResult) => void} & {param: identifyResolveRpcParam}>) {
  engineRpcOutgoing('keybase.1.identify.Resolve', request)
}

export function identifyResolveRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyResolveResult) => void} & {param: identifyResolveRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.identify.Resolve', request, callback, incomingCallMap) })
}

export function identifyResolveRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: identifyResolveResult) => void} & {param: identifyResolveRpcParam}>): Promise<identifyResolveResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.identify.Resolve', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function kbfsFSEditListRpc (request: Exact<requestCommon & requestErrorCallback & {param: kbfsFSEditListRpcParam}>) {
  engineRpcOutgoing('keybase.1.kbfs.FSEditList', request)
}

export function kbfsFSEditListRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSEditListRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.kbfs.FSEditList', request, callback, incomingCallMap) })
}

export function kbfsFSEditListRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSEditListRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.kbfs.FSEditList', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function kbfsFSEventRpc (request: Exact<requestCommon & requestErrorCallback & {param: kbfsFSEventRpcParam}>) {
  engineRpcOutgoing('keybase.1.kbfs.FSEvent', request)
}

export function kbfsFSEventRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSEventRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.kbfs.FSEvent', request, callback, incomingCallMap) })
}

export function kbfsFSEventRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSEventRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.kbfs.FSEvent', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function kbfsFSSyncEventRpc (request: Exact<requestCommon & requestErrorCallback & {param: kbfsFSSyncEventRpcParam}>) {
  engineRpcOutgoing('keybase.1.kbfs.FSSyncEvent', request)
}

export function kbfsFSSyncEventRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSSyncEventRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.kbfs.FSSyncEvent', request, callback, incomingCallMap) })
}

export function kbfsFSSyncEventRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSSyncEventRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.kbfs.FSSyncEvent', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function kbfsFSSyncStatusRpc (request: Exact<requestCommon & requestErrorCallback & {param: kbfsFSSyncStatusRpcParam}>) {
  engineRpcOutgoing('keybase.1.kbfs.FSSyncStatus', request)
}

export function kbfsFSSyncStatusRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSSyncStatusRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.kbfs.FSSyncStatus', request, callback, incomingCallMap) })
}

export function kbfsFSSyncStatusRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: kbfsFSSyncStatusRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.kbfs.FSSyncStatus', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function kbfsMountGetAllAvailableMountDirsRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: kbfsMountGetAllAvailableMountDirsResult) => void}>) {
  engineRpcOutgoing('keybase.1.kbfsMount.GetAllAvailableMountDirs', request)
}

export function kbfsMountGetAllAvailableMountDirsRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: kbfsMountGetAllAvailableMountDirsResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.kbfsMount.GetAllAvailableMountDirs', request, callback, incomingCallMap) })
}

export function kbfsMountGetAllAvailableMountDirsRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: kbfsMountGetAllAvailableMountDirsResult) => void}>): Promise<kbfsMountGetAllAvailableMountDirsResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.kbfsMount.GetAllAvailableMountDirs', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function kbfsMountGetCurrentMountDirRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: kbfsMountGetCurrentMountDirResult) => void}>) {
  engineRpcOutgoing('keybase.1.kbfsMount.GetCurrentMountDir', request)
}

export function kbfsMountGetCurrentMountDirRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: kbfsMountGetCurrentMountDirResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.kbfsMount.GetCurrentMountDir', request, callback, incomingCallMap) })
}

export function kbfsMountGetCurrentMountDirRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: kbfsMountGetCurrentMountDirResult) => void}>): Promise<kbfsMountGetCurrentMountDirResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.kbfsMount.GetCurrentMountDir', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function kbfsMountSetCurrentMountDirRpc (request: Exact<requestCommon & requestErrorCallback & {param: kbfsMountSetCurrentMountDirRpcParam}>) {
  engineRpcOutgoing('keybase.1.kbfsMount.SetCurrentMountDir', request)
}

export function kbfsMountSetCurrentMountDirRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: kbfsMountSetCurrentMountDirRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.kbfsMount.SetCurrentMountDir', request, callback, incomingCallMap) })
}

export function kbfsMountSetCurrentMountDirRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: kbfsMountSetCurrentMountDirRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.kbfsMount.SetCurrentMountDir', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function logRegisterLoggerRpc (request: Exact<requestCommon & requestErrorCallback & {param: logRegisterLoggerRpcParam}>) {
  engineRpcOutgoing('keybase.1.log.registerLogger', request)
}

export function logRegisterLoggerRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: logRegisterLoggerRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.log.registerLogger', request, callback, incomingCallMap) })
}

export function logRegisterLoggerRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: logRegisterLoggerRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.log.registerLogger', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginAccountDeleteRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.login.accountDelete', request)
}

export function loginAccountDeleteRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.accountDelete', request, callback, incomingCallMap) })
}

export function loginAccountDeleteRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.accountDelete', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginClearStoredSecretRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginClearStoredSecretRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.clearStoredSecret', request)
}

export function loginClearStoredSecretRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginClearStoredSecretRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.clearStoredSecret', request, callback, incomingCallMap) })
}

export function loginClearStoredSecretRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginClearStoredSecretRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.clearStoredSecret', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginDeprovisionRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginDeprovisionRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.deprovision', request)
}

export function loginDeprovisionRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginDeprovisionRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.deprovision', request, callback, incomingCallMap) })
}

export function loginDeprovisionRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginDeprovisionRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.deprovision', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginGetConfiguredAccountsRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: loginGetConfiguredAccountsResult) => void}>) {
  engineRpcOutgoing('keybase.1.login.getConfiguredAccounts', request)
}

export function loginGetConfiguredAccountsRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: loginGetConfiguredAccountsResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.getConfiguredAccounts', request, callback, incomingCallMap) })
}

export function loginGetConfiguredAccountsRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: loginGetConfiguredAccountsResult) => void}>): Promise<loginGetConfiguredAccountsResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.getConfiguredAccounts', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginLoginProvisionedDeviceRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginLoginProvisionedDeviceRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.loginProvisionedDevice', request)
}

export function loginLoginProvisionedDeviceRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginLoginProvisionedDeviceRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.loginProvisionedDevice', request, callback, incomingCallMap) })
}

export function loginLoginProvisionedDeviceRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginLoginProvisionedDeviceRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.loginProvisionedDevice', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginLoginRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginLoginRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.login', request)
}

export function loginLoginRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginLoginRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.login', request, callback, incomingCallMap) })
}

export function loginLoginRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginLoginRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.login', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginLoginWithPaperKeyRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.login.loginWithPaperKey', request)
}

export function loginLoginWithPaperKeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.loginWithPaperKey', request, callback, incomingCallMap) })
}

export function loginLoginWithPaperKeyRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.loginWithPaperKey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginLogoutRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.login.logout', request)
}

export function loginLogoutRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.logout', request, callback, incomingCallMap) })
}

export function loginLogoutRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.logout', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginPaperKeyRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.login.paperKey', request)
}

export function loginPaperKeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.paperKey', request, callback, incomingCallMap) })
}

export function loginPaperKeyRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.paperKey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginPaperKeySubmitRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginPaperKeySubmitRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.paperKeySubmit', request)
}

export function loginPaperKeySubmitRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginPaperKeySubmitRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.paperKeySubmit', request, callback, incomingCallMap) })
}

export function loginPaperKeySubmitRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginPaperKeySubmitRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.paperKeySubmit', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginPgpProvisionRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginPgpProvisionRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.pgpProvision', request)
}

export function loginPgpProvisionRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginPgpProvisionRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.pgpProvision', request, callback, incomingCallMap) })
}

export function loginPgpProvisionRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginPgpProvisionRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.pgpProvision', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginRecoverAccountFromEmailAddressRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginRecoverAccountFromEmailAddressRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.recoverAccountFromEmailAddress', request)
}

export function loginRecoverAccountFromEmailAddressRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginRecoverAccountFromEmailAddressRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.recoverAccountFromEmailAddress', request, callback, incomingCallMap) })
}

export function loginRecoverAccountFromEmailAddressRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginRecoverAccountFromEmailAddressRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.recoverAccountFromEmailAddress', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginUnlockRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.login.unlock', request)
}

export function loginUnlockRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.unlock', request, callback, incomingCallMap) })
}

export function loginUnlockRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.unlock', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function loginUnlockWithPassphraseRpc (request: Exact<requestCommon & requestErrorCallback & {param: loginUnlockWithPassphraseRpcParam}>) {
  engineRpcOutgoing('keybase.1.login.unlockWithPassphrase', request)
}

export function loginUnlockWithPassphraseRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: loginUnlockWithPassphraseRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.login.unlockWithPassphrase', request, callback, incomingCallMap) })
}

export function loginUnlockWithPassphraseRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: loginUnlockWithPassphraseRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.login.unlockWithPassphrase', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataAuthenticateRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataAuthenticateResult) => void} & {param: metadataAuthenticateRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.authenticate', request)
}

export function metadataAuthenticateRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataAuthenticateResult) => void} & {param: metadataAuthenticateRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.authenticate', request, callback, incomingCallMap) })
}

export function metadataAuthenticateRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataAuthenticateResult) => void} & {param: metadataAuthenticateRpcParam}>): Promise<metadataAuthenticateResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.authenticate', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataDeleteKeyRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataDeleteKeyRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.deleteKey', request)
}

export function metadataDeleteKeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataDeleteKeyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.deleteKey', request, callback, incomingCallMap) })
}

export function metadataDeleteKeyRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataDeleteKeyRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.deleteKey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetChallengeRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetChallengeResult) => void}>) {
  engineRpcOutgoing('keybase.1.metadata.getChallenge', request)
}

export function metadataGetChallengeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetChallengeResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getChallenge', request, callback, incomingCallMap) })
}

export function metadataGetChallengeRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetChallengeResult) => void}>): Promise<metadataGetChallengeResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getChallenge', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetFolderHandleRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetFolderHandleResult) => void} & {param: metadataGetFolderHandleRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getFolderHandle', request)
}

export function metadataGetFolderHandleRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetFolderHandleResult) => void} & {param: metadataGetFolderHandleRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getFolderHandle', request, callback, incomingCallMap) })
}

export function metadataGetFolderHandleRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetFolderHandleResult) => void} & {param: metadataGetFolderHandleRpcParam}>): Promise<metadataGetFolderHandleResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getFolderHandle', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetFoldersForRekeyRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataGetFoldersForRekeyRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getFoldersForRekey', request)
}

export function metadataGetFoldersForRekeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataGetFoldersForRekeyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getFoldersForRekey', request, callback, incomingCallMap) })
}

export function metadataGetFoldersForRekeyRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataGetFoldersForRekeyRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getFoldersForRekey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetKeyBundlesRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetKeyBundlesResult) => void} & {param: metadataGetKeyBundlesRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getKeyBundles', request)
}

export function metadataGetKeyBundlesRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetKeyBundlesResult) => void} & {param: metadataGetKeyBundlesRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getKeyBundles', request, callback, incomingCallMap) })
}

export function metadataGetKeyBundlesRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetKeyBundlesResult) => void} & {param: metadataGetKeyBundlesRpcParam}>): Promise<metadataGetKeyBundlesResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getKeyBundles', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetKeyRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetKeyResult) => void} & {param: metadataGetKeyRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getKey', request)
}

export function metadataGetKeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetKeyResult) => void} & {param: metadataGetKeyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getKey', request, callback, incomingCallMap) })
}

export function metadataGetKeyRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetKeyResult) => void} & {param: metadataGetKeyRpcParam}>): Promise<metadataGetKeyResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getKey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetLatestFolderHandleRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetLatestFolderHandleResult) => void} & {param: metadataGetLatestFolderHandleRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getLatestFolderHandle', request)
}

export function metadataGetLatestFolderHandleRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetLatestFolderHandleResult) => void} & {param: metadataGetLatestFolderHandleRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getLatestFolderHandle', request, callback, incomingCallMap) })
}

export function metadataGetLatestFolderHandleRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetLatestFolderHandleResult) => void} & {param: metadataGetLatestFolderHandleRpcParam}>): Promise<metadataGetLatestFolderHandleResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getLatestFolderHandle', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetMerkleNodeRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleNodeResult) => void} & {param: metadataGetMerkleNodeRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getMerkleNode', request)
}

export function metadataGetMerkleNodeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleNodeResult) => void} & {param: metadataGetMerkleNodeRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getMerkleNode', request, callback, incomingCallMap) })
}

export function metadataGetMerkleNodeRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleNodeResult) => void} & {param: metadataGetMerkleNodeRpcParam}>): Promise<metadataGetMerkleNodeResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getMerkleNode', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetMerkleRootLatestRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootLatestResult) => void} & {param: metadataGetMerkleRootLatestRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getMerkleRootLatest', request)
}

export function metadataGetMerkleRootLatestRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootLatestResult) => void} & {param: metadataGetMerkleRootLatestRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getMerkleRootLatest', request, callback, incomingCallMap) })
}

export function metadataGetMerkleRootLatestRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootLatestResult) => void} & {param: metadataGetMerkleRootLatestRpcParam}>): Promise<metadataGetMerkleRootLatestResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getMerkleRootLatest', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetMerkleRootRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootResult) => void} & {param: metadataGetMerkleRootRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getMerkleRoot', request)
}

export function metadataGetMerkleRootRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootResult) => void} & {param: metadataGetMerkleRootRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getMerkleRoot', request, callback, incomingCallMap) })
}

export function metadataGetMerkleRootRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootResult) => void} & {param: metadataGetMerkleRootRpcParam}>): Promise<metadataGetMerkleRootResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getMerkleRoot', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetMerkleRootSinceRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootSinceResult) => void} & {param: metadataGetMerkleRootSinceRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getMerkleRootSince', request)
}

export function metadataGetMerkleRootSinceRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootSinceResult) => void} & {param: metadataGetMerkleRootSinceRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getMerkleRootSince', request, callback, incomingCallMap) })
}

export function metadataGetMerkleRootSinceRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMerkleRootSinceResult) => void} & {param: metadataGetMerkleRootSinceRpcParam}>): Promise<metadataGetMerkleRootSinceResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getMerkleRootSince', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataGetMetadataRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMetadataResult) => void} & {param: metadataGetMetadataRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.getMetadata', request)
}

export function metadataGetMetadataRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMetadataResult) => void} & {param: metadataGetMetadataRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.getMetadata', request, callback, incomingCallMap) })
}

export function metadataGetMetadataRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataGetMetadataResult) => void} & {param: metadataGetMetadataRpcParam}>): Promise<metadataGetMetadataResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.getMetadata', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataPing2Rpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataPing2Result) => void}>) {
  engineRpcOutgoing('keybase.1.metadata.ping2', request)
}

export function metadataPing2RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataPing2Result) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.ping2', request, callback, incomingCallMap) })
}

export function metadataPing2RpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataPing2Result) => void}>): Promise<metadataPing2Result> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.ping2', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataPingRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.metadata.ping', request)
}

export function metadataPingRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.ping', request, callback, incomingCallMap) })
}

export function metadataPingRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.ping', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataPruneBranchRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataPruneBranchRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.pruneBranch', request)
}

export function metadataPruneBranchRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataPruneBranchRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.pruneBranch', request, callback, incomingCallMap) })
}

export function metadataPruneBranchRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataPruneBranchRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.pruneBranch', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataPutKeysRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataPutKeysRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.putKeys', request)
}

export function metadataPutKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataPutKeysRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.putKeys', request, callback, incomingCallMap) })
}

export function metadataPutKeysRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataPutKeysRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.putKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataPutMetadataRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataPutMetadataRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.putMetadata', request)
}

export function metadataPutMetadataRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataPutMetadataRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.putMetadata', request, callback, incomingCallMap) })
}

export function metadataPutMetadataRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataPutMetadataRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.putMetadata', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataRegisterForUpdatesRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataRegisterForUpdatesRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.registerForUpdates', request)
}

export function metadataRegisterForUpdatesRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataRegisterForUpdatesRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.registerForUpdates', request, callback, incomingCallMap) })
}

export function metadataRegisterForUpdatesRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataRegisterForUpdatesRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.registerForUpdates', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataTruncateLockRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataTruncateLockResult) => void} & {param: metadataTruncateLockRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.truncateLock', request)
}

export function metadataTruncateLockRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataTruncateLockResult) => void} & {param: metadataTruncateLockRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.truncateLock', request, callback, incomingCallMap) })
}

export function metadataTruncateLockRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataTruncateLockResult) => void} & {param: metadataTruncateLockRpcParam}>): Promise<metadataTruncateLockResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.truncateLock', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataTruncateUnlockRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: metadataTruncateUnlockResult) => void} & {param: metadataTruncateUnlockRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadata.truncateUnlock', request)
}

export function metadataTruncateUnlockRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataTruncateUnlockResult) => void} & {param: metadataTruncateUnlockRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadata.truncateUnlock', request, callback, incomingCallMap) })
}

export function metadataTruncateUnlockRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: metadataTruncateUnlockResult) => void} & {param: metadataTruncateUnlockRpcParam}>): Promise<metadataTruncateUnlockResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadata.truncateUnlock', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataUpdateFolderNeedsRekeyRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataUpdateFolderNeedsRekeyRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadataUpdate.folderNeedsRekey', request)
}

export function metadataUpdateFolderNeedsRekeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataUpdateFolderNeedsRekeyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadataUpdate.folderNeedsRekey', request, callback, incomingCallMap) })
}

export function metadataUpdateFolderNeedsRekeyRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataUpdateFolderNeedsRekeyRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadataUpdate.folderNeedsRekey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataUpdateFoldersNeedRekeyRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataUpdateFoldersNeedRekeyRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadataUpdate.foldersNeedRekey', request)
}

export function metadataUpdateFoldersNeedRekeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataUpdateFoldersNeedRekeyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadataUpdate.foldersNeedRekey', request, callback, incomingCallMap) })
}

export function metadataUpdateFoldersNeedRekeyRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataUpdateFoldersNeedRekeyRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadataUpdate.foldersNeedRekey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function metadataUpdateMetadataUpdateRpc (request: Exact<requestCommon & requestErrorCallback & {param: metadataUpdateMetadataUpdateRpcParam}>) {
  engineRpcOutgoing('keybase.1.metadataUpdate.metadataUpdate', request)
}

export function metadataUpdateMetadataUpdateRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: metadataUpdateMetadataUpdateRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.metadataUpdate.metadataUpdate', request, callback, incomingCallMap) })
}

export function metadataUpdateMetadataUpdateRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: metadataUpdateMetadataUpdateRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.metadataUpdate.metadataUpdate', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function notifyCtlSetNotificationsRpc (request: Exact<requestCommon & requestErrorCallback & {param: notifyCtlSetNotificationsRpcParam}>) {
  engineRpcOutgoing('keybase.1.notifyCtl.setNotifications', request)
}

export function notifyCtlSetNotificationsRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: notifyCtlSetNotificationsRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.notifyCtl.setNotifications', request, callback, incomingCallMap) })
}

export function notifyCtlSetNotificationsRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: notifyCtlSetNotificationsRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.notifyCtl.setNotifications', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function paperprovisionPaperProvisionRpc (request: Exact<requestCommon & requestErrorCallback & {param: paperprovisionPaperProvisionRpcParam}>) {
  engineRpcOutgoing('keybase.1.paperprovision.paperProvision', request)
}

export function paperprovisionPaperProvisionRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: paperprovisionPaperProvisionRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.paperprovision.paperProvision', request, callback, incomingCallMap) })
}

export function paperprovisionPaperProvisionRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: paperprovisionPaperProvisionRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.paperprovision.paperProvision', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpDecryptRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpDecryptResult) => void} & {param: pgpPgpDecryptRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpDecrypt', request)
}

export function pgpPgpDecryptRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpDecryptResult) => void} & {param: pgpPgpDecryptRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpDecrypt', request, callback, incomingCallMap) })
}

export function pgpPgpDecryptRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpDecryptResult) => void} & {param: pgpPgpDecryptRpcParam}>): Promise<pgpPgpDecryptResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpDecrypt', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpDeletePrimaryRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.pgp.pgpDeletePrimary', request)
}

export function pgpPgpDeletePrimaryRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpDeletePrimary', request, callback, incomingCallMap) })
}

export function pgpPgpDeletePrimaryRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpDeletePrimary', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpEncryptRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpEncryptRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpEncrypt', request)
}

export function pgpPgpEncryptRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpEncryptRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpEncrypt', request, callback, incomingCallMap) })
}

export function pgpPgpEncryptRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpEncryptRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpEncrypt', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpExportByFingerprintRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportByFingerprintResult) => void} & {param: pgpPgpExportByFingerprintRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpExportByFingerprint', request)
}

export function pgpPgpExportByFingerprintRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportByFingerprintResult) => void} & {param: pgpPgpExportByFingerprintRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpExportByFingerprint', request, callback, incomingCallMap) })
}

export function pgpPgpExportByFingerprintRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportByFingerprintResult) => void} & {param: pgpPgpExportByFingerprintRpcParam}>): Promise<pgpPgpExportByFingerprintResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpExportByFingerprint', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpExportByKIDRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportByKIDResult) => void} & {param: pgpPgpExportByKIDRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpExportByKID', request)
}

export function pgpPgpExportByKIDRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportByKIDResult) => void} & {param: pgpPgpExportByKIDRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpExportByKID', request, callback, incomingCallMap) })
}

export function pgpPgpExportByKIDRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportByKIDResult) => void} & {param: pgpPgpExportByKIDRpcParam}>): Promise<pgpPgpExportByKIDResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpExportByKID', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpExportRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportResult) => void} & {param: pgpPgpExportRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpExport', request)
}

export function pgpPgpExportRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportResult) => void} & {param: pgpPgpExportRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpExport', request, callback, incomingCallMap) })
}

export function pgpPgpExportRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpExportResult) => void} & {param: pgpPgpExportRpcParam}>): Promise<pgpPgpExportResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpExport', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpImportRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpImportRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpImport', request)
}

export function pgpPgpImportRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpImportRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpImport', request, callback, incomingCallMap) })
}

export function pgpPgpImportRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpImportRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpImport', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpKeyGenDefaultRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpKeyGenDefaultRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpKeyGenDefault', request)
}

export function pgpPgpKeyGenDefaultRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpKeyGenDefaultRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpKeyGenDefault', request, callback, incomingCallMap) })
}

export function pgpPgpKeyGenDefaultRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpKeyGenDefaultRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpKeyGenDefault', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpKeyGenRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpKeyGenRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpKeyGen', request)
}

export function pgpPgpKeyGenRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpKeyGenRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpKeyGen', request, callback, incomingCallMap) })
}

export function pgpPgpKeyGenRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpKeyGenRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpKeyGen', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpPullRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpPullRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpPull', request)
}

export function pgpPgpPullRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpPullRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpPull', request, callback, incomingCallMap) })
}

export function pgpPgpPullRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpPullRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpPull', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpPurgeRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpPurgeResult) => void} & {param: pgpPgpPurgeRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpPurge', request)
}

export function pgpPgpPurgeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpPurgeResult) => void} & {param: pgpPgpPurgeRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpPurge', request, callback, incomingCallMap) })
}

export function pgpPgpPurgeRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpPurgeResult) => void} & {param: pgpPgpPurgeRpcParam}>): Promise<pgpPgpPurgeResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpPurge', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpSelectRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpSelectRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpSelect', request)
}

export function pgpPgpSelectRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpSelectRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpSelect', request, callback, incomingCallMap) })
}

export function pgpPgpSelectRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpSelectRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpSelect', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpSignRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpSignRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpSign', request)
}

export function pgpPgpSignRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpSignRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpSign', request, callback, incomingCallMap) })
}

export function pgpPgpSignRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpSignRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpSign', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpStorageDismissRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.pgp.pgpStorageDismiss', request)
}

export function pgpPgpStorageDismissRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpStorageDismiss', request, callback, incomingCallMap) })
}

export function pgpPgpStorageDismissRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpStorageDismiss', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpUpdateRpc (request: Exact<requestCommon & requestErrorCallback & {param: pgpPgpUpdateRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpUpdate', request)
}

export function pgpPgpUpdateRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpUpdateRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpUpdate', request, callback, incomingCallMap) })
}

export function pgpPgpUpdateRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: pgpPgpUpdateRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpUpdate', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function pgpPgpVerifyRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpVerifyResult) => void} & {param: pgpPgpVerifyRpcParam}>) {
  engineRpcOutgoing('keybase.1.pgp.pgpVerify', request)
}

export function pgpPgpVerifyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpVerifyResult) => void} & {param: pgpPgpVerifyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.pgp.pgpVerify', request, callback, incomingCallMap) })
}

export function pgpPgpVerifyRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: pgpPgpVerifyResult) => void} & {param: pgpPgpVerifyRpcParam}>): Promise<pgpPgpVerifyResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.pgp.pgpVerify', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function proveCheckProofRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: proveCheckProofResult) => void} & {param: proveCheckProofRpcParam}>) {
  engineRpcOutgoing('keybase.1.prove.checkProof', request)
}

export function proveCheckProofRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: proveCheckProofResult) => void} & {param: proveCheckProofRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.prove.checkProof', request, callback, incomingCallMap) })
}

export function proveCheckProofRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: proveCheckProofResult) => void} & {param: proveCheckProofRpcParam}>): Promise<proveCheckProofResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.prove.checkProof', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function proveStartProofRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: proveStartProofResult) => void} & {param: proveStartProofRpcParam}>) {
  engineRpcOutgoing('keybase.1.prove.startProof', request)
}

export function proveStartProofRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: proveStartProofResult) => void} & {param: proveStartProofRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.prove.startProof', request, callback, incomingCallMap) })
}

export function proveStartProofRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: proveStartProofResult) => void} & {param: proveStartProofRpcParam}>): Promise<proveStartProofResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.prove.startProof', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function quotaVerifySessionRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: quotaVerifySessionResult) => void} & {param: quotaVerifySessionRpcParam}>) {
  engineRpcOutgoing('keybase.1.quota.verifySession', request)
}

export function quotaVerifySessionRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: quotaVerifySessionResult) => void} & {param: quotaVerifySessionRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.quota.verifySession', request, callback, incomingCallMap) })
}

export function quotaVerifySessionRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: quotaVerifySessionResult) => void} & {param: quotaVerifySessionRpcParam}>): Promise<quotaVerifySessionResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.quota.verifySession', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function reachabilityCheckReachabilityRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: reachabilityCheckReachabilityResult) => void}>) {
  engineRpcOutgoing('keybase.1.reachability.checkReachability', request)
}

export function reachabilityCheckReachabilityRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: reachabilityCheckReachabilityResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.reachability.checkReachability', request, callback, incomingCallMap) })
}

export function reachabilityCheckReachabilityRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: reachabilityCheckReachabilityResult) => void}>): Promise<reachabilityCheckReachabilityResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.reachability.checkReachability', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function reachabilityReachabilityChangedRpc (request: Exact<requestCommon & requestErrorCallback & {param: reachabilityReachabilityChangedRpcParam}>) {
  engineRpcOutgoing('keybase.1.reachability.reachabilityChanged', request)
}

export function reachabilityReachabilityChangedRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: reachabilityReachabilityChangedRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.reachability.reachabilityChanged', request, callback, incomingCallMap) })
}

export function reachabilityReachabilityChangedRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: reachabilityReachabilityChangedRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.reachability.reachabilityChanged', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function reachabilityStartReachabilityRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: reachabilityStartReachabilityResult) => void}>) {
  engineRpcOutgoing('keybase.1.reachability.startReachability', request)
}

export function reachabilityStartReachabilityRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: reachabilityStartReachabilityResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.reachability.startReachability', request, callback, incomingCallMap) })
}

export function reachabilityStartReachabilityRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: reachabilityStartReachabilityResult) => void}>): Promise<reachabilityStartReachabilityResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.reachability.startReachability', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function rekeyDebugShowRekeyStatusRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.rekey.debugShowRekeyStatus', request)
}

export function rekeyDebugShowRekeyStatusRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.rekey.debugShowRekeyStatus', request, callback, incomingCallMap) })
}

export function rekeyDebugShowRekeyStatusRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.rekey.debugShowRekeyStatus', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function rekeyGetPendingRekeyStatusRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyGetPendingRekeyStatusResult) => void}>) {
  engineRpcOutgoing('keybase.1.rekey.getPendingRekeyStatus', request)
}

export function rekeyGetPendingRekeyStatusRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyGetPendingRekeyStatusResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.rekey.getPendingRekeyStatus', request, callback, incomingCallMap) })
}

export function rekeyGetPendingRekeyStatusRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyGetPendingRekeyStatusResult) => void}>): Promise<rekeyGetPendingRekeyStatusResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.rekey.getPendingRekeyStatus', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function rekeyGetRevokeWarningRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyGetRevokeWarningResult) => void} & {param: rekeyGetRevokeWarningRpcParam}>) {
  engineRpcOutgoing('keybase.1.rekey.getRevokeWarning', request)
}

export function rekeyGetRevokeWarningRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyGetRevokeWarningResult) => void} & {param: rekeyGetRevokeWarningRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.rekey.getRevokeWarning', request, callback, incomingCallMap) })
}

export function rekeyGetRevokeWarningRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyGetRevokeWarningResult) => void} & {param: rekeyGetRevokeWarningRpcParam}>): Promise<rekeyGetRevokeWarningResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.rekey.getRevokeWarning', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function rekeyRekeyStatusFinishRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyRekeyStatusFinishResult) => void}>) {
  engineRpcOutgoing('keybase.1.rekey.rekeyStatusFinish', request)
}

export function rekeyRekeyStatusFinishRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyRekeyStatusFinishResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.rekey.rekeyStatusFinish', request, callback, incomingCallMap) })
}

export function rekeyRekeyStatusFinishRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: rekeyRekeyStatusFinishResult) => void}>): Promise<rekeyRekeyStatusFinishResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.rekey.rekeyStatusFinish', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function rekeyRekeySyncRpc (request: Exact<requestCommon & requestErrorCallback & {param: rekeyRekeySyncRpcParam}>) {
  engineRpcOutgoing('keybase.1.rekey.rekeySync', request)
}

export function rekeyRekeySyncRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: rekeyRekeySyncRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.rekey.rekeySync', request, callback, incomingCallMap) })
}

export function rekeyRekeySyncRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: rekeyRekeySyncRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.rekey.rekeySync', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function rekeyShowPendingRekeyStatusRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.rekey.showPendingRekeyStatus', request)
}

export function rekeyShowPendingRekeyStatusRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.rekey.showPendingRekeyStatus', request, callback, incomingCallMap) })
}

export function rekeyShowPendingRekeyStatusRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.rekey.showPendingRekeyStatus', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function revokeRevokeDeviceRpc (request: Exact<requestCommon & requestErrorCallback & {param: revokeRevokeDeviceRpcParam}>) {
  engineRpcOutgoing('keybase.1.revoke.revokeDevice', request)
}

export function revokeRevokeDeviceRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: revokeRevokeDeviceRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.revoke.revokeDevice', request, callback, incomingCallMap) })
}

export function revokeRevokeDeviceRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: revokeRevokeDeviceRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.revoke.revokeDevice', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function revokeRevokeKeyRpc (request: Exact<requestCommon & requestErrorCallback & {param: revokeRevokeKeyRpcParam}>) {
  engineRpcOutgoing('keybase.1.revoke.revokeKey', request)
}

export function revokeRevokeKeyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: revokeRevokeKeyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.revoke.revokeKey', request, callback, incomingCallMap) })
}

export function revokeRevokeKeyRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: revokeRevokeKeyRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.revoke.revokeKey', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function revokeRevokeSigsRpc (request: Exact<requestCommon & requestErrorCallback & {param: revokeRevokeSigsRpcParam}>) {
  engineRpcOutgoing('keybase.1.revoke.revokeSigs', request)
}

export function revokeRevokeSigsRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: revokeRevokeSigsRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.revoke.revokeSigs', request, callback, incomingCallMap) })
}

export function revokeRevokeSigsRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: revokeRevokeSigsRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.revoke.revokeSigs', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function saltpackSaltpackDecryptRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: saltpackSaltpackDecryptResult) => void} & {param: saltpackSaltpackDecryptRpcParam}>) {
  engineRpcOutgoing('keybase.1.saltpack.saltpackDecrypt', request)
}

export function saltpackSaltpackDecryptRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: saltpackSaltpackDecryptResult) => void} & {param: saltpackSaltpackDecryptRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.saltpack.saltpackDecrypt', request, callback, incomingCallMap) })
}

export function saltpackSaltpackDecryptRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: saltpackSaltpackDecryptResult) => void} & {param: saltpackSaltpackDecryptRpcParam}>): Promise<saltpackSaltpackDecryptResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.saltpack.saltpackDecrypt', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function saltpackSaltpackEncryptRpc (request: Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackEncryptRpcParam}>) {
  engineRpcOutgoing('keybase.1.saltpack.saltpackEncrypt', request)
}

export function saltpackSaltpackEncryptRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackEncryptRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.saltpack.saltpackEncrypt', request, callback, incomingCallMap) })
}

export function saltpackSaltpackEncryptRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackEncryptRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.saltpack.saltpackEncrypt', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function saltpackSaltpackSignRpc (request: Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackSignRpcParam}>) {
  engineRpcOutgoing('keybase.1.saltpack.saltpackSign', request)
}

export function saltpackSaltpackSignRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackSignRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.saltpack.saltpackSign', request, callback, incomingCallMap) })
}

export function saltpackSaltpackSignRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackSignRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.saltpack.saltpackSign', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function saltpackSaltpackVerifyRpc (request: Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackVerifyRpcParam}>) {
  engineRpcOutgoing('keybase.1.saltpack.saltpackVerify', request)
}

export function saltpackSaltpackVerifyRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackVerifyRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.saltpack.saltpackVerify', request, callback, incomingCallMap) })
}

export function saltpackSaltpackVerifyRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: saltpackSaltpackVerifyRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.saltpack.saltpackVerify', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function sessionCurrentSessionRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: sessionCurrentSessionResult) => void}>) {
  engineRpcOutgoing('keybase.1.session.currentSession', request)
}

export function sessionCurrentSessionRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: sessionCurrentSessionResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.session.currentSession', request, callback, incomingCallMap) })
}

export function sessionCurrentSessionRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: sessionCurrentSessionResult) => void}>): Promise<sessionCurrentSessionResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.session.currentSession', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function sessionSessionPingRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.session.sessionPing', request)
}

export function sessionSessionPingRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.session.sessionPing', request, callback, incomingCallMap) })
}

export function sessionSessionPingRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.session.sessionPing', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function signupCheckInvitationCodeRpc (request: Exact<requestCommon & requestErrorCallback & {param: signupCheckInvitationCodeRpcParam}>) {
  engineRpcOutgoing('keybase.1.signup.checkInvitationCode', request)
}

export function signupCheckInvitationCodeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: signupCheckInvitationCodeRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.signup.checkInvitationCode', request, callback, incomingCallMap) })
}

export function signupCheckInvitationCodeRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: signupCheckInvitationCodeRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.signup.checkInvitationCode', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function signupCheckUsernameAvailableRpc (request: Exact<requestCommon & requestErrorCallback & {param: signupCheckUsernameAvailableRpcParam}>) {
  engineRpcOutgoing('keybase.1.signup.checkUsernameAvailable', request)
}

export function signupCheckUsernameAvailableRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: signupCheckUsernameAvailableRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.signup.checkUsernameAvailable', request, callback, incomingCallMap) })
}

export function signupCheckUsernameAvailableRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: signupCheckUsernameAvailableRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.signup.checkUsernameAvailable', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function signupGetInvitationCodeRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: signupGetInvitationCodeResult) => void}>) {
  engineRpcOutgoing('keybase.1.signup.getInvitationCode', request)
}

export function signupGetInvitationCodeRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: signupGetInvitationCodeResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.signup.getInvitationCode', request, callback, incomingCallMap) })
}

export function signupGetInvitationCodeRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: signupGetInvitationCodeResult) => void}>): Promise<signupGetInvitationCodeResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.signup.getInvitationCode', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function signupInviteRequestRpc (request: Exact<requestCommon & requestErrorCallback & {param: signupInviteRequestRpcParam}>) {
  engineRpcOutgoing('keybase.1.signup.inviteRequest', request)
}

export function signupInviteRequestRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: signupInviteRequestRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.signup.inviteRequest', request, callback, incomingCallMap) })
}

export function signupInviteRequestRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: signupInviteRequestRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.signup.inviteRequest', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function signupSignupRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: signupSignupResult) => void} & {param: signupSignupRpcParam}>) {
  engineRpcOutgoing('keybase.1.signup.signup', request)
}

export function signupSignupRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: signupSignupResult) => void} & {param: signupSignupRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.signup.signup', request, callback, incomingCallMap) })
}

export function signupSignupRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: signupSignupResult) => void} & {param: signupSignupRpcParam}>): Promise<signupSignupResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.signup.signup', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function sigsSigListJSONRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: sigsSigListJSONResult) => void} & {param: sigsSigListJSONRpcParam}>) {
  engineRpcOutgoing('keybase.1.sigs.sigListJSON', request)
}

export function sigsSigListJSONRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: sigsSigListJSONResult) => void} & {param: sigsSigListJSONRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.sigs.sigListJSON', request, callback, incomingCallMap) })
}

export function sigsSigListJSONRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: sigsSigListJSONResult) => void} & {param: sigsSigListJSONRpcParam}>): Promise<sigsSigListJSONResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.sigs.sigListJSON', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function sigsSigListRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: sigsSigListResult) => void} & {param: sigsSigListRpcParam}>) {
  engineRpcOutgoing('keybase.1.sigs.sigList', request)
}

export function sigsSigListRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: sigsSigListResult) => void} & {param: sigsSigListRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.sigs.sigList', request, callback, incomingCallMap) })
}

export function sigsSigListRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: sigsSigListResult) => void} & {param: sigsSigListRpcParam}>): Promise<sigsSigListResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.sigs.sigList', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function testPanicRpc (request: Exact<requestCommon & requestErrorCallback & {param: testPanicRpcParam}>) {
  engineRpcOutgoing('keybase.1.test.panic', request)
}

export function testPanicRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: testPanicRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.test.panic', request, callback, incomingCallMap) })
}

export function testPanicRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: testPanicRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.test.panic', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function testTestCallbackRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: testTestCallbackResult) => void} & {param: testTestCallbackRpcParam}>) {
  engineRpcOutgoing('keybase.1.test.testCallback', request)
}

export function testTestCallbackRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: testTestCallbackResult) => void} & {param: testTestCallbackRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.test.testCallback', request, callback, incomingCallMap) })
}

export function testTestCallbackRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: testTestCallbackResult) => void} & {param: testTestCallbackRpcParam}>): Promise<testTestCallbackResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.test.testCallback', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function testTestRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: testTestResult) => void} & {param: testTestRpcParam}>) {
  engineRpcOutgoing('keybase.1.test.test', request)
}

export function testTestRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: testTestResult) => void} & {param: testTestRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.test.test', request, callback, incomingCallMap) })
}

export function testTestRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: testTestResult) => void} & {param: testTestRpcParam}>): Promise<testTestResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.test.test', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function tlfCompleteAndCanonicalizePrivateTlfNameRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: tlfCompleteAndCanonicalizePrivateTlfNameResult) => void} & {param: tlfCompleteAndCanonicalizePrivateTlfNameRpcParam}>) {
  engineRpcOutgoing('keybase.1.tlf.completeAndCanonicalizePrivateTlfName', request)
}

export function tlfCompleteAndCanonicalizePrivateTlfNameRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfCompleteAndCanonicalizePrivateTlfNameResult) => void} & {param: tlfCompleteAndCanonicalizePrivateTlfNameRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.tlf.completeAndCanonicalizePrivateTlfName', request, callback, incomingCallMap) })
}

export function tlfCompleteAndCanonicalizePrivateTlfNameRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfCompleteAndCanonicalizePrivateTlfNameResult) => void} & {param: tlfCompleteAndCanonicalizePrivateTlfNameRpcParam}>): Promise<tlfCompleteAndCanonicalizePrivateTlfNameResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.tlf.completeAndCanonicalizePrivateTlfName', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function tlfCryptKeysRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: tlfCryptKeysResult) => void} & {param: tlfCryptKeysRpcParam}>) {
  engineRpcOutgoing('keybase.1.tlf.CryptKeys', request)
}

export function tlfCryptKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfCryptKeysResult) => void} & {param: tlfCryptKeysRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.tlf.CryptKeys', request, callback, incomingCallMap) })
}

export function tlfCryptKeysRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfCryptKeysResult) => void} & {param: tlfCryptKeysRpcParam}>): Promise<tlfCryptKeysResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.tlf.CryptKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function tlfKeysGetPublicCanonicalTLFNameAndIDRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: tlfKeysGetPublicCanonicalTLFNameAndIDResult) => void} & {param: tlfKeysGetPublicCanonicalTLFNameAndIDRpcParam}>) {
  engineRpcOutgoing('keybase.1.tlfKeys.getPublicCanonicalTLFNameAndID', request)
}

export function tlfKeysGetPublicCanonicalTLFNameAndIDRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfKeysGetPublicCanonicalTLFNameAndIDResult) => void} & {param: tlfKeysGetPublicCanonicalTLFNameAndIDRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.tlfKeys.getPublicCanonicalTLFNameAndID', request, callback, incomingCallMap) })
}

export function tlfKeysGetPublicCanonicalTLFNameAndIDRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfKeysGetPublicCanonicalTLFNameAndIDResult) => void} & {param: tlfKeysGetPublicCanonicalTLFNameAndIDRpcParam}>): Promise<tlfKeysGetPublicCanonicalTLFNameAndIDResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.tlfKeys.getPublicCanonicalTLFNameAndID', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function tlfKeysGetTLFCryptKeysRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: tlfKeysGetTLFCryptKeysResult) => void} & {param: tlfKeysGetTLFCryptKeysRpcParam}>) {
  engineRpcOutgoing('keybase.1.tlfKeys.getTLFCryptKeys', request)
}

export function tlfKeysGetTLFCryptKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfKeysGetTLFCryptKeysResult) => void} & {param: tlfKeysGetTLFCryptKeysRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.tlfKeys.getTLFCryptKeys', request, callback, incomingCallMap) })
}

export function tlfKeysGetTLFCryptKeysRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfKeysGetTLFCryptKeysResult) => void} & {param: tlfKeysGetTLFCryptKeysRpcParam}>): Promise<tlfKeysGetTLFCryptKeysResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.tlfKeys.getTLFCryptKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function tlfPublicCanonicalTLFNameAndIDRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: tlfPublicCanonicalTLFNameAndIDResult) => void} & {param: tlfPublicCanonicalTLFNameAndIDRpcParam}>) {
  engineRpcOutgoing('keybase.1.tlf.publicCanonicalTLFNameAndID', request)
}

export function tlfPublicCanonicalTLFNameAndIDRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfPublicCanonicalTLFNameAndIDResult) => void} & {param: tlfPublicCanonicalTLFNameAndIDRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.tlf.publicCanonicalTLFNameAndID', request, callback, incomingCallMap) })
}

export function tlfPublicCanonicalTLFNameAndIDRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: tlfPublicCanonicalTLFNameAndIDResult) => void} & {param: tlfPublicCanonicalTLFNameAndIDRpcParam}>): Promise<tlfPublicCanonicalTLFNameAndIDResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.tlf.publicCanonicalTLFNameAndID', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function trackCheckTrackingRpc (request: Exact<requestCommon & requestErrorCallback>) {
  engineRpcOutgoing('keybase.1.track.checkTracking', request)
}

export function trackCheckTrackingRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.track.checkTracking', request, callback, incomingCallMap) })
}

export function trackCheckTrackingRpcPromise (request: $Exact<requestCommon & requestErrorCallback>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.track.checkTracking', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function trackDismissWithTokenRpc (request: Exact<requestCommon & requestErrorCallback & {param: trackDismissWithTokenRpcParam}>) {
  engineRpcOutgoing('keybase.1.track.dismissWithToken', request)
}

export function trackDismissWithTokenRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: trackDismissWithTokenRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.track.dismissWithToken', request, callback, incomingCallMap) })
}

export function trackDismissWithTokenRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: trackDismissWithTokenRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.track.dismissWithToken', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function trackFakeTrackingChangedRpc (request: Exact<requestCommon & requestErrorCallback & {param: trackFakeTrackingChangedRpcParam}>) {
  engineRpcOutgoing('keybase.1.track.fakeTrackingChanged', request)
}

export function trackFakeTrackingChangedRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: trackFakeTrackingChangedRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.track.fakeTrackingChanged', request, callback, incomingCallMap) })
}

export function trackFakeTrackingChangedRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: trackFakeTrackingChangedRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.track.fakeTrackingChanged', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function trackTrackRpc (request: Exact<requestCommon & requestErrorCallback & {param: trackTrackRpcParam}>) {
  engineRpcOutgoing('keybase.1.track.track', request)
}

export function trackTrackRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: trackTrackRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.track.track', request, callback, incomingCallMap) })
}

export function trackTrackRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: trackTrackRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.track.track', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function trackTrackWithTokenRpc (request: Exact<requestCommon & requestErrorCallback & {param: trackTrackWithTokenRpcParam}>) {
  engineRpcOutgoing('keybase.1.track.trackWithToken', request)
}

export function trackTrackWithTokenRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: trackTrackWithTokenRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.track.trackWithToken', request, callback, incomingCallMap) })
}

export function trackTrackWithTokenRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: trackTrackWithTokenRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.track.trackWithToken', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function trackUntrackRpc (request: Exact<requestCommon & requestErrorCallback & {param: trackUntrackRpcParam}>) {
  engineRpcOutgoing('keybase.1.track.untrack', request)
}

export function trackUntrackRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: trackUntrackRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.track.untrack', request, callback, incomingCallMap) })
}

export function trackUntrackRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: trackUntrackRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.track.untrack', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userListTrackers2Rpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackers2Result) => void} & {param: userListTrackers2RpcParam}>) {
  engineRpcOutgoing('keybase.1.user.listTrackers2', request)
}

export function userListTrackers2RpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackers2Result) => void} & {param: userListTrackers2RpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.listTrackers2', request, callback, incomingCallMap) })
}

export function userListTrackers2RpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackers2Result) => void} & {param: userListTrackers2RpcParam}>): Promise<userListTrackers2Result> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.listTrackers2', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userListTrackersByNameRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersByNameResult) => void} & {param: userListTrackersByNameRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.listTrackersByName', request)
}

export function userListTrackersByNameRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersByNameResult) => void} & {param: userListTrackersByNameRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.listTrackersByName', request, callback, incomingCallMap) })
}

export function userListTrackersByNameRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersByNameResult) => void} & {param: userListTrackersByNameRpcParam}>): Promise<userListTrackersByNameResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.listTrackersByName', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userListTrackersRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersResult) => void} & {param: userListTrackersRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.listTrackers', request)
}

export function userListTrackersRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersResult) => void} & {param: userListTrackersRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.listTrackers', request, callback, incomingCallMap) })
}

export function userListTrackersRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersResult) => void} & {param: userListTrackersRpcParam}>): Promise<userListTrackersResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.listTrackers', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userListTrackersSelfRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersSelfResult) => void}>) {
  engineRpcOutgoing('keybase.1.user.listTrackersSelf', request)
}

export function userListTrackersSelfRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersSelfResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.listTrackersSelf', request, callback, incomingCallMap) })
}

export function userListTrackersSelfRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackersSelfResult) => void}>): Promise<userListTrackersSelfResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.listTrackersSelf', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userListTrackingJSONRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackingJSONResult) => void} & {param: userListTrackingJSONRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.listTrackingJSON', request)
}

export function userListTrackingJSONRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackingJSONResult) => void} & {param: userListTrackingJSONRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.listTrackingJSON', request, callback, incomingCallMap) })
}

export function userListTrackingJSONRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackingJSONResult) => void} & {param: userListTrackingJSONRpcParam}>): Promise<userListTrackingJSONResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.listTrackingJSON', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userListTrackingRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackingResult) => void} & {param: userListTrackingRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.listTracking', request)
}

export function userListTrackingRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackingResult) => void} & {param: userListTrackingRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.listTracking', request, callback, incomingCallMap) })
}

export function userListTrackingRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userListTrackingResult) => void} & {param: userListTrackingRpcParam}>): Promise<userListTrackingResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.listTracking', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadAllPublicKeysUnverifiedRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadAllPublicKeysUnverifiedResult) => void} & {param: userLoadAllPublicKeysUnverifiedRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.loadAllPublicKeysUnverified', request)
}

export function userLoadAllPublicKeysUnverifiedRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadAllPublicKeysUnverifiedResult) => void} & {param: userLoadAllPublicKeysUnverifiedRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadAllPublicKeysUnverified', request, callback, incomingCallMap) })
}

export function userLoadAllPublicKeysUnverifiedRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadAllPublicKeysUnverifiedResult) => void} & {param: userLoadAllPublicKeysUnverifiedRpcParam}>): Promise<userLoadAllPublicKeysUnverifiedResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadAllPublicKeysUnverified', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadMyPublicKeysRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadMyPublicKeysResult) => void}>) {
  engineRpcOutgoing('keybase.1.user.loadMyPublicKeys', request)
}

export function userLoadMyPublicKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadMyPublicKeysResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadMyPublicKeys', request, callback, incomingCallMap) })
}

export function userLoadMyPublicKeysRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadMyPublicKeysResult) => void}>): Promise<userLoadMyPublicKeysResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadMyPublicKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadMySettingsRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadMySettingsResult) => void}>) {
  engineRpcOutgoing('keybase.1.user.loadMySettings', request)
}

export function userLoadMySettingsRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadMySettingsResult) => void}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadMySettings', request, callback, incomingCallMap) })
}

export function userLoadMySettingsRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadMySettingsResult) => void}>): Promise<userLoadMySettingsResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadMySettings', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadPublicKeysRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadPublicKeysResult) => void} & {param: userLoadPublicKeysRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.loadPublicKeys', request)
}

export function userLoadPublicKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadPublicKeysResult) => void} & {param: userLoadPublicKeysRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadPublicKeys', request, callback, incomingCallMap) })
}

export function userLoadPublicKeysRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadPublicKeysResult) => void} & {param: userLoadPublicKeysRpcParam}>): Promise<userLoadPublicKeysResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadPublicKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadUncheckedUserSummariesRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUncheckedUserSummariesResult) => void} & {param: userLoadUncheckedUserSummariesRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.loadUncheckedUserSummaries', request)
}

export function userLoadUncheckedUserSummariesRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUncheckedUserSummariesResult) => void} & {param: userLoadUncheckedUserSummariesRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadUncheckedUserSummaries', request, callback, incomingCallMap) })
}

export function userLoadUncheckedUserSummariesRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUncheckedUserSummariesResult) => void} & {param: userLoadUncheckedUserSummariesRpcParam}>): Promise<userLoadUncheckedUserSummariesResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadUncheckedUserSummaries', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadUserByNameRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserByNameResult) => void} & {param: userLoadUserByNameRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.loadUserByName', request)
}

export function userLoadUserByNameRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserByNameResult) => void} & {param: userLoadUserByNameRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadUserByName', request, callback, incomingCallMap) })
}

export function userLoadUserByNameRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserByNameResult) => void} & {param: userLoadUserByNameRpcParam}>): Promise<userLoadUserByNameResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadUserByName', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadUserPlusKeysRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserPlusKeysResult) => void} & {param: userLoadUserPlusKeysRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.loadUserPlusKeys', request)
}

export function userLoadUserPlusKeysRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserPlusKeysResult) => void} & {param: userLoadUserPlusKeysRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadUserPlusKeys', request, callback, incomingCallMap) })
}

export function userLoadUserPlusKeysRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserPlusKeysResult) => void} & {param: userLoadUserPlusKeysRpcParam}>): Promise<userLoadUserPlusKeysResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadUserPlusKeys', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userLoadUserRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserResult) => void} & {param: userLoadUserRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.loadUser', request)
}

export function userLoadUserRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserResult) => void} & {param: userLoadUserRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.loadUser', request, callback, incomingCallMap) })
}

export function userLoadUserRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userLoadUserResult) => void} & {param: userLoadUserRpcParam}>): Promise<userLoadUserResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.loadUser', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userProfileEditRpc (request: Exact<requestCommon & requestErrorCallback & {param: userProfileEditRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.profileEdit', request)
}

export function userProfileEditRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & requestErrorCallback & {param: userProfileEditRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.profileEdit', request, callback, incomingCallMap) })
}

export function userProfileEditRpcPromise (request: $Exact<requestCommon & requestErrorCallback & {param: userProfileEditRpcParam}>): Promise<void> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.profileEdit', request, (error, result) => error ? reject(error) : resolve(result)))
}

export function userSearchRpc (request: Exact<requestCommon & {callback?: ?(err: ?any, response: userSearchResult) => void} & {param: userSearchRpcParam}>) {
  engineRpcOutgoing('keybase.1.user.search', request)
}

export function userSearchRpcChannelMap (channelConfig: ChannelConfig<*>, request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userSearchResult) => void} & {param: userSearchRpcParam}>): ChannelMap<*> {
  return _channelMapRpcHelper(channelConfig, (incomingCallMap, callback) => { engineRpcOutgoing('keybase.1.user.search', request, callback, incomingCallMap) })
}

export function userSearchRpcPromise (request: $Exact<requestCommon & {callback?: ?(err: ?any, response: userSearchResult) => void} & {param: userSearchRpcParam}>): Promise<userSearchResult> {
  return new Promise((resolve, reject) => engineRpcOutgoing('keybase.1.user.search', request, (error, result) => error ? reject(error) : resolve(result)))
}

export type APIRes = {
  status: string,
  body: string,
  httpStatus: int,
  appStatus: string,
}

export type AsyncOps =
    0 // LIST_0
  | 1 // LIST_RECURSIVE_1
  | 2 // READ_2
  | 3 // WRITE_3
  | 4 // COPY_4
  | 5 // MOVE_5
  | 6 // REMOVE_6

export type BTCRegisterBTCRpcParam = Exact<{
  address: string,
  force: boolean
}>

export type BadgeConversationInfo = {
  convID: ChatConversationID,
  UnreadMessages: int,
}

export type BadgeState = {
  newTlfs: int,
  rekeysNeeded: int,
  newFollowers: int,
  conversations?: ?Array<BadgeConversationInfo>,
}

export type BinaryKID = bytes

export type BlockIdCombo = {
  blockHash: string,
  chargedTo: UID,
  blockType: BlockType,
}

export type BlockPingResponse = {}

export type BlockRefNonce = any

export type BlockReference = {
  bid: BlockIdCombo,
  nonce: BlockRefNonce,
  chargedTo: UID,
}

export type BlockReferenceCount = {
  ref: BlockReference,
  liveCount: int,
}

export type BlockType =
    0 // DATA_0
  | 1 // MD_1

export type BoxNonce = any

export type BoxPublicKey = any

export type Bytes32 = any

export type CanonicalTLFNameAndIDWithBreaks = {
  tlfID: TLFID,
  CanonicalName: CanonicalTlfName,
  breaks: TLFBreak,
}

export type CanonicalTlfName = string

export type ChallengeInfo = {
  now: long,
  challenge: string,
}

export type ChatConversationID = bytes

export type CheckProofStatus = {
  found: boolean,
  status: ProofStatus,
  proofText: string,
  state: ProofState,
}

export type CheckResult = {
  proofResult: ProofResult,
  time: Time,
  freshness: CheckResultFreshness,
}

export type CheckResultFreshness =
    0 // FRESH_0
  | 1 // AGED_1
  | 2 // RANCID_2

export type ChooseType =
    0 // EXISTING_DEVICE_0
  | 1 // NEW_DEVICE_1

export type CiphertextBundle = {
  kid: KID,
  ciphertext: EncryptedBytes32,
  nonce: BoxNonce,
  publicKey: BoxPublicKey,
}

export type ClientDetails = {
  pid: int,
  clientType: ClientType,
  argv?: ?Array<string>,
  desc: string,
  version: string,
}

export type ClientType =
    0 // NONE_0
  | 1 // CLI_1
  | 2 // GUI_MAIN_2
  | 3 // KBFS_3
  | 4 // GUI_HELPER_4

export type ComponentResult = {
  name: string,
  status: Status,
}

export type Config = {
  serverURI: string,
  socketFile: string,
  label: string,
  runMode: string,
  gpgExists: boolean,
  gpgPath: string,
  version: string,
  path: string,
  configPath: string,
  versionShort: string,
  versionFull: string,
  isAutoForked: boolean,
  forkType: ForkType,
}

export type ConfigValue = {
  isNull: boolean,
  b?: ?boolean,
  i?: ?int,
  s?: ?string,
  o?: ?string,
}

export type ConfiguredAccount = {
  username: string,
  hasStoredSecret: boolean,
}

export type ConfirmResult = {
  identityConfirmed: boolean,
  remoteConfirmed: boolean,
  expiringLocal: boolean,
}

export type CopyArgs = {
  opID: OpID,
  src: Path,
  dest: Path,
}

export type CryptKey = {
  KeyGeneration: int,
  Key: Bytes32,
}

export type Cryptocurrency = {
  rowId: int,
  pkhash: bytes,
  address: string,
  sigID: SigID,
  type: string,
  family: string,
}

export type CsrfToken = string

export type DbKey = {
  dbType: DbType,
  objType: int,
  key: string,
}

export type DbType =
    0 // MAIN_0
  | 1 // CHAT_1

export type DbValue = bytes

export type Device = {
  type: string,
  name: string,
  deviceID: DeviceID,
  cTime: Time,
  mTime: Time,
  lastUsedTime: Time,
  encryptKey: KID,
  verifyKey: KID,
  status: int,
}

export type DeviceDetail = {
  device: Device,
  eldest: boolean,
  provisioner?: ?Device,
  provisionedAt?: ?Time,
  revokedAt?: ?Time,
  revokedBy: KID,
  revokedByDevice?: ?Device,
  currentDevice: boolean,
}

export type DeviceID = string

export type DeviceType =
    0 // DESKTOP_0
  | 1 // MOBILE_1

export type Dirent = {
  time: Time,
  size: int,
  name: string,
  direntType: DirentType,
}

export type DirentType =
    0 // FILE_0
  | 1 // DIR_1
  | 2 // SYM_2
  | 3 // EXEC_3

export type DismissReason = {
  type: DismissReasonType,
  reason: string,
  resource: string,
}

export type DismissReasonType =
    0 // NONE_0
  | 1 // HANDLED_ELSEWHERE_1

export type DowngradeReferenceRes = {
  completed?: ?Array<BlockReferenceCount>,
  failed: BlockReference,
}

export type DurationSec = double

export type ED25519PublicKey = any

export type ED25519Signature = any

export type ED25519SignatureInfo = {
  sig: ED25519Signature,
  publicKey: ED25519PublicKey,
}

export type Email = {
  email: string,
  isVerified: boolean,
}

export type EncryptedBytes32 = any

export type ErrorNum = int

export type ExitCode =
    0 // OK_0
  | 2 // NOTOK_2
  | 4 // RESTART_4

export type ExtendedStatus = {
  standalone: boolean,
  passphraseStreamCached: boolean,
  tsecCached: boolean,
  deviceSigKeyCached: boolean,
  deviceEncKeyCached: boolean,
  paperSigKeyCached: boolean,
  paperEncKeyCached: boolean,
  storedSecret: boolean,
  secretPromptSkip: boolean,
  device?: ?Device,
  deviceErr?: ?LoadDeviceErr,
  logDir: string,
  session?: ?SessionStatus,
  defaultUsername: string,
  provisionedUsernames?: ?Array<string>,
  Clients?: ?Array<ClientDetails>,
  platformInfo: PlatformInfo,
  defaultDeviceID: DeviceID,
}

export type FSEditListRequest = {
  folder: Folder,
  requestID: int,
}

export type FSErrorType =
    0 // ACCESS_DENIED_0
  | 1 // USER_NOT_FOUND_1
  | 2 // REVOKED_DATA_DETECTED_2
  | 3 // NOT_LOGGED_IN_3
  | 4 // TIMEOUT_4
  | 5 // REKEY_NEEDED_5
  | 6 // BAD_FOLDER_6
  | 7 // NOT_IMPLEMENTED_7
  | 8 // OLD_VERSION_8
  | 9 // OVER_QUOTA_9
  | 10 // NO_SIG_CHAIN_10
  | 11 // TOO_MANY_FOLDERS_11
  | 12 // EXDEV_NOT_SUPPORTED_12

export type FSNotification = {
  publicTopLevelFolder: boolean,
  filename: string,
  status: string,
  statusCode: FSStatusCode,
  notificationType: FSNotificationType,
  errorType: FSErrorType,
  params: {[key: string]: string},
  writerUid: UID,
  localTime: Time,
}

export type FSNotificationType =
    0 // ENCRYPTING_0
  | 1 // DECRYPTING_1
  | 2 // SIGNING_2
  | 3 // VERIFYING_3
  | 4 // REKEYING_4
  | 5 // CONNECTION_5
  | 6 // MD_READ_SUCCESS_6
  | 7 // FILE_CREATED_7
  | 8 // FILE_MODIFIED_8
  | 9 // FILE_DELETED_9
  | 10 // FILE_RENAMED_10

export type FSPathSyncStatus = {
  publicTopLevelFolder: boolean,
  path: string,
  syncingBytes: int64,
  syncingOps: int64,
  syncedBytes: int64,
}

export type FSStatusCode =
    0 // START_0
  | 1 // FINISH_1
  | 2 // ERROR_2

export type FSSyncStatus = {
  totalSyncingBytes: int64,
  totalSyncingOps: int64,
  pathStatuses?: ?Array<FSPathSyncStatus>,
}

export type FSSyncStatusRequest = {
  requestID: int,
}

export type FavoritesResult = {
  favoriteFolders?: ?Array<Folder>,
  ignoredFolders?: ?Array<Folder>,
  newFolders?: ?Array<Folder>,
}

export type Feature = {
  allow: boolean,
  defaultValue: boolean,
  readonly: boolean,
  label: string,
}

export type File = {
  path: string,
}

export type FileContent = {
  data: bytes,
  progress: Progress,
}

export type FileDescriptor = {
  name: string,
  type: FileType,
}

export type FileType =
    0 // UNKNOWN_0
  | 1 // DIRECTORY_1
  | 2 // FILE_2

export type FirstStepResult = {
  valPlusTwo: int,
}

export type Folder = {
  name: string,
  private: boolean,
  notificationsOn: boolean,
  created: boolean,
}

export type ForkType =
    0 // NONE_0
  | 1 // AUTO_1
  | 2 // WATCHDOG_2
  | 3 // LAUNCHD_3

export type FuseMountInfo = {
  path: string,
  fstype: string,
  output: string,
}

export type FuseStatus = {
  version: string,
  bundleVersion: string,
  kextID: string,
  path: string,
  kextStarted: boolean,
  installStatus: InstallStatus,
  installAction: InstallAction,
  mountInfos?: ?Array<FuseMountInfo>,
  status: Status,
}

export type GPGKey = {
  algorithm: string,
  keyID: string,
  creation: string,
  expiration: string,
  identities?: ?Array<PGPIdentity>,
}

export type GPGMethod =
    0 // GPG_NONE_0
  | 1 // GPG_IMPORT_1
  | 2 // GPG_SIGN_2

export type GUIEntryArg = {
  windowTitle: string,
  prompt: string,
  username: string,
  submitLabel: string,
  cancelLabel: string,
  retryLabel: string,
  type: PassphraseType,
  features: GUIEntryFeatures,
}

export type GUIEntryFeatures = {
  showTyping: Feature,
}

export type GetBlockRes = {
  blockKey: string,
  buf: bytes,
}

export type GetCurrentStatusRes = {
  configured: boolean,
  registered: boolean,
  loggedIn: boolean,
  sessionIsValid: boolean,
  user?: ?User,
}

export type GetPassphraseRes = {
  passphrase: string,
  storeSecret: boolean,
}

export type GetTLFCryptKeysRes = {
  nameIDBreaks: CanonicalTLFNameAndIDWithBreaks,
  CryptKeys?: ?Array<CryptKey>,
}

export type HasServerKeysRes = {
  hasServerKeys: boolean,
}

export type Hello2Res = {
  encryptionKey: KID,
  sigPayload: HelloRes,
}

export type HelloRes = string

export type Identify2Res = {
  upk: UserPlusKeys,
  trackBreaks?: ?IdentifyTrackBreaks,
}

export type IdentifyKey = {
  pgpFingerprint: bytes,
  KID: KID,
  trackDiff?: ?TrackDiff,
  breaksTracking: boolean,
}

export type IdentifyOutcome = {
  username: string,
  status?: ?Status,
  warnings?: ?Array<string>,
  trackUsed?: ?TrackSummary,
  trackStatus: TrackStatus,
  numTrackFailures: int,
  numTrackChanges: int,
  numProofFailures: int,
  numRevoked: int,
  numProofSuccesses: int,
  revoked?: ?Array<TrackDiff>,
  trackOptions: TrackOptions,
  forPGPPull: boolean,
  reason: IdentifyReason,
}

export type IdentifyProofBreak = {
  remoteProof: RemoteProof,
  lcr: LinkCheckResult,
}

export type IdentifyReason = {
  type: IdentifyReasonType,
  reason: string,
  resource: string,
}

export type IdentifyReasonType =
    0 // NONE_0
  | 1 // ID_1
  | 2 // TRACK_2
  | 3 // ENCRYPT_3
  | 4 // DECRYPT_4
  | 5 // VERIFY_5
  | 6 // RESOURCE_6
  | 7 // BACKGROUND_7

export type IdentifyRes = {
  user?: ?User,
  publicKeys?: ?Array<PublicKey>,
  outcome: IdentifyOutcome,
  trackToken: TrackToken,
}

export type IdentifyRow = {
  rowId: int,
  proof: RemoteProof,
  trackDiff?: ?TrackDiff,
}

export type IdentifyTrackBreaks = {
  keys?: ?Array<IdentifyKey>,
  proofs?: ?Array<IdentifyProofBreak>,
}

export type Identity = {
  status?: ?Status,
  whenLastTracked: Time,
  proofs?: ?Array<IdentifyRow>,
  cryptocurrency?: ?Array<Cryptocurrency>,
  revoked?: ?Array<TrackDiff>,
  revokedDetails?: ?Array<RevokedProof>,
  breaksTracking: boolean,
}

export type InstallAction =
    0 // UNKNOWN_0
  | 1 // NONE_1
  | 2 // UPGRADE_2
  | 3 // REINSTALL_3
  | 4 // INSTALL_4

export type InstallResult = {
  componentResults?: ?Array<ComponentResult>,
  status: Status,
  fatal: boolean,
}

export type InstallStatus =
    0 // UNKNOWN_0
  | 1 // ERROR_1
  | 2 // NOT_INSTALLED_2
  | 4 // INSTALLED_4

export type KID = string

export type Kex2Provisionee2DidCounterSign2RpcParam = Exact<{
  sig: bytes,
  ppsEncrypted: string
}>

export type Kex2Provisionee2Hello2RpcParam = Exact<{
  uid: UID,
  token: SessionToken,
  csrf: CsrfToken,
  sigBody: string
}>

export type Kex2ProvisioneeDidCounterSignRpcParam = Exact<{
  sig: bytes
}>

export type Kex2ProvisioneeHelloRpcParam = Exact<{
  uid: UID,
  token: SessionToken,
  csrf: CsrfToken,
  pps: PassphraseStream,
  sigBody: string
}>

export type KeyBundle = {
  version: int,
  bundle: bytes,
}

export type KeyBundleResponse = {
  WriterBundle: KeyBundle,
  ReaderBundle: KeyBundle,
}

export type KeyHalf = {
  user: UID,
  deviceKID: KID,
  key: bytes,
}

export type KeyInfo = {
  fingerprint: string,
  key: string,
  desc: string,
}

export type KeybaseTime = {
  unix: Time,
  chain: int,
}

export type LinkCheckResult = {
  proofId: int,
  proofResult: ProofResult,
  snoozedResult: ProofResult,
  torWarning: boolean,
  tmpTrackExpireTime: Time,
  cached?: ?CheckResult,
  diff?: ?TrackDiff,
  remoteDiff?: ?TrackDiff,
  hint?: ?SigHint,
  breaksTracking: boolean,
}

export type LinkID = string

export type ListArgs = {
  opID: OpID,
  path: Path,
}

export type ListResult = {
  files?: ?Array<File>,
}

export type LoadDeviceErr = {
  where: string,
  desc: string,
}

export type LogLevel =
    0 // NONE_0
  | 1 // DEBUG_1
  | 2 // INFO_2
  | 3 // NOTICE_3
  | 4 // WARN_4
  | 5 // ERROR_5
  | 6 // CRITICAL_6
  | 7 // FATAL_7

export type MDBlock = {
  version: int,
  timestamp: Time,
  block: bytes,
}

export type MerkleRoot = {
  version: int,
  root: bytes,
}

export type MerkleTreeID =
    0 // MASTER_0
  | 1 // KBFS_PUBLIC_1
  | 2 // KBFS_PRIVATE_2

export type MetadataResponse = {
  folderID: string,
  mdBlocks?: ?Array<MDBlock>,
}

export type MoveArgs = {
  opID: OpID,
  src: Path,
  dest: Path,
}

export type NaclDHKeyPrivate = any

export type NaclDHKeyPublic = any

export type NaclSigningKeyPrivate = any

export type NaclSigningKeyPublic = any

export type NotificationChannels = {
  session: boolean,
  users: boolean,
  kbfs: boolean,
  tracking: boolean,
  favorites: boolean,
  paperkeys: boolean,
  keyfamily: boolean,
  service: boolean,
  app: boolean,
  chat: boolean,
  pgp: boolean,
  kbfsrequest: boolean,
  badges: boolean,
  reachability: boolean,
}

export type NotifyBadgesBadgeStateRpcParam = Exact<{
  badgeState: BadgeState
}>

export type NotifyFSFSActivityRpcParam = Exact<{
  notification: FSNotification
}>

export type NotifyFSFSEditListResponseRpcParam = Exact<{
  edits?: ?Array<FSNotification>,
  requestID: int
}>

export type NotifyFSFSSyncActivityRpcParam = Exact<{
  status: FSPathSyncStatus
}>

export type NotifyFSFSSyncStatusResponseRpcParam = Exact<{
  status: FSSyncStatus,
  requestID: int
}>

export type NotifyFSRequestFSEditListRequestRpcParam = Exact<{
  req: FSEditListRequest
}>

export type NotifyFSRequestFSSyncStatusRequestRpcParam = Exact<{
  req: FSSyncStatusRequest
}>

export type NotifyFavoritesFavoritesChangedRpcParam = Exact<{
  uid: UID
}>

export type NotifyKeyfamilyKeyfamilyChangedRpcParam = Exact<{
  uid: UID
}>

export type NotifyPaperKeyPaperKeyCachedRpcParam = Exact<{
  uid: UID,
  encKID: KID,
  sigKID: KID
}>

export type NotifySessionClientOutOfDateRpcParam = Exact<{
  upgradeTo: string,
  upgradeURI: string,
  upgradeMsg: string
}>

export type NotifySessionLoggedInRpcParam = Exact<{
  username: string
}>

export type NotifyTrackingTrackingChangedRpcParam = Exact<{
  uid: UID,
  username: string,
  isTracking: boolean
}>

export type NotifyUsersUserChangedRpcParam = Exact<{
  uid: UID
}>

export type OpDescription =
    { asyncOp: 0, list: ?ListArgs }
  | { asyncOp: 1, listRecursive: ?ListArgs }
  | { asyncOp: 2, read: ?ReadArgs }
  | { asyncOp: 3, write: ?WriteArgs }
  | { asyncOp: 4, copy: ?CopyArgs }
  | { asyncOp: 5, move: ?MoveArgs }
  | { asyncOp: 6, remove: ?RemoveArgs }

export type OpID = any

export type OpenFlags =
    0 // READ_0
  | 1 // REPLACE_1
  | 2 // EXISTING_2
  | 4 // WRITE_4
  | 8 // APPEND_8
  | 16 // DIRECTORY_16

export type OutOfDateInfo = {
  upgradeTo: string,
  upgradeURI: string,
  customMessage: string,
  criticalClockSkew: long,
}

export type Outcome =
    0 // NONE_0
  | 1 // FIXED_1
  | 2 // IGNORED_2

export type PGPCreateUids = {
  useDefault: boolean,
  ids?: ?Array<PGPIdentity>,
}

export type PGPDecryptOptions = {
  assertSigned: boolean,
  signedBy: string,
}

export type PGPEncryptOptions = {
  recipients?: ?Array<string>,
  noSign: boolean,
  noSelf: boolean,
  binaryOut: boolean,
  keyQuery: string,
}

export type PGPIdentity = {
  username: string,
  comment: string,
  email: string,
}

export type PGPPurgeRes = {
  filenames?: ?Array<string>,
}

export type PGPQuery = {
  secret: boolean,
  query: string,
  exactMatch: boolean,
}

export type PGPSigVerification = {
  isSigned: boolean,
  verified: boolean,
  signer: User,
  signKey: PublicKey,
}

export type PGPSignOptions = {
  keyQuery: string,
  mode: SignMode,
  binaryIn: boolean,
  binaryOut: boolean,
}

export type PGPVerifyOptions = {
  signedBy: string,
  signature: bytes,
}

export type PassphraseStream = {
  passphraseStream: bytes,
  generation: int,
}

export type PassphraseType =
    0 // NONE_0
  | 1 // PAPER_KEY_1
  | 2 // PASS_PHRASE_2
  | 3 // VERIFY_PASS_PHRASE_3

export type Path =
    { PathType: 0, local: ?string }
  | { PathType: 1, kbfs: ?string }

export type PathType =
    0 // LOCAL_0
  | 1 // KBFS_1

export type PingResponse = {
  timestamp: Time,
}

export type PlatformInfo = {
  os: string,
  osVersion: string,
  arch: string,
  goVersion: string,
}

export type ProblemSet = {
  user: User,
  kid: KID,
  tlfs?: ?Array<ProblemTLF>,
}

export type ProblemSetDevices = {
  problemSet: ProblemSet,
  devices?: ?Array<Device>,
}

export type ProblemTLF = {
  tlf: TLF,
  score: int,
  solution_kids?: ?Array<KID>,
}

export type Process = {
  pid: string,
  command: string,
  fileDescriptors?: ?Array<FileDescriptor>,
}

export type Progress = int

export type PromptDefault =
    0 // NONE_0
  | 1 // YES_1
  | 2 // NO_2

export type PromptOverwriteType =
    0 // SOCIAL_0
  | 1 // SITE_1

export type ProofResult = {
  state: ProofState,
  status: ProofStatus,
  desc: string,
}

export type ProofState =
    0 // NONE_0
  | 1 // OK_1
  | 2 // TEMP_FAILURE_2
  | 3 // PERM_FAILURE_3
  | 4 // LOOKING_4
  | 5 // SUPERSEDED_5
  | 6 // POSTED_6
  | 7 // REVOKED_7
  | 8 // DELETED_8
  | 9 // UNKNOWN_TYPE_9
  | 10 // SIG_HINT_MISSING_10
  | 11 // UNCHECKED_11

export type ProofStatus =
    0 // NONE_0
  | 1 // OK_1
  | 2 // LOCAL_2
  | 3 // FOUND_3
  | 100 // BASE_ERROR_100
  | 101 // HOST_UNREACHABLE_101
  | 103 // PERMISSION_DENIED_103
  | 106 // FAILED_PARSE_106
  | 107 // DNS_ERROR_107
  | 108 // AUTH_FAILED_108
  | 129 // HTTP_429_129
  | 150 // HTTP_500_150
  | 160 // TIMEOUT_160
  | 170 // INTERNAL_ERROR_170
  | 171 // UNCHECKED_171
  | 172 // MISSING_PVL_172
  | 200 // BASE_HARD_ERROR_200
  | 201 // NOT_FOUND_201
  | 202 // CONTENT_FAILURE_202
  | 203 // BAD_USERNAME_203
  | 204 // BAD_REMOTE_ID_204
  | 205 // TEXT_NOT_FOUND_205
  | 206 // BAD_ARGS_206
  | 207 // CONTENT_MISSING_207
  | 208 // TITLE_NOT_FOUND_208
  | 209 // SERVICE_ERROR_209
  | 210 // TOR_SKIPPED_210
  | 211 // TOR_INCOMPATIBLE_211
  | 230 // HTTP_300_230
  | 240 // HTTP_400_240
  | 260 // HTTP_OTHER_260
  | 270 // EMPTY_JSON_270
  | 301 // DELETED_301
  | 302 // SERVICE_DEAD_302
  | 303 // BAD_SIGNATURE_303
  | 304 // BAD_API_URL_304
  | 305 // UNKNOWN_TYPE_305
  | 306 // NO_HINT_306
  | 307 // BAD_HINT_TEXT_307
  | 308 // INVALID_PVL_308

export type ProofType =
    0 // NONE_0
  | 1 // KEYBASE_1
  | 2 // TWITTER_2
  | 3 // GITHUB_3
  | 4 // REDDIT_4
  | 5 // COINBASE_5
  | 6 // HACKERNEWS_6
  | 8 // FACEBOOK_8
  | 1000 // GENERIC_WEB_SITE_1000
  | 1001 // DNS_1001
  | 1002 // PGP_1002
  | 100001 // ROOTER_100001

export type Proofs = {
  social?: ?Array<TrackProof>,
  web?: ?Array<WebProof>,
  publicKeys?: ?Array<PublicKey>,
}

export type ProvisionMethod =
    0 // DEVICE_0
  | 1 // PAPER_KEY_1
  | 2 // PASSPHRASE_2
  | 3 // GPG_IMPORT_3
  | 4 // GPG_SIGN_4

export type PublicKey = {
  KID: KID,
  PGPFingerprint: string,
  PGPIdentities?: ?Array<PGPIdentity>,
  isSibkey: boolean,
  isEldest: boolean,
  parentID: string,
  deviceID: DeviceID,
  deviceDescription: string,
  deviceType: string,
  cTime: Time,
  eTime: Time,
  isRevoked: boolean,
}

export type PushReason =
    0 // NONE_0
  | 1 // RECONNECTED_1
  | 2 // NEW_DATA_2

export type Reachability = {
  reachable: Reachable,
}

export type Reachable =
    0 // UNKNOWN_0
  | 1 // YES_1
  | 2 // NO_2

export type ReadArgs = {
  opID: OpID,
  path: Path,
  offset: long,
  size: int,
}

export type RegisterAddressRes = {
  type: string,
  family: string,
}

export type RekeyEvent = {
  eventType: RekeyEventType,
  interruptType: int,
}

export type RekeyEventType =
    0 // NONE_0
  | 1 // NOT_LOGGED_IN_1
  | 2 // API_ERROR_2
  | 3 // NO_PROBLEMS_3
  | 4 // LOAD_ME_ERROR_4
  | 5 // CURRENT_DEVICE_CAN_REKEY_5
  | 6 // DEVICE_LOAD_ERROR_6
  | 7 // HARASS_7
  | 8 // NO_GREGOR_MESSAGES_8

export type RekeyRequest = {
  folderID: string,
  revision: long,
}

export type RemoteProof = {
  proofType: ProofType,
  key: string,
  value: string,
  displayMarkup: string,
  sigID: SigID,
  mTime: Time,
}

export type RemoteTrack = {
  username: string,
  uid: UID,
  linkID: LinkID,
}

export type RemoveArgs = {
  opID: OpID,
  path: Path,
}

export type RevokeWarning = {
  endangeredTLFs?: ?Array<TLF>,
}

export type RevokedKey = {
  key: PublicKey,
  time: KeybaseTime,
  by: KID,
}

export type RevokedProof = {
  proof: RemoteProof,
  diff: TrackDiff,
}

export type SaltpackDecryptOptions = {
  interactive: boolean,
  forceRemoteCheck: boolean,
  usePaperKey: boolean,
}

export type SaltpackEncryptOptions = {
  recipients?: ?Array<string>,
  hideSelf: boolean,
  noSelfEncrypt: boolean,
  binary: boolean,
  hideRecipients: boolean,
}

export type SaltpackEncryptedMessageInfo = {
  devices?: ?Array<Device>,
  numAnonReceivers: int,
  receiverIsAnon: boolean,
  sender: SaltpackSender,
}

export type SaltpackSender = {
  uid: UID,
  username: string,
  senderType: SaltpackSenderType,
}

export type SaltpackSenderType =
    0 // NOT_TRACKED_0
  | 1 // UNKNOWN_1
  | 2 // ANONYMOUS_2
  | 3 // TRACKING_BROKE_3
  | 4 // TRACKING_OK_4
  | 5 // SELF_5
  | 6 // REVOKED_6
  | 7 // EXPIRED_7

export type SaltpackSignOptions = {
  detached: boolean,
  binary: boolean,
}

export type SaltpackVerifyOptions = {
  signedBy: string,
  signature: bytes,
}

export type ScanProofsScanProofsRpcParam = Exact<{
  infile: string,
  indices: string,
  sigid: string,
  ratelimit: int,
  cachefile: string,
  ignorefile: string
}>

export type SearchComponent = {
  key: string,
  value: string,
  score: double,
}

export type SearchResult = {
  uid: UID,
  username: string,
  components?: ?Array<SearchComponent>,
  score: double,
}

export type SecretEntryArg = {
  desc: string,
  prompt: string,
  err: string,
  cancel: string,
  ok: string,
  reason: string,
  showTyping: boolean,
}

export type SecretEntryRes = {
  text: string,
  canceled: boolean,
  storeSecret: boolean,
}

export type SecretKeys = {
  signing: NaclSigningKeyPrivate,
  encryption: NaclDHKeyPrivate,
}

export type SecretResponse = {
  secret: bytes,
  phrase: string,
}

export type SelectKeyRes = {
  keyID: string,
  doSecretPush: boolean,
}

export type ServiceStatus = {
  version: string,
  label: string,
  pid: string,
  lastExitStatus: string,
  bundleVersion: string,
  installStatus: InstallStatus,
  installAction: InstallAction,
  status: Status,
}

export type ServicesStatus = {
  service?: ?Array<ServiceStatus>,
  kbfs?: ?Array<ServiceStatus>,
  updater?: ?Array<ServiceStatus>,
}

export type Session = {
  uid: UID,
  username: string,
  token: string,
  deviceSubkeyKid: KID,
  deviceSibkeyKid: KID,
}

export type SessionStatus = {
  SessionFor: string,
  Loaded: boolean,
  Cleared: boolean,
  SaltOnly: boolean,
  Expired: boolean,
}

export type SessionToken = string

export type Sig = {
  seqno: int,
  sigID: SigID,
  sigIDDisplay: string,
  type: string,
  cTime: Time,
  revoked: boolean,
  active: boolean,
  key: string,
  body: string,
}

export type SigHint = {
  remoteId: string,
  humanUrl: string,
  apiUrl: string,
  checkText: string,
}

export type SigID = string

export type SigListArgs = {
  sessionID: int,
  username: string,
  allKeys: boolean,
  types?: ?SigTypes,
  filterx: string,
  verbose: boolean,
  revoked: boolean,
}

export type SigTypes = {
  track: boolean,
  proof: boolean,
  cryptocurrency: boolean,
  isSelf: boolean,
}

export type SignMode =
    0 // ATTACHED_0
  | 1 // DETACHED_1
  | 2 // CLEAR_2

export type SignupRes = {
  passphraseOk: boolean,
  postOk: boolean,
  writeOk: boolean,
}

export type SimpleFSListResult = {
  entries?: ?Array<Dirent>,
  progress: Progress,
}

export type SimpleFSSimpleFSCancelRpcParam = Exact<{
  opID: OpID
}>

export type SimpleFSSimpleFSCheckRpcParam = Exact<{
  opID: OpID
}>

export type SimpleFSSimpleFSCloseRpcParam = Exact<{
  opID: OpID
}>

export type SimpleFSSimpleFSCopyRecursiveRpcParam = Exact<{
  opID: OpID,
  src: Path,
  dest: Path
}>

export type SimpleFSSimpleFSCopyRpcParam = Exact<{
  opID: OpID,
  src: Path,
  dest: Path
}>

export type SimpleFSSimpleFSListRecursiveRpcParam = Exact<{
  opID: OpID,
  path: Path
}>

export type SimpleFSSimpleFSListRpcParam = Exact<{
  opID: OpID,
  path: Path
}>

export type SimpleFSSimpleFSMoveRpcParam = Exact<{
  opID: OpID,
  src: Path,
  dest: Path
}>

export type SimpleFSSimpleFSOpenRpcParam = Exact<{
  opID: OpID,
  dest: Path,
  flags: OpenFlags
}>

export type SimpleFSSimpleFSReadListRpcParam = Exact<{
  opID: OpID
}>

export type SimpleFSSimpleFSReadRpcParam = Exact<{
  opID: OpID,
  offset: long,
  size: int
}>

export type SimpleFSSimpleFSRemoveRpcParam = Exact<{
  opID: OpID,
  path: Path
}>

export type SimpleFSSimpleFSRenameRpcParam = Exact<{
  src: Path,
  dest: Path
}>

export type SimpleFSSimpleFSSetStatRpcParam = Exact<{
  dest: Path,
  flag: DirentType
}>

export type SimpleFSSimpleFSStatRpcParam = Exact<{
  path: Path
}>

export type SimpleFSSimpleFSWaitRpcParam = Exact<{
  opID: OpID
}>

export type SimpleFSSimpleFSWriteRpcParam = Exact<{
  opID: OpID,
  offset: long,
  content: bytes
}>

export type SocialAssertion = {
  user: string,
  service: SocialAssertionService,
}

export type SocialAssertionService = string

export type StartProofResult = {
  sigID: SigID,
}

export type Status = {
  code: int,
  name: string,
  desc: string,
  fields?: ?Array<StringKVPair>,
}

export type StatusCode =
    0 // SCOk_0
  | 100 // SCInputError_100
  | 201 // SCLoginRequired_201
  | 202 // SCBadSession_202
  | 203 // SCBadLoginUserNotFound_203
  | 204 // SCBadLoginPassword_204
  | 205 // SCNotFound_205
  | 210 // SCThrottleControl_210
  | 216 // SCDeleted_216
  | 218 // SCGeneric_218
  | 235 // SCAlreadyLoggedIn_235
  | 230 // SCExists_230
  | 237 // SCCanceled_237
  | 239 // SCInputCanceled_239
  | 274 // SCReloginRequired_274
  | 275 // SCResolutionFailed_275
  | 276 // SCProfileNotPublic_276
  | 277 // SCIdentifyFailed_277
  | 278 // SCTrackingBroke_278
  | 279 // SCWrongCryptoFormat_279
  | 280 // SCDecryptionError_280
  | 281 // SCInvalidAddress_281
  | 283 // SCNoSession_283
  | 472 // SCBadEmail_472
  | 701 // SCBadSignupUsernameTaken_701
  | 707 // SCBadInvitationCode_707
  | 801 // SCMissingResult_801
  | 901 // SCKeyNotFound_901
  | 907 // SCKeyInUse_907
  | 913 // SCKeyBadGen_913
  | 914 // SCKeyNoSecret_914
  | 915 // SCKeyBadUIDs_915
  | 916 // SCKeyNoActive_916
  | 917 // SCKeyNoSig_917
  | 918 // SCKeyBadSig_918
  | 919 // SCKeyBadEldest_919
  | 920 // SCKeyNoEldest_920
  | 921 // SCKeyDuplicateUpdate_921
  | 922 // SCSibkeyAlreadyExists_922
  | 924 // SCDecryptionKeyNotFound_924
  | 927 // SCKeyNoPGPEncryption_927
  | 928 // SCKeyNoNaClEncryption_928
  | 929 // SCKeySyncedPGPNotFound_929
  | 930 // SCKeyNoMatchingGPG_930
  | 931 // SCKeyRevoked_931
  | 1301 // SCBadTrackSession_1301
  | 1404 // SCDeviceBadName_1404
  | 1408 // SCDeviceNameInUse_1408
  | 1409 // SCDeviceNotFound_1409
  | 1410 // SCDeviceMismatch_1410
  | 1411 // SCDeviceRequired_1411
  | 1413 // SCDevicePrevProvisioned_1413
  | 1414 // SCDeviceNoProvision_1414
  | 1501 // SCStreamExists_1501
  | 1502 // SCStreamNotFound_1502
  | 1503 // SCStreamWrongKind_1503
  | 1504 // SCStreamEOF_1504
  | 1600 // SCGenericAPIError_1600
  | 1601 // SCAPINetworkError_1601
  | 1602 // SCTimeout_1602
  | 1701 // SCProofError_1701
  | 1702 // SCIdentificationExpired_1702
  | 1703 // SCSelfNotFound_1703
  | 1704 // SCBadKexPhrase_1704
  | 1705 // SCNoUIDelegation_1705
  | 1706 // SCNoUI_1706
  | 1707 // SCGPGUnavailable_1707
  | 1800 // SCInvalidVersionError_1800
  | 1801 // SCOldVersionError_1801
  | 1802 // SCInvalidLocationError_1802
  | 1803 // SCServiceStatusError_1803
  | 1804 // SCInstallError_1804
  | 2500 // SCChatInternal_2500
  | 2501 // SCChatRateLimit_2501
  | 2502 // SCChatConvExists_2502
  | 2503 // SCChatUnknownTLFID_2503
  | 2504 // SCChatNotInConv_2504
  | 2505 // SCChatBadMsg_2505
  | 2506 // SCChatBroadcast_2506
  | 2507 // SCChatAlreadySuperseded_2507
  | 2508 // SCChatAlreadyDeleted_2508
  | 2509 // SCChatTLFFinalized_2509
  | 2510 // SCChatCollision_2510
  | 2511 // SCIdentifySummaryError_2511
  | 2512 // SCNeedSelfRekey_2512
  | 2513 // SCNeedOtherRekey_2513
  | 2514 // SCChatMessageCollision_2514

export type Stream = {
  fd: int,
}

export type StringKVPair = {
  key: string,
  value: string,
}

export type TLF = {
  id: TLFID,
  name: string,
  writers?: ?Array<string>,
  readers?: ?Array<string>,
  isPrivate: boolean,
}

export type TLFBreak = {
  breaks?: ?Array<TLFIdentifyFailure>,
}

export type TLFID = string

export type TLFIdentifyBehavior =
    0 // DEFAULT_KBFS_0
  | 1 // CHAT_CLI_1
  | 2 // CHAT_GUI_2
  | 3 // CHAT_GUI_STRICT_3
  | 4 // KBFS_REKEY_4
  | 5 // KBFS_QR_5
  | 6 // CHAT_SKIP_6

export type TLFIdentifyFailure = {
  user: User,
  breaks?: ?IdentifyTrackBreaks,
}

export type TLFQuery = {
  tlfName: string,
  identifyBehavior: TLFIdentifyBehavior,
}

export type Test = {
  reply: string,
}

export type Text = {
  data: string,
  markup: boolean,
}

export type Time = long

export type TrackDiff = {
  type: TrackDiffType,
  displayMarkup: string,
}

export type TrackDiffType =
    0 // NONE_0
  | 1 // ERROR_1
  | 2 // CLASH_2
  | 3 // REVOKED_3
  | 4 // UPGRADED_4
  | 5 // NEW_5
  | 6 // REMOTE_FAIL_6
  | 7 // REMOTE_WORKING_7
  | 8 // REMOTE_CHANGED_8
  | 9 // NEW_ELDEST_9
  | 10 // NONE_VIA_TEMPORARY_10

export type TrackOptions = {
  localOnly: boolean,
  bypassConfirm: boolean,
  forceRetrack: boolean,
  expiringLocal: boolean,
  forPGPPull: boolean,
}

export type TrackProof = {
  proofType: string,
  proofName: string,
  idString: string,
}

export type TrackStatus =
    1 // NEW_OK_1
  | 2 // NEW_ZERO_PROOFS_2
  | 3 // NEW_FAIL_PROOFS_3
  | 4 // UPDATE_BROKEN_FAILED_PROOFS_4
  | 5 // UPDATE_NEW_PROOFS_5
  | 6 // UPDATE_OK_6
  | 7 // UPDATE_BROKEN_REVOKED_7

export type TrackSummary = {
  username: string,
  time: Time,
  isRemote: boolean,
}

export type TrackToken = string

export type Tracker = {
  tracker: UID,
  status: int,
  mTime: Time,
}

export type UID = string

export type UnboxAnyRes = {
  kid: KID,
  plaintext: Bytes32,
  index: int,
}

export type UninstallResult = {
  componentResults?: ?Array<ComponentResult>,
  status: Status,
}

export type User = {
  uid: UID,
  username: string,
}

export type UserCard = {
  following: int,
  followers: int,
  uid: UID,
  fullName: string,
  location: string,
  bio: string,
  website: string,
  twitter: string,
  youFollowThem: boolean,
  theyFollowYou: boolean,
}

export type UserPlusAllKeys = {
  base: UserPlusKeys,
  pgpKeys?: ?Array<PublicKey>,
  remoteTracks?: ?Array<RemoteTrack>,
}

export type UserPlusKeys = {
  uid: UID,
  username: string,
  deviceKeys?: ?Array<PublicKey>,
  revokedDeviceKeys?: ?Array<RevokedKey>,
  pgpKeyCount: int,
  uvv: UserVersionVector,
  deletedDeviceKeys?: ?Array<PublicKey>,
}

export type UserResolution = {
  assertion: SocialAssertion,
  userID: UID,
}

export type UserSettings = {
  emails?: ?Array<Email>,
}

export type UserSummary = {
  uid: UID,
  username: string,
  thumbnail: string,
  idVersion: int,
  fullName: string,
  bio: string,
  proofs: Proofs,
  sigIDDisplay: string,
  trackTime: Time,
}

export type UserSummary2 = {
  uid: UID,
  username: string,
  thumbnail: string,
  fullName: string,
  isFollower: boolean,
  isFollowee: boolean,
}

export type UserSummary2Set = {
  users?: ?Array<UserSummary2>,
  time: Time,
  version: int,
}

export type UserVersionVector = {
  id: long,
  sigHints: int,
  sigChain: long,
  cachedAt: Time,
  lastIdentifiedAt: Time,
}

export type VerifySessionRes = {
  uid: UID,
  sid: string,
  generated: int,
  lifetime: int,
}

export type WebProof = {
  hostname: string,
  protocols?: ?Array<string>,
}

export type WriteArgs = {
  opID: OpID,
  path: Path,
  offset: long,
}

export type accountEmailChangeRpcParam = Exact<{
  newEmail: string
}>

export type accountPassphraseChangeRpcParam = Exact<{
  oldPassphrase: string,
  passphrase: string,
  force: boolean
}>

export type accountPassphrasePromptRpcParam = Exact<{
  guiArg: GUIEntryArg
}>

export type apiserverGetRpcParam = Exact<{
  endpoint: string,
  args?: ?Array<StringKVPair>,
  httpStatus?: ?Array<int>,
  appStatusCode?: ?Array<int>
}>

export type apiserverPostJSONRpcParam = Exact<{
  endpoint: string,
  args?: ?Array<StringKVPair>,
  JSONPayload?: ?Array<StringKVPair>,
  httpStatus?: ?Array<int>,
  appStatusCode?: ?Array<int>
}>

export type apiserverPostRpcParam = Exact<{
  endpoint: string,
  args?: ?Array<StringKVPair>,
  httpStatus?: ?Array<int>,
  appStatusCode?: ?Array<int>
}>

export type blockAddReferenceRpcParam = Exact<{
  folder: string,
  ref: BlockReference
}>

export type blockArchiveReferenceRpcParam = Exact<{
  folder: string,
  refs?: ?Array<BlockReference>
}>

export type blockArchiveReferenceWithCountRpcParam = Exact<{
  folder: string,
  refs?: ?Array<BlockReference>
}>

export type blockAuthenticateSessionRpcParam = Exact<{
  signature: string
}>

export type blockDelReferenceRpcParam = Exact<{
  folder: string,
  ref: BlockReference
}>

export type blockDelReferenceWithCountRpcParam = Exact<{
  folder: string,
  refs?: ?Array<BlockReference>
}>

export type blockGetBlockRpcParam = Exact<{
  bid: BlockIdCombo,
  folder: string
}>

export type blockPutBlockRpcParam = Exact<{
  bid: BlockIdCombo,
  folder: string,
  blockKey: string,
  buf: bytes
}>

export type configClearValueRpcParam = Exact<{
  path: string
}>

export type configGetValueRpcParam = Exact<{
  path: string
}>

export type configHelloIAmRpcParam = Exact<{
  details: ClientDetails
}>

export type configSetPathRpcParam = Exact<{
  path: string
}>

export type configSetUserConfigRpcParam = Exact<{
  username: string,
  key: string,
  value: string
}>

export type configSetValueRpcParam = Exact<{
  path: string,
  value: ConfigValue
}>

export type configWaitForClientRpcParam = Exact<{
  clientType: ClientType,
  timeout: DurationSec
}>

export type cryptoSignED25519ForKBFSRpcParam = Exact<{
  msg: bytes,
  reason: string
}>

export type cryptoSignED25519RpcParam = Exact<{
  msg: bytes,
  reason: string
}>

export type cryptoSignToStringRpcParam = Exact<{
  msg: bytes,
  reason: string
}>

export type cryptoUnboxBytes32AnyRpcParam = Exact<{
  bundles?: ?Array<CiphertextBundle>,
  reason: string,
  promptPaper: boolean
}>

export type cryptoUnboxBytes32RpcParam = Exact<{
  encryptedBytes32: EncryptedBytes32,
  nonce: BoxNonce,
  peersPublicKey: BoxPublicKey,
  reason: string
}>

export type cryptocurrencyRegisterAddressRpcParam = Exact<{
  address: string,
  force: boolean,
  wantedFamily: string
}>

export type ctlDbDeleteRpcParam = Exact<{
  key: DbKey
}>

export type ctlDbGetRpcParam = Exact<{
  key: DbKey
}>

export type ctlDbPutRpcParam = Exact<{
  key: DbKey,
  value: DbValue
}>

export type ctlStopRpcParam = Exact<{
  exitCode: ExitCode
}>

export type debuggingFirstStepRpcParam = Exact<{
  val: int
}>

export type debuggingIncrementRpcParam = Exact<{
  val: int
}>

export type debuggingSecondStepRpcParam = Exact<{
  val: int
}>

export type deviceCheckDeviceNameForUserRpcParam = Exact<{
  username: string,
  devicename: string
}>

export type deviceCheckDeviceNameFormatRpcParam = Exact<{
  name: string
}>

export type favoriteFavoriteAddRpcParam = Exact<{
  folder: Folder
}>

export type favoriteFavoriteIgnoreRpcParam = Exact<{
  folder: Folder
}>

export type fsListRpcParam = Exact<{
  path: string
}>

export type gpgUiSelectKeyAndPushOptionRpcParam = Exact<{
  keys?: ?Array<GPGKey>
}>

export type gpgUiSelectKeyRpcParam = Exact<{
  keys?: ?Array<GPGKey>
}>

export type gpgUiSignRpcParam = Exact<{
  msg: bytes,
  fingerprint: bytes
}>

export type gregorUIPushOutOfBandMessagesRpcParam = Exact<{
  oobm?: ?Array<gregor1.OutOfBandMessage>
}>

export type gregorUIPushStateRpcParam = Exact<{
  state: gregor1.State,
  reason: PushReason
}>

export type identifyIdentify2RpcParam = Exact<{
  uid: UID,
  userAssertion: string,
  reason: IdentifyReason,
  useDelegateUI?: boolean,
  alwaysBlock?: boolean,
  noErrorOnTrackFailure?: boolean,
  forceRemoteCheck?: boolean,
  needProofSet?: boolean,
  allowEmptySelfID?: boolean,
  noSkipSelf?: boolean,
  canSuppressUI?: boolean,
  identifyBehavior?: TLFIdentifyBehavior,
  forceDisplay?: boolean
}>

export type identifyIdentifyRpcParam = Exact<{
  userAssertion: string,
  forceRemoteCheck?: boolean,
  useDelegateUI?: boolean,
  reason: IdentifyReason,
  source: ClientType
}>

export type identifyResolve2RpcParam = Exact<{
  assertion: string
}>

export type identifyResolveRpcParam = Exact<{
  assertion: string
}>

export type identifyUiConfirmRpcParam = Exact<{
  outcome: IdentifyOutcome
}>

export type identifyUiDismissRpcParam = Exact<{
  username: string,
  reason: DismissReason
}>

export type identifyUiDisplayCryptocurrencyRpcParam = Exact<{
  c: Cryptocurrency
}>

export type identifyUiDisplayKeyRpcParam = Exact<{
  key: IdentifyKey
}>

export type identifyUiDisplayTLFCreateWithInviteRpcParam = Exact<{
  folderName: string,
  isPrivate: boolean,
  assertion: string,
  socialAssertion: SocialAssertion,
  inviteLink: string,
  throttled: boolean
}>

export type identifyUiDisplayTrackStatementRpcParam = Exact<{
  stmt: string
}>

export type identifyUiDisplayUserCardRpcParam = Exact<{
  card: UserCard
}>

export type identifyUiFinishSocialProofCheckRpcParam = Exact<{
  rp: RemoteProof,
  lcr: LinkCheckResult
}>

export type identifyUiFinishWebProofCheckRpcParam = Exact<{
  rp: RemoteProof,
  lcr: LinkCheckResult
}>

export type identifyUiLaunchNetworkChecksRpcParam = Exact<{
  identity: Identity,
  user: User
}>

export type identifyUiReportLastTrackRpcParam = Exact<{
  track?: ?TrackSummary
}>

export type identifyUiReportTrackTokenRpcParam = Exact<{
  trackToken: TrackToken
}>

export type identifyUiStartRpcParam = Exact<{
  username: string,
  reason: IdentifyReason,
  forceDisplay?: boolean
}>

export type kbfsFSEditListRpcParam = Exact<{
  edits?: ?Array<FSNotification>,
  requestID: int
}>

export type kbfsFSEventRpcParam = Exact<{
  event: FSNotification
}>

export type kbfsFSSyncEventRpcParam = Exact<{
  event: FSPathSyncStatus
}>

export type kbfsFSSyncStatusRpcParam = Exact<{
  status: FSSyncStatus,
  requestID: int
}>

export type kbfsMountSetCurrentMountDirRpcParam = Exact<{
  dir: string
}>

export type logRegisterLoggerRpcParam = Exact<{
  name: string,
  level: LogLevel
}>

export type logUiLogRpcParam = Exact<{
  level: LogLevel,
  text: Text
}>

export type loginClearStoredSecretRpcParam = Exact<{
  username: string
}>

export type loginDeprovisionRpcParam = Exact<{
  username: string,
  doRevoke: boolean
}>

export type loginLoginProvisionedDeviceRpcParam = Exact<{
  username: string,
  noPassphrasePrompt: boolean
}>

export type loginLoginRpcParam = Exact<{
  deviceType: string,
  usernameOrEmail: string,
  clientType: ClientType
}>

export type loginPaperKeySubmitRpcParam = Exact<{
  paperPhrase: string
}>

export type loginPgpProvisionRpcParam = Exact<{
  username: string,
  passphrase: string,
  deviceName: string
}>

export type loginRecoverAccountFromEmailAddressRpcParam = Exact<{
  email: string
}>

export type loginUiDisplayPaperKeyPhraseRpcParam = Exact<{
  phrase: string
}>

export type loginUiDisplayPrimaryPaperKeyRpcParam = Exact<{
  phrase: string
}>

export type loginUiPromptRevokePaperKeysRpcParam = Exact<{
  device: Device,
  index: int
}>

export type loginUnlockWithPassphraseRpcParam = Exact<{
  passphrase: string
}>

export type metadataAuthenticateRpcParam = Exact<{
  signature: string
}>

export type metadataDeleteKeyRpcParam = Exact<{
  uid: UID,
  deviceKID: KID,
  keyHalfID: bytes,
  logTags: {[key: string]: string}
}>

export type metadataGetFolderHandleRpcParam = Exact<{
  folderID: string,
  signature: string,
  challenge: string
}>

export type metadataGetFoldersForRekeyRpcParam = Exact<{
  deviceKID: KID
}>

export type metadataGetKeyBundlesRpcParam = Exact<{
  folderID: string,
  writerBundleID: string,
  readerBundleID: string
}>

export type metadataGetKeyRpcParam = Exact<{
  keyHalfID: bytes,
  deviceKID: string,
  logTags: {[key: string]: string}
}>

export type metadataGetLatestFolderHandleRpcParam = Exact<{
  folderID: string
}>

export type metadataGetMerkleNodeRpcParam = Exact<{
  hash: string
}>

export type metadataGetMerkleRootLatestRpcParam = Exact<{
  treeID: MerkleTreeID
}>

export type metadataGetMerkleRootRpcParam = Exact<{
  treeID: MerkleTreeID,
  seqNo: long
}>

export type metadataGetMerkleRootSinceRpcParam = Exact<{
  treeID: MerkleTreeID,
  when: Time
}>

export type metadataGetMetadataRpcParam = Exact<{
  folderID: string,
  folderHandle: bytes,
  branchID: string,
  unmerged: boolean,
  startRevision: long,
  stopRevision: long,
  logTags: {[key: string]: string}
}>

export type metadataPruneBranchRpcParam = Exact<{
  folderID: string,
  branchID: string,
  logTags: {[key: string]: string}
}>

export type metadataPutKeysRpcParam = Exact<{
  keyHalves?: ?Array<KeyHalf>,
  logTags: {[key: string]: string}
}>

export type metadataPutMetadataRpcParam = Exact<{
  mdBlock: MDBlock,
  readerKeyBundle: KeyBundle,
  writerKeyBundle: KeyBundle,
  logTags: {[key: string]: string}
}>

export type metadataRegisterForUpdatesRpcParam = Exact<{
  folderID: string,
  currRevision: long,
  logTags: {[key: string]: string}
}>

export type metadataTruncateLockRpcParam = Exact<{
  folderID: string
}>

export type metadataTruncateUnlockRpcParam = Exact<{
  folderID: string
}>

export type metadataUpdateFolderNeedsRekeyRpcParam = Exact<{
  folderID: string,
  revision: long
}>

export type metadataUpdateFoldersNeedRekeyRpcParam = Exact<{
  requests?: ?Array<RekeyRequest>
}>

export type metadataUpdateMetadataUpdateRpcParam = Exact<{
  folderID: string,
  revision: long
}>

export type notifyCtlSetNotificationsRpcParam = Exact<{
  channels: NotificationChannels
}>

export type paperprovisionPaperProvisionRpcParam = Exact<{
  username: string,
  deviceName: string,
  paperKey: string,
  keepPaperKey: boolean
}>

export type pgpPgpDecryptRpcParam = Exact<{
  source: Stream,
  sink: Stream,
  opts: PGPDecryptOptions
}>

export type pgpPgpEncryptRpcParam = Exact<{
  source: Stream,
  sink: Stream,
  opts: PGPEncryptOptions
}>

export type pgpPgpExportByFingerprintRpcParam = Exact<{
  options: PGPQuery
}>

export type pgpPgpExportByKIDRpcParam = Exact<{
  options: PGPQuery
}>

export type pgpPgpExportRpcParam = Exact<{
  options: PGPQuery
}>

export type pgpPgpImportRpcParam = Exact<{
  key: bytes,
  pushSecret: boolean
}>

export type pgpPgpKeyGenDefaultRpcParam = Exact<{
  createUids: PGPCreateUids
}>

export type pgpPgpKeyGenRpcParam = Exact<{
  primaryBits: int,
  subkeyBits: int,
  createUids: PGPCreateUids,
  allowMulti: boolean,
  doExport: boolean,
  pushSecret: boolean
}>

export type pgpPgpPullRpcParam = Exact<{
  userAsserts?: ?Array<string>
}>

export type pgpPgpPurgeRpcParam = Exact<{
  doPurge: boolean
}>

export type pgpPgpSelectRpcParam = Exact<{
  fingerprintQuery: string,
  allowMulti: boolean,
  skipImport: boolean,
  onlyImport: boolean
}>

export type pgpPgpSignRpcParam = Exact<{
  source: Stream,
  sink: Stream,
  opts: PGPSignOptions
}>

export type pgpPgpUpdateRpcParam = Exact<{
  all: boolean,
  fingerprints?: ?Array<string>
}>

export type pgpPgpVerifyRpcParam = Exact<{
  source: Stream,
  opts: PGPVerifyOptions
}>

export type pgpUiKeyGeneratedRpcParam = Exact<{
  kid: KID,
  key: KeyInfo
}>

export type pgpUiOutputSignatureSuccessNonKeybaseRpcParam = Exact<{
  keyID: string,
  signedAt: Time
}>

export type pgpUiOutputSignatureSuccessRpcParam = Exact<{
  fingerprint: string,
  username: string,
  signedAt: Time
}>

export type proveCheckProofRpcParam = Exact<{
  sigID: SigID
}>

export type proveStartProofRpcParam = Exact<{
  service: string,
  username: string,
  force: boolean,
  promptPosted: boolean,
  auto: boolean
}>

export type proveUiDisplayRecheckWarningRpcParam = Exact<{
  text: Text
}>

export type proveUiOkToCheckRpcParam = Exact<{
  name: string,
  attempt: int
}>

export type proveUiOutputInstructionsRpcParam = Exact<{
  instructions: Text,
  proof: string
}>

export type proveUiOutputPrechecksRpcParam = Exact<{
  text: Text
}>

export type proveUiPreProofWarningRpcParam = Exact<{
  text: Text
}>

export type proveUiPromptOverwriteRpcParam = Exact<{
  account: string,
  typ: PromptOverwriteType
}>

export type proveUiPromptUsernameRpcParam = Exact<{
  prompt: string,
  prevError?: ?Status
}>

export type provisionUiChooseDeviceRpcParam = Exact<{
  devices?: ?Array<Device>
}>

export type provisionUiChooseDeviceTypeRpcParam = Exact<{
  kind: ChooseType
}>

export type provisionUiChooseGPGMethodRpcParam = Exact<{
  keys?: ?Array<GPGKey>
}>

export type provisionUiChooseProvisioningMethodRpcParam = Exact<{
  gpgOption: boolean
}>

export type provisionUiDisplayAndPromptSecretRpcParam = Exact<{
  secret: bytes,
  phrase: string,
  otherDeviceType: DeviceType
}>

export type provisionUiPromptNewDeviceNameRpcParam = Exact<{
  existingDevices?: ?Array<string>,
  errorMessage: string
}>

export type provisionUiProvisioneeSuccessRpcParam = Exact<{
  username: string,
  deviceName: string
}>

export type provisionUiProvisionerSuccessRpcParam = Exact<{
  deviceName: string,
  deviceType: string
}>

export type provisionUiSwitchToGPGSignOKRpcParam = Exact<{
  key: GPGKey,
  importError: string
}>

export type quotaVerifySessionRpcParam = Exact<{
  session: string
}>

export type reachabilityReachabilityChangedRpcParam = Exact<{
  reachability: Reachability
}>

export type rekeyGetRevokeWarningRpcParam = Exact<{
  session: int,
  actingDevice: DeviceID,
  targetDevice: DeviceID
}>

export type rekeyRekeySyncRpcParam = Exact<{
  force: boolean
}>

export type rekeyUIRefreshRpcParam = Exact<{
  problemSetDevices: ProblemSetDevices
}>

export type rekeyUIRekeySendEventRpcParam = Exact<{
  event: RekeyEvent
}>

export type revokeRevokeDeviceRpcParam = Exact<{
  deviceID: DeviceID,
  force: boolean
}>

export type revokeRevokeKeyRpcParam = Exact<{
  keyID: KID
}>

export type revokeRevokeSigsRpcParam = Exact<{
  sigIDQueries?: ?Array<string>
}>

export type saltpackSaltpackDecryptRpcParam = Exact<{
  source: Stream,
  sink: Stream,
  opts: SaltpackDecryptOptions
}>

export type saltpackSaltpackEncryptRpcParam = Exact<{
  source: Stream,
  sink: Stream,
  opts: SaltpackEncryptOptions
}>

export type saltpackSaltpackSignRpcParam = Exact<{
  source: Stream,
  sink: Stream,
  opts: SaltpackSignOptions
}>

export type saltpackSaltpackVerifyRpcParam = Exact<{
  source: Stream,
  sink: Stream,
  opts: SaltpackVerifyOptions
}>

export type saltpackUiSaltpackPromptForDecryptRpcParam = Exact<{
  sender: SaltpackSender,
  usedDelegateUI: boolean
}>

export type saltpackUiSaltpackVerifyBadSenderRpcParam = Exact<{
  signingKID: KID,
  sender: SaltpackSender
}>

export type saltpackUiSaltpackVerifySuccessRpcParam = Exact<{
  signingKID: KID,
  sender: SaltpackSender
}>

export type secretUiGetPassphraseRpcParam = Exact<{
  pinentry: GUIEntryArg,
  terminal?: ?SecretEntryArg
}>

export type signupCheckInvitationCodeRpcParam = Exact<{
  invitationCode: string
}>

export type signupCheckUsernameAvailableRpcParam = Exact<{
  username: string
}>

export type signupInviteRequestRpcParam = Exact<{
  email: string,
  fullname: string,
  notes: string
}>

export type signupSignupRpcParam = Exact<{
  email: string,
  inviteCode: string,
  passphrase: string,
  username: string,
  deviceName: string,
  deviceType: DeviceType,
  storeSecret: boolean,
  skipMail: boolean,
  genPGPBatch: boolean
}>

export type sigsSigListJSONRpcParam = Exact<{
  arg: SigListArgs
}>

export type sigsSigListRpcParam = Exact<{
  arg: SigListArgs
}>

export type streamUiCloseRpcParam = Exact<{
  s: Stream
}>

export type streamUiReadRpcParam = Exact<{
  s: Stream,
  sz: int
}>

export type streamUiResetRpcParam = Exact<{
  s: Stream
}>

export type streamUiWriteRpcParam = Exact<{
  s: Stream,
  buf: bytes
}>

export type testPanicRpcParam = Exact<{
  message: string
}>

export type testTestCallbackRpcParam = Exact<{
  name: string
}>

export type testTestRpcParam = Exact<{
  name: string
}>

export type tlfCompleteAndCanonicalizePrivateTlfNameRpcParam = Exact<{
  query: TLFQuery
}>

export type tlfCryptKeysRpcParam = Exact<{
  query: TLFQuery
}>

export type tlfKeysGetPublicCanonicalTLFNameAndIDRpcParam = Exact<{
  query: TLFQuery
}>

export type tlfKeysGetTLFCryptKeysRpcParam = Exact<{
  query: TLFQuery
}>

export type tlfPublicCanonicalTLFNameAndIDRpcParam = Exact<{
  query: TLFQuery
}>

export type trackDismissWithTokenRpcParam = Exact<{
  trackToken: TrackToken
}>

export type trackFakeTrackingChangedRpcParam = Exact<{
  username: string,
  isTracking: boolean
}>

export type trackTrackRpcParam = Exact<{
  userAssertion: string,
  options: TrackOptions,
  forceRemoteCheck: boolean
}>

export type trackTrackWithTokenRpcParam = Exact<{
  trackToken: TrackToken,
  options: TrackOptions
}>

export type trackUntrackRpcParam = Exact<{
  username: string
}>

export type uiPromptYesNoRpcParam = Exact<{
  text: Text,
  promptDefault: PromptDefault
}>

export type userListTrackers2RpcParam = Exact<{
  assertion: string,
  reverse: boolean
}>

export type userListTrackersByNameRpcParam = Exact<{
  username: string
}>

export type userListTrackersRpcParam = Exact<{
  uid: UID
}>

export type userListTrackingJSONRpcParam = Exact<{
  filter: string,
  verbose: boolean,
  assertion: string
}>

export type userListTrackingRpcParam = Exact<{
  filter: string,
  assertion: string
}>

export type userLoadAllPublicKeysUnverifiedRpcParam = Exact<{
  uid: UID
}>

export type userLoadPublicKeysRpcParam = Exact<{
  uid: UID
}>

export type userLoadUncheckedUserSummariesRpcParam = Exact<{
  uids?: ?Array<UID>
}>

export type userLoadUserByNameRpcParam = Exact<{
  username: string
}>

export type userLoadUserPlusKeysRpcParam = Exact<{
  uid: UID,
  pollForKID: KID
}>

export type userLoadUserRpcParam = Exact<{
  uid: UID
}>

export type userProfileEditRpcParam = Exact<{
  fullName: string,
  location: string,
  bio: string
}>

export type userSearchRpcParam = Exact<{
  query: string
}>
type Kex2Provisionee2Hello2Result = Hello2Res
type Kex2ProvisioneeHelloResult = HelloRes
type SecretKeysGetSecretKeysResult = SecretKeys
type SimpleFSSimpleFSCheckResult = Progress
type SimpleFSSimpleFSGetOpsResult = ?Array<OpDescription>
type SimpleFSSimpleFSMakeOpidResult = OpID
type SimpleFSSimpleFSReadListResult = SimpleFSListResult
type SimpleFSSimpleFSReadResult = FileContent
type SimpleFSSimpleFSStatResult = Dirent
type accountHasServerKeysResult = HasServerKeysRes
type accountPassphrasePromptResult = GetPassphraseRes
type apiserverGetResult = APIRes
type apiserverPostJSONResult = APIRes
type apiserverPostResult = APIRes
type blockArchiveReferenceResult = ?Array<BlockReference>
type blockArchiveReferenceWithCountResult = DowngradeReferenceRes
type blockBlockPingResult = BlockPingResponse
type blockDelReferenceWithCountResult = DowngradeReferenceRes
type blockGetBlockResult = GetBlockRes
type blockGetSessionChallengeResult = ChallengeInfo
type blockGetUserQuotaInfoResult = bytes
type configCheckAPIServerOutOfDateWarningResult = OutOfDateInfo
type configGetConfigResult = Config
type configGetCurrentStatusResult = GetCurrentStatusRes
type configGetExtendedStatusResult = ExtendedStatus
type configGetValueResult = ConfigValue
type configWaitForClientResult = boolean
type cryptoSignED25519ForKBFSResult = ED25519SignatureInfo
type cryptoSignED25519Result = ED25519SignatureInfo
type cryptoSignToStringResult = string
type cryptoUnboxBytes32AnyResult = UnboxAnyRes
type cryptoUnboxBytes32Result = Bytes32
type cryptocurrencyRegisterAddressResult = RegisterAddressRes
type ctlDbGetResult = ?DbValue
type debuggingFirstStepResult = FirstStepResult
type debuggingIncrementResult = int
type debuggingSecondStepResult = int
type deviceCheckDeviceNameFormatResult = boolean
type deviceDeviceHistoryListResult = ?Array<DeviceDetail>
type deviceDeviceListResult = ?Array<Device>
type favoriteGetFavoritesResult = FavoritesResult
type fsListResult = ListResult
type gpgUiConfirmDuplicateKeyChosenResult = boolean
type gpgUiGetTTYResult = string
type gpgUiSelectKeyAndPushOptionResult = SelectKeyRes
type gpgUiSelectKeyResult = string
type gpgUiSignResult = string
type gpgUiWantToAddGPGKeyResult = boolean
type gregorGetStateResult = gregor1.State
type identifyIdentify2Result = Identify2Res
type identifyIdentifyResult = IdentifyRes
type identifyResolve2Result = User
type identifyResolveResult = UID
type identifyUiConfirmResult = ConfirmResult
type identifyUiDelegateIdentifyUIResult = int
type kbfsMountGetAllAvailableMountDirsResult = ?Array<string>
type kbfsMountGetCurrentMountDirResult = string
type loginGetConfiguredAccountsResult = ?Array<ConfiguredAccount>
type loginUiGetEmailOrUsernameResult = string
type loginUiPromptRevokePaperKeysResult = boolean
type metadataAuthenticateResult = int
type metadataGetChallengeResult = ChallengeInfo
type metadataGetFolderHandleResult = bytes
type metadataGetKeyBundlesResult = KeyBundleResponse
type metadataGetKeyResult = bytes
type metadataGetLatestFolderHandleResult = bytes
type metadataGetMerkleNodeResult = bytes
type metadataGetMerkleRootLatestResult = MerkleRoot
type metadataGetMerkleRootResult = MerkleRoot
type metadataGetMerkleRootSinceResult = MerkleRoot
type metadataGetMetadataResult = MetadataResponse
type metadataPing2Result = PingResponse
type metadataTruncateLockResult = boolean
type metadataTruncateUnlockResult = boolean
type pgpPgpDecryptResult = PGPSigVerification
type pgpPgpExportByFingerprintResult = ?Array<KeyInfo>
type pgpPgpExportByKIDResult = ?Array<KeyInfo>
type pgpPgpExportResult = ?Array<KeyInfo>
type pgpPgpPurgeResult = PGPPurgeRes
type pgpPgpVerifyResult = PGPSigVerification
type pgpUiShouldPushPrivateResult = boolean
type proveCheckProofResult = CheckProofStatus
type proveStartProofResult = StartProofResult
type proveUiOkToCheckResult = boolean
type proveUiPreProofWarningResult = boolean
type proveUiPromptOverwriteResult = boolean
type proveUiPromptUsernameResult = string
type provisionUiChooseDeviceResult = DeviceID
type provisionUiChooseDeviceTypeResult = DeviceType
type provisionUiChooseGPGMethodResult = GPGMethod
type provisionUiChooseProvisioningMethodResult = ProvisionMethod
type provisionUiDisplayAndPromptSecretResult = SecretResponse
type provisionUiPromptNewDeviceNameResult = string
type provisionUiSwitchToGPGSignOKResult = boolean
type quotaVerifySessionResult = VerifySessionRes
type reachabilityCheckReachabilityResult = Reachability
type reachabilityStartReachabilityResult = Reachability
type rekeyGetPendingRekeyStatusResult = ProblemSetDevices
type rekeyGetRevokeWarningResult = RevokeWarning
type rekeyRekeyStatusFinishResult = Outcome
type rekeyUIDelegateRekeyUIResult = int
type saltpackSaltpackDecryptResult = SaltpackEncryptedMessageInfo
type secretUiGetPassphraseResult = GetPassphraseRes
type sessionCurrentSessionResult = Session
type signupGetInvitationCodeResult = string
type signupSignupResult = SignupRes
type sigsSigListJSONResult = string
type sigsSigListResult = ?Array<Sig>
type streamUiReadResult = bytes
type streamUiWriteResult = int
type testTestCallbackResult = string
type testTestResult = Test
type tlfCompleteAndCanonicalizePrivateTlfNameResult = CanonicalTLFNameAndIDWithBreaks
type tlfCryptKeysResult = GetTLFCryptKeysRes
type tlfKeysGetPublicCanonicalTLFNameAndIDResult = CanonicalTLFNameAndIDWithBreaks
type tlfKeysGetTLFCryptKeysResult = GetTLFCryptKeysRes
type tlfPublicCanonicalTLFNameAndIDResult = CanonicalTLFNameAndIDWithBreaks
type uiPromptYesNoResult = boolean
type userListTrackers2Result = UserSummary2Set
type userListTrackersByNameResult = ?Array<Tracker>
type userListTrackersResult = ?Array<Tracker>
type userListTrackersSelfResult = ?Array<Tracker>
type userListTrackingJSONResult = string
type userListTrackingResult = ?Array<UserSummary>
type userLoadAllPublicKeysUnverifiedResult = ?Array<PublicKey>
type userLoadMyPublicKeysResult = ?Array<PublicKey>
type userLoadMySettingsResult = UserSettings
type userLoadPublicKeysResult = ?Array<PublicKey>
type userLoadUncheckedUserSummariesResult = ?Array<UserSummary>
type userLoadUserByNameResult = User
type userLoadUserPlusKeysResult = UserPlusKeys
type userLoadUserResult = User
type userSearchResult = ?Array<SearchResult>

export type rpc =
    BTCRegisterBTCRpc
  | Kex2Provisionee2DidCounterSign2Rpc
  | Kex2Provisionee2Hello2Rpc
  | Kex2ProvisioneeDidCounterSignRpc
  | Kex2ProvisioneeHelloRpc
  | Kex2ProvisionerKexStartRpc
  | NotifyFSRequestFSEditListRequestRpc
  | NotifyFSRequestFSSyncStatusRequestRpc
  | ScanProofsScanProofsRpc
  | SecretKeysGetSecretKeysRpc
  | SimpleFSSimpleFSCancelRpc
  | SimpleFSSimpleFSCheckRpc
  | SimpleFSSimpleFSCloseRpc
  | SimpleFSSimpleFSCopyRecursiveRpc
  | SimpleFSSimpleFSCopyRpc
  | SimpleFSSimpleFSGetOpsRpc
  | SimpleFSSimpleFSListRecursiveRpc
  | SimpleFSSimpleFSListRpc
  | SimpleFSSimpleFSMakeOpidRpc
  | SimpleFSSimpleFSMoveRpc
  | SimpleFSSimpleFSOpenRpc
  | SimpleFSSimpleFSReadListRpc
  | SimpleFSSimpleFSReadRpc
  | SimpleFSSimpleFSRemoveRpc
  | SimpleFSSimpleFSRenameRpc
  | SimpleFSSimpleFSSetStatRpc
  | SimpleFSSimpleFSStatRpc
  | SimpleFSSimpleFSWaitRpc
  | SimpleFSSimpleFSWriteRpc
  | accountEmailChangeRpc
  | accountHasServerKeysRpc
  | accountPassphraseChangeRpc
  | accountPassphrasePromptRpc
  | accountResetAccountRpc
  | apiserverGetRpc
  | apiserverPostJSONRpc
  | apiserverPostRpc
  | blockAddReferenceRpc
  | blockArchiveReferenceRpc
  | blockArchiveReferenceWithCountRpc
  | blockAuthenticateSessionRpc
  | blockBlockPingRpc
  | blockDelReferenceRpc
  | blockDelReferenceWithCountRpc
  | blockGetBlockRpc
  | blockGetSessionChallengeRpc
  | blockGetUserQuotaInfoRpc
  | blockPutBlockRpc
  | configCheckAPIServerOutOfDateWarningRpc
  | configClearValueRpc
  | configGetConfigRpc
  | configGetCurrentStatusRpc
  | configGetExtendedStatusRpc
  | configGetValueRpc
  | configHelloIAmRpc
  | configSetPathRpc
  | configSetUserConfigRpc
  | configSetValueRpc
  | configWaitForClientRpc
  | cryptoSignED25519ForKBFSRpc
  | cryptoSignED25519Rpc
  | cryptoSignToStringRpc
  | cryptoUnboxBytes32AnyRpc
  | cryptoUnboxBytes32Rpc
  | cryptocurrencyRegisterAddressRpc
  | ctlAppExitRpc
  | ctlDbDeleteRpc
  | ctlDbGetRpc
  | ctlDbNukeRpc
  | ctlDbPutRpc
  | ctlLogRotateRpc
  | ctlReloadRpc
  | ctlStopRpc
  | debuggingFirstStepRpc
  | debuggingIncrementRpc
  | debuggingSecondStepRpc
  | delegateUiCtlRegisterGregorFirehoseRpc
  | delegateUiCtlRegisterIdentifyUIRpc
  | delegateUiCtlRegisterRekeyUIRpc
  | delegateUiCtlRegisterSecretUIRpc
  | delegateUiCtlRegisterUpdateUIRpc
  | deviceCheckDeviceNameForUserRpc
  | deviceCheckDeviceNameFormatRpc
  | deviceDeviceAddRpc
  | deviceDeviceHistoryListRpc
  | deviceDeviceListRpc
  | favoriteFavoriteAddRpc
  | favoriteFavoriteIgnoreRpc
  | favoriteGetFavoritesRpc
  | fsListRpc
  | gregorGetStateRpc
  | identifyIdentify2Rpc
  | identifyIdentifyRpc
  | identifyResolve2Rpc
  | identifyResolveRpc
  | kbfsFSEditListRpc
  | kbfsFSEventRpc
  | kbfsFSSyncEventRpc
  | kbfsFSSyncStatusRpc
  | kbfsMountGetAllAvailableMountDirsRpc
  | kbfsMountGetCurrentMountDirRpc
  | kbfsMountSetCurrentMountDirRpc
  | logRegisterLoggerRpc
  | loginAccountDeleteRpc
  | loginClearStoredSecretRpc
  | loginDeprovisionRpc
  | loginGetConfiguredAccountsRpc
  | loginLoginProvisionedDeviceRpc
  | loginLoginRpc
  | loginLoginWithPaperKeyRpc
  | loginLogoutRpc
  | loginPaperKeyRpc
  | loginPaperKeySubmitRpc
  | loginPgpProvisionRpc
  | loginRecoverAccountFromEmailAddressRpc
  | loginUnlockRpc
  | loginUnlockWithPassphraseRpc
  | metadataAuthenticateRpc
  | metadataDeleteKeyRpc
  | metadataGetChallengeRpc
  | metadataGetFolderHandleRpc
  | metadataGetFoldersForRekeyRpc
  | metadataGetKeyBundlesRpc
  | metadataGetKeyRpc
  | metadataGetLatestFolderHandleRpc
  | metadataGetMerkleNodeRpc
  | metadataGetMerkleRootLatestRpc
  | metadataGetMerkleRootRpc
  | metadataGetMerkleRootSinceRpc
  | metadataGetMetadataRpc
  | metadataPing2Rpc
  | metadataPingRpc
  | metadataPruneBranchRpc
  | metadataPutKeysRpc
  | metadataPutMetadataRpc
  | metadataRegisterForUpdatesRpc
  | metadataTruncateLockRpc
  | metadataTruncateUnlockRpc
  | metadataUpdateFolderNeedsRekeyRpc
  | metadataUpdateFoldersNeedRekeyRpc
  | metadataUpdateMetadataUpdateRpc
  | notifyCtlSetNotificationsRpc
  | paperprovisionPaperProvisionRpc
  | pgpPgpDecryptRpc
  | pgpPgpDeletePrimaryRpc
  | pgpPgpEncryptRpc
  | pgpPgpExportByFingerprintRpc
  | pgpPgpExportByKIDRpc
  | pgpPgpExportRpc
  | pgpPgpImportRpc
  | pgpPgpKeyGenDefaultRpc
  | pgpPgpKeyGenRpc
  | pgpPgpPullRpc
  | pgpPgpPurgeRpc
  | pgpPgpSelectRpc
  | pgpPgpSignRpc
  | pgpPgpStorageDismissRpc
  | pgpPgpUpdateRpc
  | pgpPgpVerifyRpc
  | proveCheckProofRpc
  | proveStartProofRpc
  | quotaVerifySessionRpc
  | reachabilityCheckReachabilityRpc
  | reachabilityReachabilityChangedRpc
  | reachabilityStartReachabilityRpc
  | rekeyDebugShowRekeyStatusRpc
  | rekeyGetPendingRekeyStatusRpc
  | rekeyGetRevokeWarningRpc
  | rekeyRekeyStatusFinishRpc
  | rekeyRekeySyncRpc
  | rekeyShowPendingRekeyStatusRpc
  | revokeRevokeDeviceRpc
  | revokeRevokeKeyRpc
  | revokeRevokeSigsRpc
  | saltpackSaltpackDecryptRpc
  | saltpackSaltpackEncryptRpc
  | saltpackSaltpackSignRpc
  | saltpackSaltpackVerifyRpc
  | sessionCurrentSessionRpc
  | sessionSessionPingRpc
  | signupCheckInvitationCodeRpc
  | signupCheckUsernameAvailableRpc
  | signupGetInvitationCodeRpc
  | signupInviteRequestRpc
  | signupSignupRpc
  | sigsSigListJSONRpc
  | sigsSigListRpc
  | testPanicRpc
  | testTestCallbackRpc
  | testTestRpc
  | tlfCompleteAndCanonicalizePrivateTlfNameRpc
  | tlfCryptKeysRpc
  | tlfKeysGetPublicCanonicalTLFNameAndIDRpc
  | tlfKeysGetTLFCryptKeysRpc
  | tlfPublicCanonicalTLFNameAndIDRpc
  | trackCheckTrackingRpc
  | trackDismissWithTokenRpc
  | trackFakeTrackingChangedRpc
  | trackTrackRpc
  | trackTrackWithTokenRpc
  | trackUntrackRpc
  | userListTrackers2Rpc
  | userListTrackersByNameRpc
  | userListTrackersRpc
  | userListTrackersSelfRpc
  | userListTrackingJSONRpc
  | userListTrackingRpc
  | userLoadAllPublicKeysUnverifiedRpc
  | userLoadMyPublicKeysRpc
  | userLoadMySettingsRpc
  | userLoadPublicKeysRpc
  | userLoadUncheckedUserSummariesRpc
  | userLoadUserByNameRpc
  | userLoadUserPlusKeysRpc
  | userLoadUserRpc
  | userProfileEditRpc
  | userSearchRpc

export type incomingCallMapType = Exact<{
  'keybase.1.gpgUi.wantToAddGPGKey'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: gpgUiWantToAddGPGKeyResult) => void,
    }
  ) => void,
  'keybase.1.gpgUi.confirmDuplicateKeyChosen'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: gpgUiConfirmDuplicateKeyChosenResult) => void,
    }
  ) => void,
  'keybase.1.gpgUi.selectKeyAndPushOption'?: (
    params: Exact<{
      sessionID: int,
      keys?: ?Array<GPGKey>
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: gpgUiSelectKeyAndPushOptionResult) => void,
    }
  ) => void,
  'keybase.1.gpgUi.selectKey'?: (
    params: Exact<{
      sessionID: int,
      keys?: ?Array<GPGKey>
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: gpgUiSelectKeyResult) => void,
    }
  ) => void,
  'keybase.1.gpgUi.sign'?: (
    params: Exact<{
      msg: bytes,
      fingerprint: bytes
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: gpgUiSignResult) => void,
    }
  ) => void,
  'keybase.1.gpgUi.getTTY'?: (
    params: Exact<{}>,
    response: {
      error: RPCErrorHandler,
      result: (result: gpgUiGetTTYResult) => void,
    }
  ) => void,
  'keybase.1.gregorUI.pushState'?: (
    params: Exact<{
      state: gregor1.State,
      reason: PushReason
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.gregorUI.pushOutOfBandMessages'?: (
    params: Exact<{
      oobm?: ?Array<gregor1.OutOfBandMessage>
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.displayTLFCreateWithInvite'?: (
    params: Exact<{
      sessionID: int,
      folderName: string,
      isPrivate: boolean,
      assertion: string,
      socialAssertion: SocialAssertion,
      inviteLink: string,
      throttled: boolean
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.delegateIdentifyUI'?: (
    params: Exact<{}>,
    response: {
      error: RPCErrorHandler,
      result: (result: identifyUiDelegateIdentifyUIResult) => void,
    }
  ) => void,
  'keybase.1.identifyUi.start'?: (
    params: Exact<{
      sessionID: int,
      username: string,
      reason: IdentifyReason,
      forceDisplay?: boolean
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.displayKey'?: (
    params: Exact<{
      sessionID: int,
      key: IdentifyKey
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.reportLastTrack'?: (
    params: Exact<{
      sessionID: int,
      track?: ?TrackSummary
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.launchNetworkChecks'?: (
    params: Exact<{
      sessionID: int,
      identity: Identity,
      user: User
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.displayTrackStatement'?: (
    params: Exact<{
      sessionID: int,
      stmt: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.finishWebProofCheck'?: (
    params: Exact<{
      sessionID: int,
      rp: RemoteProof,
      lcr: LinkCheckResult
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.finishSocialProofCheck'?: (
    params: Exact<{
      sessionID: int,
      rp: RemoteProof,
      lcr: LinkCheckResult
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.displayCryptocurrency'?: (
    params: Exact<{
      sessionID: int,
      c: Cryptocurrency
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.reportTrackToken'?: (
    params: Exact<{
      sessionID: int,
      trackToken: TrackToken
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.displayUserCard'?: (
    params: Exact<{
      sessionID: int,
      card: UserCard
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.confirm'?: (
    params: Exact<{
      sessionID: int,
      outcome: IdentifyOutcome
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: identifyUiConfirmResult) => void,
    }
  ) => void,
  'keybase.1.identifyUi.cancel'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.finish'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.identifyUi.dismiss'?: (
    params: Exact<{
      sessionID: int,
      username: string,
      reason: DismissReason
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.logUi.log'?: (
    params: Exact<{
      sessionID: int,
      level: LogLevel,
      text: Text
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.loginUi.getEmailOrUsername'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: loginUiGetEmailOrUsernameResult) => void,
    }
  ) => void,
  'keybase.1.loginUi.promptRevokePaperKeys'?: (
    params: Exact<{
      sessionID: int,
      device: Device,
      index: int
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: loginUiPromptRevokePaperKeysResult) => void,
    }
  ) => void,
  'keybase.1.loginUi.displayPaperKeyPhrase'?: (
    params: Exact<{
      sessionID: int,
      phrase: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.loginUi.displayPrimaryPaperKey'?: (
    params: Exact<{
      sessionID: int,
      phrase: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.logsend.prepareLogsend'?: (
    params: Exact<{}>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyApp.exit'?: (
    params: Exact<{}>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyBadges.badgeState'?: (
    params: Exact<{
      badgeState: BadgeState
    }> /* ,
    response: {} // Notify call
    */
  ) => void,
  'keybase.1.NotifyFavorites.favoritesChanged'?: (
    params: Exact<{
      uid: UID
    }> /* ,
    response: {} // Notify call
    */
  ) => void,
  'keybase.1.NotifyFS.FSActivity'?: (
    params: Exact<{
      notification: FSNotification
    }> /* ,
    response: {} // Notify call
    */
  ) => void,
  'keybase.1.NotifyFS.FSSyncActivity'?: (
    params: Exact<{
      status: FSPathSyncStatus
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyFS.FSEditListResponse'?: (
    params: Exact<{
      edits?: ?Array<FSNotification>,
      requestID: int
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyFS.FSSyncStatusResponse'?: (
    params: Exact<{
      status: FSSyncStatus,
      requestID: int
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyKeyfamily.keyfamilyChanged'?: (
    params: Exact<{
      uid: UID
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyPaperKey.paperKeyCached'?: (
    params: Exact<{
      uid: UID,
      encKID: KID,
      sigKID: KID
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyPGP.pgpKeyInSecretStoreFile'?: (
    params: Exact<{}>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyService.shutdown'?: (
    params: Exact<{}>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifySession.loggedOut'?: (
    params: Exact<{}> /* ,
    response: {} // Notify call
    */
  ) => void,
  'keybase.1.NotifySession.loggedIn'?: (
    params: Exact<{
      username: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifySession.clientOutOfDate'?: (
    params: Exact<{
      upgradeTo: string,
      upgradeURI: string,
      upgradeMsg: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.NotifyTracking.trackingChanged'?: (
    params: Exact<{
      uid: UID,
      username: string,
      isTracking: boolean
    }> /* ,
    response: {} // Notify call
    */
  ) => void,
  'keybase.1.NotifyUsers.userChanged'?: (
    params: Exact<{
      uid: UID
    }> /* ,
    response: {} // Notify call
    */
  ) => void,
  'keybase.1.pgpUi.outputSignatureSuccess'?: (
    params: Exact<{
      sessionID: int,
      fingerprint: string,
      username: string,
      signedAt: Time
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.pgpUi.outputSignatureSuccessNonKeybase'?: (
    params: Exact<{
      sessionID: int,
      keyID: string,
      signedAt: Time
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.pgpUi.keyGenerated'?: (
    params: Exact<{
      sessionID: int,
      kid: KID,
      key: KeyInfo
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.pgpUi.shouldPushPrivate'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: pgpUiShouldPushPrivateResult) => void,
    }
  ) => void,
  'keybase.1.pgpUi.finished'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.proveUi.promptOverwrite'?: (
    params: Exact<{
      sessionID: int,
      account: string,
      typ: PromptOverwriteType
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: proveUiPromptOverwriteResult) => void,
    }
  ) => void,
  'keybase.1.proveUi.promptUsername'?: (
    params: Exact<{
      sessionID: int,
      prompt: string,
      prevError?: ?Status
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: proveUiPromptUsernameResult) => void,
    }
  ) => void,
  'keybase.1.proveUi.outputPrechecks'?: (
    params: Exact<{
      sessionID: int,
      text: Text
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.proveUi.preProofWarning'?: (
    params: Exact<{
      sessionID: int,
      text: Text
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: proveUiPreProofWarningResult) => void,
    }
  ) => void,
  'keybase.1.proveUi.outputInstructions'?: (
    params: Exact<{
      sessionID: int,
      instructions: Text,
      proof: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.proveUi.okToCheck'?: (
    params: Exact<{
      sessionID: int,
      name: string,
      attempt: int
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: proveUiOkToCheckResult) => void,
    }
  ) => void,
  'keybase.1.proveUi.displayRecheckWarning'?: (
    params: Exact<{
      sessionID: int,
      text: Text
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.provisionUi.chooseProvisioningMethod'?: (
    params: Exact<{
      sessionID: int,
      gpgOption: boolean
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: provisionUiChooseProvisioningMethodResult) => void,
    }
  ) => void,
  'keybase.1.provisionUi.chooseGPGMethod'?: (
    params: Exact<{
      sessionID: int,
      keys?: ?Array<GPGKey>
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: provisionUiChooseGPGMethodResult) => void,
    }
  ) => void,
  'keybase.1.provisionUi.switchToGPGSignOK'?: (
    params: Exact<{
      sessionID: int,
      key: GPGKey,
      importError: string
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: provisionUiSwitchToGPGSignOKResult) => void,
    }
  ) => void,
  'keybase.1.provisionUi.chooseDevice'?: (
    params: Exact<{
      sessionID: int,
      devices?: ?Array<Device>
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: provisionUiChooseDeviceResult) => void,
    }
  ) => void,
  'keybase.1.provisionUi.chooseDeviceType'?: (
    params: Exact<{
      sessionID: int,
      kind: ChooseType
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: provisionUiChooseDeviceTypeResult) => void,
    }
  ) => void,
  'keybase.1.provisionUi.DisplayAndPromptSecret'?: (
    params: Exact<{
      sessionID: int,
      secret: bytes,
      phrase: string,
      otherDeviceType: DeviceType
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: provisionUiDisplayAndPromptSecretResult) => void,
    }
  ) => void,
  'keybase.1.provisionUi.DisplaySecretExchanged'?: (
    params: Exact<{
      sessionID: int
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.provisionUi.PromptNewDeviceName'?: (
    params: Exact<{
      sessionID: int,
      existingDevices?: ?Array<string>,
      errorMessage: string
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: provisionUiPromptNewDeviceNameResult) => void,
    }
  ) => void,
  'keybase.1.provisionUi.ProvisioneeSuccess'?: (
    params: Exact<{
      sessionID: int,
      username: string,
      deviceName: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.provisionUi.ProvisionerSuccess'?: (
    params: Exact<{
      sessionID: int,
      deviceName: string,
      deviceType: string
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.rekeyUI.delegateRekeyUI'?: (
    params: Exact<{}>,
    response: {
      error: RPCErrorHandler,
      result: (result: rekeyUIDelegateRekeyUIResult) => void,
    }
  ) => void,
  'keybase.1.rekeyUI.refresh'?: (
    params: Exact<{
      sessionID: int,
      problemSetDevices: ProblemSetDevices
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.rekeyUI.rekeySendEvent'?: (
    params: Exact<{
      sessionID: int,
      event: RekeyEvent
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.saltpackUi.saltpackPromptForDecrypt'?: (
    params: Exact<{
      sessionID: int,
      sender: SaltpackSender,
      usedDelegateUI: boolean
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.saltpackUi.saltpackVerifySuccess'?: (
    params: Exact<{
      sessionID: int,
      signingKID: KID,
      sender: SaltpackSender
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.saltpackUi.saltpackVerifyBadSender'?: (
    params: Exact<{
      sessionID: int,
      signingKID: KID,
      sender: SaltpackSender
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.secretUi.getPassphrase'?: (
    params: Exact<{
      sessionID: int,
      pinentry: GUIEntryArg,
      terminal?: ?SecretEntryArg
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: secretUiGetPassphraseResult) => void,
    }
  ) => void,
  'keybase.1.streamUi.close'?: (
    params: Exact<{
      sessionID: int,
      s: Stream
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.streamUi.read'?: (
    params: Exact<{
      sessionID: int,
      s: Stream,
      sz: int
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: streamUiReadResult) => void,
    }
  ) => void,
  'keybase.1.streamUi.reset'?: (
    params: Exact<{
      sessionID: int,
      s: Stream
    }>,
    response: CommonResponseHandler
  ) => void,
  'keybase.1.streamUi.write'?: (
    params: Exact<{
      sessionID: int,
      s: Stream,
      buf: bytes
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: streamUiWriteResult) => void,
    }
  ) => void,
  'keybase.1.ui.promptYesNo'?: (
    params: Exact<{
      sessionID: int,
      text: Text,
      promptDefault: PromptDefault
    }>,
    response: {
      error: RPCErrorHandler,
      result: (result: uiPromptYesNoResult) => void,
    }
  ) => void
}>
