gRPC-web codegen TypeScript originals

identity-auth-client.cjs.flow.ts

import * as grpcWeb from 'grpc-web';

import * as identity_auth_pb from './identity_auth_pb';
import * as identity_unauth_pb from './identity_unauth_pb';


export class IdentityClientServiceClient {
  constructor (hostname: string,
               credentials?: null | { [index: string]: string; },
               options?: null | { [index: string]: any; });

  uploadOneTimeKeys(
    request: identity_auth_pb.UploadOneTimeKeysRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

  refreshUserPrekeys(
    request: identity_auth_pb.RefreshUserPrekeysRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

  getOutboundKeysForUser(
    request: identity_auth_pb.OutboundKeysForUserRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_auth_pb.OutboundKeysForUserResponse) => void
  ): grpcWeb.ClientReadableStream<identity_auth_pb.OutboundKeysForUserResponse>;

  getInboundKeysForUser(
    request: identity_auth_pb.InboundKeysForUserRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_auth_pb.InboundKeysForUserResponse) => void
  ): grpcWeb.ClientReadableStream<identity_auth_pb.InboundKeysForUserResponse>;

  updateUserPasswordStart(
    request: identity_auth_pb.UpdateUserPasswordStartRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_auth_pb.UpdateUserPasswordStartResponse) => void
  ): grpcWeb.ClientReadableStream<identity_auth_pb.UpdateUserPasswordStartResponse>;

  updateUserPasswordFinish(
    request: identity_auth_pb.UpdateUserPasswordFinishRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

  logOutUser(
    request: identity_unauth_pb.Empty,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

  deleteUser(
    request: identity_unauth_pb.Empty,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

  getKeyserverKeys(
    request: identity_auth_pb.OutboundKeysForUserRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_auth_pb.KeyserverKeysResponse) => void
  ): grpcWeb.ClientReadableStream<identity_auth_pb.KeyserverKeysResponse>;

  findUserID(
    request: identity_auth_pb.FindUserIDRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_auth_pb.FindUserIDResponse) => void
  ): grpcWeb.ClientReadableStream<identity_auth_pb.FindUserIDResponse>;

  getDeviceListForUser(
    request: identity_auth_pb.GetDeviceListRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_auth_pb.GetDeviceListResponse) => void
  ): grpcWeb.ClientReadableStream<identity_auth_pb.GetDeviceListResponse>;

}

export class IdentityClientServicePromiseClient {
  constructor (hostname: string,
               credentials?: null | { [index: string]: string; },
               options?: null | { [index: string]: any; });

  uploadOneTimeKeys(
    request: identity_auth_pb.UploadOneTimeKeysRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

  refreshUserPrekeys(
    request: identity_auth_pb.RefreshUserPrekeysRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

  getOutboundKeysForUser(
    request: identity_auth_pb.OutboundKeysForUserRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_auth_pb.OutboundKeysForUserResponse>;

  getInboundKeysForUser(
    request: identity_auth_pb.InboundKeysForUserRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_auth_pb.InboundKeysForUserResponse>;

  updateUserPasswordStart(
    request: identity_auth_pb.UpdateUserPasswordStartRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_auth_pb.UpdateUserPasswordStartResponse>;

  updateUserPasswordFinish(
    request: identity_auth_pb.UpdateUserPasswordFinishRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

  logOutUser(
    request: identity_unauth_pb.Empty,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

  deleteUser(
    request: identity_unauth_pb.Empty,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

  getKeyserverKeys(
    request: identity_auth_pb.OutboundKeysForUserRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_auth_pb.KeyserverKeysResponse>;

  findUserID(
    request: identity_auth_pb.FindUserIDRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_auth_pb.FindUserIDResponse>;

  getDeviceListForUser(
    request: identity_auth_pb.GetDeviceListRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_auth_pb.GetDeviceListResponse>;

}

identity-auth-structs.cjs.flow.ts

import * as jspb from 'google-protobuf'

import * as identity_unauth_pb from './identity_unauth_pb';


export class UploadOneTimeKeysRequest extends jspb.Message {
  getContentOneTimePrekeysList(): Array<string>;
  setContentOneTimePrekeysList(value: Array<string>): UploadOneTimeKeysRequest;
  clearContentOneTimePrekeysList(): UploadOneTimeKeysRequest;
  addContentOneTimePrekeys(value: string, index?: number): UploadOneTimeKeysRequest;

  getNotifOneTimePrekeysList(): Array<string>;
  setNotifOneTimePrekeysList(value: Array<string>): UploadOneTimeKeysRequest;
  clearNotifOneTimePrekeysList(): UploadOneTimeKeysRequest;
  addNotifOneTimePrekeys(value: string, index?: number): UploadOneTimeKeysRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UploadOneTimeKeysRequest.AsObject;
  static toObject(includeInstance: boolean, msg: UploadOneTimeKeysRequest): UploadOneTimeKeysRequest.AsObject;
  static serializeBinaryToWriter(message: UploadOneTimeKeysRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UploadOneTimeKeysRequest;
  static deserializeBinaryFromReader(message: UploadOneTimeKeysRequest, reader: jspb.BinaryReader): UploadOneTimeKeysRequest;
}

export namespace UploadOneTimeKeysRequest {
  export type AsObject = {
    contentOneTimePrekeysList: Array<string>,
    notifOneTimePrekeysList: Array<string>,
  }
}

export class RefreshUserPrekeysRequest extends jspb.Message {
  getNewContentPrekeys(): identity_unauth_pb.Prekey | undefined;
  setNewContentPrekeys(value?: identity_unauth_pb.Prekey): RefreshUserPrekeysRequest;
  hasNewContentPrekeys(): boolean;
  clearNewContentPrekeys(): RefreshUserPrekeysRequest;

  getNewNotifPrekeys(): identity_unauth_pb.Prekey | undefined;
  setNewNotifPrekeys(value?: identity_unauth_pb.Prekey): RefreshUserPrekeysRequest;
  hasNewNotifPrekeys(): boolean;
  clearNewNotifPrekeys(): RefreshUserPrekeysRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RefreshUserPrekeysRequest.AsObject;
  static toObject(includeInstance: boolean, msg: RefreshUserPrekeysRequest): RefreshUserPrekeysRequest.AsObject;
  static serializeBinaryToWriter(message: RefreshUserPrekeysRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RefreshUserPrekeysRequest;
  static deserializeBinaryFromReader(message: RefreshUserPrekeysRequest, reader: jspb.BinaryReader): RefreshUserPrekeysRequest;
}

export namespace RefreshUserPrekeysRequest {
  export type AsObject = {
    newContentPrekeys?: identity_unauth_pb.Prekey.AsObject,
    newNotifPrekeys?: identity_unauth_pb.Prekey.AsObject,
  }
}

export class OutboundKeyInfo extends jspb.Message {
  getIdentityInfo(): identity_unauth_pb.IdentityKeyInfo | undefined;
  setIdentityInfo(value?: identity_unauth_pb.IdentityKeyInfo): OutboundKeyInfo;
  hasIdentityInfo(): boolean;
  clearIdentityInfo(): OutboundKeyInfo;

  getContentPrekey(): identity_unauth_pb.Prekey | undefined;
  setContentPrekey(value?: identity_unauth_pb.Prekey): OutboundKeyInfo;
  hasContentPrekey(): boolean;
  clearContentPrekey(): OutboundKeyInfo;

  getNotifPrekey(): identity_unauth_pb.Prekey | undefined;
  setNotifPrekey(value?: identity_unauth_pb.Prekey): OutboundKeyInfo;
  hasNotifPrekey(): boolean;
  clearNotifPrekey(): OutboundKeyInfo;

  getOneTimeContentPrekey(): string;
  setOneTimeContentPrekey(value: string): OutboundKeyInfo;
  hasOneTimeContentPrekey(): boolean;
  clearOneTimeContentPrekey(): OutboundKeyInfo;

  getOneTimeNotifPrekey(): string;
  setOneTimeNotifPrekey(value: string): OutboundKeyInfo;
  hasOneTimeNotifPrekey(): boolean;
  clearOneTimeNotifPrekey(): OutboundKeyInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OutboundKeyInfo.AsObject;
  static toObject(includeInstance: boolean, msg: OutboundKeyInfo): OutboundKeyInfo.AsObject;
  static serializeBinaryToWriter(message: OutboundKeyInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OutboundKeyInfo;
  static deserializeBinaryFromReader(message: OutboundKeyInfo, reader: jspb.BinaryReader): OutboundKeyInfo;
}

export namespace OutboundKeyInfo {
  export type AsObject = {
    identityInfo?: identity_unauth_pb.IdentityKeyInfo.AsObject,
    contentPrekey?: identity_unauth_pb.Prekey.AsObject,
    notifPrekey?: identity_unauth_pb.Prekey.AsObject,
    oneTimeContentPrekey?: string,
    oneTimeNotifPrekey?: string,
  }

  export enum OneTimeContentPrekeyCase { 
    _ONE_TIME_CONTENT_PREKEY_NOT_SET = 0,
    ONE_TIME_CONTENT_PREKEY = 4,
  }

  export enum OneTimeNotifPrekeyCase { 
    _ONE_TIME_NOTIF_PREKEY_NOT_SET = 0,
    ONE_TIME_NOTIF_PREKEY = 5,
  }
}

export class KeyserverKeysResponse extends jspb.Message {
  getKeyserverInfo(): OutboundKeyInfo | undefined;
  setKeyserverInfo(value?: OutboundKeyInfo): KeyserverKeysResponse;
  hasKeyserverInfo(): boolean;
  clearKeyserverInfo(): KeyserverKeysResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): KeyserverKeysResponse.AsObject;
  static toObject(includeInstance: boolean, msg: KeyserverKeysResponse): KeyserverKeysResponse.AsObject;
  static serializeBinaryToWriter(message: KeyserverKeysResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): KeyserverKeysResponse;
  static deserializeBinaryFromReader(message: KeyserverKeysResponse, reader: jspb.BinaryReader): KeyserverKeysResponse;
}

export namespace KeyserverKeysResponse {
  export type AsObject = {
    keyserverInfo?: OutboundKeyInfo.AsObject,
  }

  export enum KeyserverInfoCase { 
    _KEYSERVER_INFO_NOT_SET = 0,
    KEYSERVER_INFO = 1,
  }
}

export class OutboundKeysForUserResponse extends jspb.Message {
  getDevicesMap(): jspb.Map<string, OutboundKeyInfo>;
  clearDevicesMap(): OutboundKeysForUserResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OutboundKeysForUserResponse.AsObject;
  static toObject(includeInstance: boolean, msg: OutboundKeysForUserResponse): OutboundKeysForUserResponse.AsObject;
  static serializeBinaryToWriter(message: OutboundKeysForUserResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OutboundKeysForUserResponse;
  static deserializeBinaryFromReader(message: OutboundKeysForUserResponse, reader: jspb.BinaryReader): OutboundKeysForUserResponse;
}

export namespace OutboundKeysForUserResponse {
  export type AsObject = {
    devicesMap: Array<[string, OutboundKeyInfo.AsObject]>,
  }
}

export class OutboundKeysForUserRequest extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): OutboundKeysForUserRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OutboundKeysForUserRequest.AsObject;
  static toObject(includeInstance: boolean, msg: OutboundKeysForUserRequest): OutboundKeysForUserRequest.AsObject;
  static serializeBinaryToWriter(message: OutboundKeysForUserRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OutboundKeysForUserRequest;
  static deserializeBinaryFromReader(message: OutboundKeysForUserRequest, reader: jspb.BinaryReader): OutboundKeysForUserRequest;
}

export namespace OutboundKeysForUserRequest {
  export type AsObject = {
    userId: string,
  }
}

export class InboundKeyInfo extends jspb.Message {
  getIdentityInfo(): identity_unauth_pb.IdentityKeyInfo | undefined;
  setIdentityInfo(value?: identity_unauth_pb.IdentityKeyInfo): InboundKeyInfo;
  hasIdentityInfo(): boolean;
  clearIdentityInfo(): InboundKeyInfo;

  getContentPrekey(): identity_unauth_pb.Prekey | undefined;
  setContentPrekey(value?: identity_unauth_pb.Prekey): InboundKeyInfo;
  hasContentPrekey(): boolean;
  clearContentPrekey(): InboundKeyInfo;

  getNotifPrekey(): identity_unauth_pb.Prekey | undefined;
  setNotifPrekey(value?: identity_unauth_pb.Prekey): InboundKeyInfo;
  hasNotifPrekey(): boolean;
  clearNotifPrekey(): InboundKeyInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InboundKeyInfo.AsObject;
  static toObject(includeInstance: boolean, msg: InboundKeyInfo): InboundKeyInfo.AsObject;
  static serializeBinaryToWriter(message: InboundKeyInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InboundKeyInfo;
  static deserializeBinaryFromReader(message: InboundKeyInfo, reader: jspb.BinaryReader): InboundKeyInfo;
}

export namespace InboundKeyInfo {
  export type AsObject = {
    identityInfo?: identity_unauth_pb.IdentityKeyInfo.AsObject,
    contentPrekey?: identity_unauth_pb.Prekey.AsObject,
    notifPrekey?: identity_unauth_pb.Prekey.AsObject,
  }
}

export class InboundKeysForUserResponse extends jspb.Message {
  getDevicesMap(): jspb.Map<string, InboundKeyInfo>;
  clearDevicesMap(): InboundKeysForUserResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InboundKeysForUserResponse.AsObject;
  static toObject(includeInstance: boolean, msg: InboundKeysForUserResponse): InboundKeysForUserResponse.AsObject;
  static serializeBinaryToWriter(message: InboundKeysForUserResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InboundKeysForUserResponse;
  static deserializeBinaryFromReader(message: InboundKeysForUserResponse, reader: jspb.BinaryReader): InboundKeysForUserResponse;
}

export namespace InboundKeysForUserResponse {
  export type AsObject = {
    devicesMap: Array<[string, InboundKeyInfo.AsObject]>,
  }
}

export class InboundKeysForUserRequest extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): InboundKeysForUserRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InboundKeysForUserRequest.AsObject;
  static toObject(includeInstance: boolean, msg: InboundKeysForUserRequest): InboundKeysForUserRequest.AsObject;
  static serializeBinaryToWriter(message: InboundKeysForUserRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InboundKeysForUserRequest;
  static deserializeBinaryFromReader(message: InboundKeysForUserRequest, reader: jspb.BinaryReader): InboundKeysForUserRequest;
}

export namespace InboundKeysForUserRequest {
  export type AsObject = {
    userId: string,
  }
}

export class FindUserIDRequest extends jspb.Message {
  getUsername(): string;
  setUsername(value: string): FindUserIDRequest;

  getWalletAddress(): string;
  setWalletAddress(value: string): FindUserIDRequest;

  getIdentifierCase(): FindUserIDRequest.IdentifierCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FindUserIDRequest.AsObject;
  static toObject(includeInstance: boolean, msg: FindUserIDRequest): FindUserIDRequest.AsObject;
  static serializeBinaryToWriter(message: FindUserIDRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FindUserIDRequest;
  static deserializeBinaryFromReader(message: FindUserIDRequest, reader: jspb.BinaryReader): FindUserIDRequest;
}

export namespace FindUserIDRequest {
  export type AsObject = {
    username: string,
    walletAddress: string,
  }

  export enum IdentifierCase { 
    IDENTIFIER_NOT_SET = 0,
    USERNAME = 1,
    WALLET_ADDRESS = 2,
  }
}

export class FindUserIDResponse extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): FindUserIDResponse;
  hasUserId(): boolean;
  clearUserId(): FindUserIDResponse;

  getIsReserved(): boolean;
  setIsReserved(value: boolean): FindUserIDResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FindUserIDResponse.AsObject;
  static toObject(includeInstance: boolean, msg: FindUserIDResponse): FindUserIDResponse.AsObject;
  static serializeBinaryToWriter(message: FindUserIDResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FindUserIDResponse;
  static deserializeBinaryFromReader(message: FindUserIDResponse, reader: jspb.BinaryReader): FindUserIDResponse;
}

export namespace FindUserIDResponse {
  export type AsObject = {
    userId?: string,
    isReserved: boolean,
  }

  export enum UserIdCase { 
    _USER_ID_NOT_SET = 0,
    USER_ID = 1,
  }
}

export class UpdateUserPasswordStartRequest extends jspb.Message {
  getOpaqueRegistrationRequest(): Uint8Array | string;
  getOpaqueRegistrationRequest_asU8(): Uint8Array;
  getOpaqueRegistrationRequest_asB64(): string;
  setOpaqueRegistrationRequest(value: Uint8Array | string): UpdateUserPasswordStartRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UpdateUserPasswordStartRequest.AsObject;
  static toObject(includeInstance: boolean, msg: UpdateUserPasswordStartRequest): UpdateUserPasswordStartRequest.AsObject;
  static serializeBinaryToWriter(message: UpdateUserPasswordStartRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UpdateUserPasswordStartRequest;
  static deserializeBinaryFromReader(message: UpdateUserPasswordStartRequest, reader: jspb.BinaryReader): UpdateUserPasswordStartRequest;
}

export namespace UpdateUserPasswordStartRequest {
  export type AsObject = {
    opaqueRegistrationRequest: Uint8Array | string,
  }
}

export class UpdateUserPasswordFinishRequest extends jspb.Message {
  getSessionId(): string;
  setSessionId(value: string): UpdateUserPasswordFinishRequest;

  getOpaqueRegistrationUpload(): Uint8Array | string;
  getOpaqueRegistrationUpload_asU8(): Uint8Array;
  getOpaqueRegistrationUpload_asB64(): string;
  setOpaqueRegistrationUpload(value: Uint8Array | string): UpdateUserPasswordFinishRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UpdateUserPasswordFinishRequest.AsObject;
  static toObject(includeInstance: boolean, msg: UpdateUserPasswordFinishRequest): UpdateUserPasswordFinishRequest.AsObject;
  static serializeBinaryToWriter(message: UpdateUserPasswordFinishRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UpdateUserPasswordFinishRequest;
  static deserializeBinaryFromReader(message: UpdateUserPasswordFinishRequest, reader: jspb.BinaryReader): UpdateUserPasswordFinishRequest;
}

export namespace UpdateUserPasswordFinishRequest {
  export type AsObject = {
    sessionId: string,
    opaqueRegistrationUpload: Uint8Array | string,
  }
}

export class UpdateUserPasswordStartResponse extends jspb.Message {
  getSessionId(): string;
  setSessionId(value: string): UpdateUserPasswordStartResponse;

  getOpaqueRegistrationResponse(): Uint8Array | string;
  getOpaqueRegistrationResponse_asU8(): Uint8Array;
  getOpaqueRegistrationResponse_asB64(): string;
  setOpaqueRegistrationResponse(value: Uint8Array | string): UpdateUserPasswordStartResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UpdateUserPasswordStartResponse.AsObject;
  static toObject(includeInstance: boolean, msg: UpdateUserPasswordStartResponse): UpdateUserPasswordStartResponse.AsObject;
  static serializeBinaryToWriter(message: UpdateUserPasswordStartResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UpdateUserPasswordStartResponse;
  static deserializeBinaryFromReader(message: UpdateUserPasswordStartResponse, reader: jspb.BinaryReader): UpdateUserPasswordStartResponse;
}

export namespace UpdateUserPasswordStartResponse {
  export type AsObject = {
    sessionId: string,
    opaqueRegistrationResponse: Uint8Array | string,
  }
}

export class GetDeviceListRequest extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): GetDeviceListRequest;

  getSinceTimestamp(): number;
  setSinceTimestamp(value: number): GetDeviceListRequest;
  hasSinceTimestamp(): boolean;
  clearSinceTimestamp(): GetDeviceListRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetDeviceListRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetDeviceListRequest): GetDeviceListRequest.AsObject;
  static serializeBinaryToWriter(message: GetDeviceListRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetDeviceListRequest;
  static deserializeBinaryFromReader(message: GetDeviceListRequest, reader: jspb.BinaryReader): GetDeviceListRequest;
}

export namespace GetDeviceListRequest {
  export type AsObject = {
    userId: string,
    sinceTimestamp?: number,
  }

  export enum SinceTimestampCase { 
    _SINCE_TIMESTAMP_NOT_SET = 0,
    SINCE_TIMESTAMP = 2,
  }
}

export class GetDeviceListResponse extends jspb.Message {
  getDeviceListUpdatesList(): Array<string>;
  setDeviceListUpdatesList(value: Array<string>): GetDeviceListResponse;
  clearDeviceListUpdatesList(): GetDeviceListResponse;
  addDeviceListUpdates(value: string, index?: number): GetDeviceListResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetDeviceListResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GetDeviceListResponse): GetDeviceListResponse.AsObject;
  static serializeBinaryToWriter(message: GetDeviceListResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetDeviceListResponse;
  static deserializeBinaryFromReader(message: GetDeviceListResponse, reader: jspb.BinaryReader): GetDeviceListResponse;
}

export namespace GetDeviceListResponse {
  export type AsObject = {
    deviceListUpdatesList: Array<string>,
  }
}

identity-unauth-structs.cjs.flow.ts

import * as jspb from 'google-protobuf'



export class Empty extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Empty.AsObject;
  static toObject(includeInstance: boolean, msg: Empty): Empty.AsObject;
  static serializeBinaryToWriter(message: Empty, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Empty;
  static deserializeBinaryFromReader(message: Empty, reader: jspb.BinaryReader): Empty;
}

export namespace Empty {
  export type AsObject = {
  }
}

export class Prekey extends jspb.Message {
  getPrekey(): string;
  setPrekey(value: string): Prekey;

  getPrekeySignature(): string;
  setPrekeySignature(value: string): Prekey;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Prekey.AsObject;
  static toObject(includeInstance: boolean, msg: Prekey): Prekey.AsObject;
  static serializeBinaryToWriter(message: Prekey, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Prekey;
  static deserializeBinaryFromReader(message: Prekey, reader: jspb.BinaryReader): Prekey;
}

export namespace Prekey {
  export type AsObject = {
    prekey: string,
    prekeySignature: string,
  }
}

export class IdentityKeyInfo extends jspb.Message {
  getPayload(): string;
  setPayload(value: string): IdentityKeyInfo;

  getPayloadSignature(): string;
  setPayloadSignature(value: string): IdentityKeyInfo;

  getSocialProof(): string;
  setSocialProof(value: string): IdentityKeyInfo;
  hasSocialProof(): boolean;
  clearSocialProof(): IdentityKeyInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): IdentityKeyInfo.AsObject;
  static toObject(includeInstance: boolean, msg: IdentityKeyInfo): IdentityKeyInfo.AsObject;
  static serializeBinaryToWriter(message: IdentityKeyInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): IdentityKeyInfo;
  static deserializeBinaryFromReader(message: IdentityKeyInfo, reader: jspb.BinaryReader): IdentityKeyInfo;
}

export namespace IdentityKeyInfo {
  export type AsObject = {
    payload: string,
    payloadSignature: string,
    socialProof?: string,
  }

  export enum SocialProofCase { 
    _SOCIAL_PROOF_NOT_SET = 0,
    SOCIAL_PROOF = 3,
  }
}

export class DeviceKeyUpload extends jspb.Message {
  getDeviceKeyInfo(): IdentityKeyInfo | undefined;
  setDeviceKeyInfo(value?: IdentityKeyInfo): DeviceKeyUpload;
  hasDeviceKeyInfo(): boolean;
  clearDeviceKeyInfo(): DeviceKeyUpload;

  getContentUpload(): Prekey | undefined;
  setContentUpload(value?: Prekey): DeviceKeyUpload;
  hasContentUpload(): boolean;
  clearContentUpload(): DeviceKeyUpload;

  getNotifUpload(): Prekey | undefined;
  setNotifUpload(value?: Prekey): DeviceKeyUpload;
  hasNotifUpload(): boolean;
  clearNotifUpload(): DeviceKeyUpload;

  getOneTimeContentPrekeysList(): Array<string>;
  setOneTimeContentPrekeysList(value: Array<string>): DeviceKeyUpload;
  clearOneTimeContentPrekeysList(): DeviceKeyUpload;
  addOneTimeContentPrekeys(value: string, index?: number): DeviceKeyUpload;

  getOneTimeNotifPrekeysList(): Array<string>;
  setOneTimeNotifPrekeysList(value: Array<string>): DeviceKeyUpload;
  clearOneTimeNotifPrekeysList(): DeviceKeyUpload;
  addOneTimeNotifPrekeys(value: string, index?: number): DeviceKeyUpload;

  getDeviceType(): DeviceType;
  setDeviceType(value: DeviceType): DeviceKeyUpload;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeviceKeyUpload.AsObject;
  static toObject(includeInstance: boolean, msg: DeviceKeyUpload): DeviceKeyUpload.AsObject;
  static serializeBinaryToWriter(message: DeviceKeyUpload, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeviceKeyUpload;
  static deserializeBinaryFromReader(message: DeviceKeyUpload, reader: jspb.BinaryReader): DeviceKeyUpload;
}

export namespace DeviceKeyUpload {
  export type AsObject = {
    deviceKeyInfo?: IdentityKeyInfo.AsObject,
    contentUpload?: Prekey.AsObject,
    notifUpload?: Prekey.AsObject,
    oneTimeContentPrekeysList: Array<string>,
    oneTimeNotifPrekeysList: Array<string>,
    deviceType: DeviceType,
  }
}

export class RegistrationStartRequest extends jspb.Message {
  getOpaqueRegistrationRequest(): Uint8Array | string;
  getOpaqueRegistrationRequest_asU8(): Uint8Array;
  getOpaqueRegistrationRequest_asB64(): string;
  setOpaqueRegistrationRequest(value: Uint8Array | string): RegistrationStartRequest;

  getUsername(): string;
  setUsername(value: string): RegistrationStartRequest;

  getDeviceKeyUpload(): DeviceKeyUpload | undefined;
  setDeviceKeyUpload(value?: DeviceKeyUpload): RegistrationStartRequest;
  hasDeviceKeyUpload(): boolean;
  clearDeviceKeyUpload(): RegistrationStartRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RegistrationStartRequest.AsObject;
  static toObject(includeInstance: boolean, msg: RegistrationStartRequest): RegistrationStartRequest.AsObject;
  static serializeBinaryToWriter(message: RegistrationStartRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RegistrationStartRequest;
  static deserializeBinaryFromReader(message: RegistrationStartRequest, reader: jspb.BinaryReader): RegistrationStartRequest;
}

export namespace RegistrationStartRequest {
  export type AsObject = {
    opaqueRegistrationRequest: Uint8Array | string,
    username: string,
    deviceKeyUpload?: DeviceKeyUpload.AsObject,
  }
}

export class ReservedRegistrationStartRequest extends jspb.Message {
  getOpaqueRegistrationRequest(): Uint8Array | string;
  getOpaqueRegistrationRequest_asU8(): Uint8Array;
  getOpaqueRegistrationRequest_asB64(): string;
  setOpaqueRegistrationRequest(value: Uint8Array | string): ReservedRegistrationStartRequest;

  getUsername(): string;
  setUsername(value: string): ReservedRegistrationStartRequest;

  getDeviceKeyUpload(): DeviceKeyUpload | undefined;
  setDeviceKeyUpload(value?: DeviceKeyUpload): ReservedRegistrationStartRequest;
  hasDeviceKeyUpload(): boolean;
  clearDeviceKeyUpload(): ReservedRegistrationStartRequest;

  getKeyserverMessage(): string;
  setKeyserverMessage(value: string): ReservedRegistrationStartRequest;

  getKeyserverSignature(): string;
  setKeyserverSignature(value: string): ReservedRegistrationStartRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ReservedRegistrationStartRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ReservedRegistrationStartRequest): ReservedRegistrationStartRequest.AsObject;
  static serializeBinaryToWriter(message: ReservedRegistrationStartRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ReservedRegistrationStartRequest;
  static deserializeBinaryFromReader(message: ReservedRegistrationStartRequest, reader: jspb.BinaryReader): ReservedRegistrationStartRequest;
}

export namespace ReservedRegistrationStartRequest {
  export type AsObject = {
    opaqueRegistrationRequest: Uint8Array | string,
    username: string,
    deviceKeyUpload?: DeviceKeyUpload.AsObject,
    keyserverMessage: string,
    keyserverSignature: string,
  }
}

export class RegistrationFinishRequest extends jspb.Message {
  getSessionId(): string;
  setSessionId(value: string): RegistrationFinishRequest;

  getOpaqueRegistrationUpload(): Uint8Array | string;
  getOpaqueRegistrationUpload_asU8(): Uint8Array;
  getOpaqueRegistrationUpload_asB64(): string;
  setOpaqueRegistrationUpload(value: Uint8Array | string): RegistrationFinishRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RegistrationFinishRequest.AsObject;
  static toObject(includeInstance: boolean, msg: RegistrationFinishRequest): RegistrationFinishRequest.AsObject;
  static serializeBinaryToWriter(message: RegistrationFinishRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RegistrationFinishRequest;
  static deserializeBinaryFromReader(message: RegistrationFinishRequest, reader: jspb.BinaryReader): RegistrationFinishRequest;
}

export namespace RegistrationFinishRequest {
  export type AsObject = {
    sessionId: string,
    opaqueRegistrationUpload: Uint8Array | string,
  }
}

export class RegistrationStartResponse extends jspb.Message {
  getSessionId(): string;
  setSessionId(value: string): RegistrationStartResponse;

  getOpaqueRegistrationResponse(): Uint8Array | string;
  getOpaqueRegistrationResponse_asU8(): Uint8Array;
  getOpaqueRegistrationResponse_asB64(): string;
  setOpaqueRegistrationResponse(value: Uint8Array | string): RegistrationStartResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RegistrationStartResponse.AsObject;
  static toObject(includeInstance: boolean, msg: RegistrationStartResponse): RegistrationStartResponse.AsObject;
  static serializeBinaryToWriter(message: RegistrationStartResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RegistrationStartResponse;
  static deserializeBinaryFromReader(message: RegistrationStartResponse, reader: jspb.BinaryReader): RegistrationStartResponse;
}

export namespace RegistrationStartResponse {
  export type AsObject = {
    sessionId: string,
    opaqueRegistrationResponse: Uint8Array | string,
  }
}

export class RegistrationFinishResponse extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): RegistrationFinishResponse;

  getAccessToken(): string;
  setAccessToken(value: string): RegistrationFinishResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RegistrationFinishResponse.AsObject;
  static toObject(includeInstance: boolean, msg: RegistrationFinishResponse): RegistrationFinishResponse.AsObject;
  static serializeBinaryToWriter(message: RegistrationFinishResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RegistrationFinishResponse;
  static deserializeBinaryFromReader(message: RegistrationFinishResponse, reader: jspb.BinaryReader): RegistrationFinishResponse;
}

export namespace RegistrationFinishResponse {
  export type AsObject = {
    userId: string,
    accessToken: string,
  }
}

export class OpaqueLoginStartRequest extends jspb.Message {
  getUsername(): string;
  setUsername(value: string): OpaqueLoginStartRequest;

  getOpaqueLoginRequest(): Uint8Array | string;
  getOpaqueLoginRequest_asU8(): Uint8Array;
  getOpaqueLoginRequest_asB64(): string;
  setOpaqueLoginRequest(value: Uint8Array | string): OpaqueLoginStartRequest;

  getDeviceKeyUpload(): DeviceKeyUpload | undefined;
  setDeviceKeyUpload(value?: DeviceKeyUpload): OpaqueLoginStartRequest;
  hasDeviceKeyUpload(): boolean;
  clearDeviceKeyUpload(): OpaqueLoginStartRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OpaqueLoginStartRequest.AsObject;
  static toObject(includeInstance: boolean, msg: OpaqueLoginStartRequest): OpaqueLoginStartRequest.AsObject;
  static serializeBinaryToWriter(message: OpaqueLoginStartRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OpaqueLoginStartRequest;
  static deserializeBinaryFromReader(message: OpaqueLoginStartRequest, reader: jspb.BinaryReader): OpaqueLoginStartRequest;
}

export namespace OpaqueLoginStartRequest {
  export type AsObject = {
    username: string,
    opaqueLoginRequest: Uint8Array | string,
    deviceKeyUpload?: DeviceKeyUpload.AsObject,
  }
}

export class OpaqueLoginFinishRequest extends jspb.Message {
  getSessionId(): string;
  setSessionId(value: string): OpaqueLoginFinishRequest;

  getOpaqueLoginUpload(): Uint8Array | string;
  getOpaqueLoginUpload_asU8(): Uint8Array;
  getOpaqueLoginUpload_asB64(): string;
  setOpaqueLoginUpload(value: Uint8Array | string): OpaqueLoginFinishRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OpaqueLoginFinishRequest.AsObject;
  static toObject(includeInstance: boolean, msg: OpaqueLoginFinishRequest): OpaqueLoginFinishRequest.AsObject;
  static serializeBinaryToWriter(message: OpaqueLoginFinishRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OpaqueLoginFinishRequest;
  static deserializeBinaryFromReader(message: OpaqueLoginFinishRequest, reader: jspb.BinaryReader): OpaqueLoginFinishRequest;
}

export namespace OpaqueLoginFinishRequest {
  export type AsObject = {
    sessionId: string,
    opaqueLoginUpload: Uint8Array | string,
  }
}

export class OpaqueLoginStartResponse extends jspb.Message {
  getSessionId(): string;
  setSessionId(value: string): OpaqueLoginStartResponse;

  getOpaqueLoginResponse(): Uint8Array | string;
  getOpaqueLoginResponse_asU8(): Uint8Array;
  getOpaqueLoginResponse_asB64(): string;
  setOpaqueLoginResponse(value: Uint8Array | string): OpaqueLoginStartResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OpaqueLoginStartResponse.AsObject;
  static toObject(includeInstance: boolean, msg: OpaqueLoginStartResponse): OpaqueLoginStartResponse.AsObject;
  static serializeBinaryToWriter(message: OpaqueLoginStartResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OpaqueLoginStartResponse;
  static deserializeBinaryFromReader(message: OpaqueLoginStartResponse, reader: jspb.BinaryReader): OpaqueLoginStartResponse;
}

export namespace OpaqueLoginStartResponse {
  export type AsObject = {
    sessionId: string,
    opaqueLoginResponse: Uint8Array | string,
  }
}

export class OpaqueLoginFinishResponse extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): OpaqueLoginFinishResponse;

  getAccessToken(): string;
  setAccessToken(value: string): OpaqueLoginFinishResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OpaqueLoginFinishResponse.AsObject;
  static toObject(includeInstance: boolean, msg: OpaqueLoginFinishResponse): OpaqueLoginFinishResponse.AsObject;
  static serializeBinaryToWriter(message: OpaqueLoginFinishResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OpaqueLoginFinishResponse;
  static deserializeBinaryFromReader(message: OpaqueLoginFinishResponse, reader: jspb.BinaryReader): OpaqueLoginFinishResponse;
}

export namespace OpaqueLoginFinishResponse {
  export type AsObject = {
    userId: string,
    accessToken: string,
  }
}

export class WalletLoginRequest extends jspb.Message {
  getSiweMessage(): string;
  setSiweMessage(value: string): WalletLoginRequest;

  getSiweSignature(): string;
  setSiweSignature(value: string): WalletLoginRequest;

  getDeviceKeyUpload(): DeviceKeyUpload | undefined;
  setDeviceKeyUpload(value?: DeviceKeyUpload): WalletLoginRequest;
  hasDeviceKeyUpload(): boolean;
  clearDeviceKeyUpload(): WalletLoginRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): WalletLoginRequest.AsObject;
  static toObject(includeInstance: boolean, msg: WalletLoginRequest): WalletLoginRequest.AsObject;
  static serializeBinaryToWriter(message: WalletLoginRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): WalletLoginRequest;
  static deserializeBinaryFromReader(message: WalletLoginRequest, reader: jspb.BinaryReader): WalletLoginRequest;
}

export namespace WalletLoginRequest {
  export type AsObject = {
    siweMessage: string,
    siweSignature: string,
    deviceKeyUpload?: DeviceKeyUpload.AsObject,
  }
}

export class ReservedWalletLoginRequest extends jspb.Message {
  getSiweMessage(): string;
  setSiweMessage(value: string): ReservedWalletLoginRequest;

  getSiweSignature(): string;
  setSiweSignature(value: string): ReservedWalletLoginRequest;

  getDeviceKeyUpload(): DeviceKeyUpload | undefined;
  setDeviceKeyUpload(value?: DeviceKeyUpload): ReservedWalletLoginRequest;
  hasDeviceKeyUpload(): boolean;
  clearDeviceKeyUpload(): ReservedWalletLoginRequest;

  getKeyserverMessage(): string;
  setKeyserverMessage(value: string): ReservedWalletLoginRequest;

  getKeyserverSignature(): string;
  setKeyserverSignature(value: string): ReservedWalletLoginRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ReservedWalletLoginRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ReservedWalletLoginRequest): ReservedWalletLoginRequest.AsObject;
  static serializeBinaryToWriter(message: ReservedWalletLoginRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ReservedWalletLoginRequest;
  static deserializeBinaryFromReader(message: ReservedWalletLoginRequest, reader: jspb.BinaryReader): ReservedWalletLoginRequest;
}

export namespace ReservedWalletLoginRequest {
  export type AsObject = {
    siweMessage: string,
    siweSignature: string,
    deviceKeyUpload?: DeviceKeyUpload.AsObject,
    keyserverMessage: string,
    keyserverSignature: string,
  }
}

export class WalletLoginResponse extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): WalletLoginResponse;

  getAccessToken(): string;
  setAccessToken(value: string): WalletLoginResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): WalletLoginResponse.AsObject;
  static toObject(includeInstance: boolean, msg: WalletLoginResponse): WalletLoginResponse.AsObject;
  static serializeBinaryToWriter(message: WalletLoginResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): WalletLoginResponse;
  static deserializeBinaryFromReader(message: WalletLoginResponse, reader: jspb.BinaryReader): WalletLoginResponse;
}

export namespace WalletLoginResponse {
  export type AsObject = {
    userId: string,
    accessToken: string,
  }
}

export class GenerateNonceResponse extends jspb.Message {
  getNonce(): string;
  setNonce(value: string): GenerateNonceResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GenerateNonceResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GenerateNonceResponse): GenerateNonceResponse.AsObject;
  static serializeBinaryToWriter(message: GenerateNonceResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GenerateNonceResponse;
  static deserializeBinaryFromReader(message: GenerateNonceResponse, reader: jspb.BinaryReader): GenerateNonceResponse;
}

export namespace GenerateNonceResponse {
  export type AsObject = {
    nonce: string,
  }
}

export class VerifyUserAccessTokenRequest extends jspb.Message {
  getUserId(): string;
  setUserId(value: string): VerifyUserAccessTokenRequest;

  getDeviceId(): string;
  setDeviceId(value: string): VerifyUserAccessTokenRequest;

  getAccessToken(): string;
  setAccessToken(value: string): VerifyUserAccessTokenRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): VerifyUserAccessTokenRequest.AsObject;
  static toObject(includeInstance: boolean, msg: VerifyUserAccessTokenRequest): VerifyUserAccessTokenRequest.AsObject;
  static serializeBinaryToWriter(message: VerifyUserAccessTokenRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): VerifyUserAccessTokenRequest;
  static deserializeBinaryFromReader(message: VerifyUserAccessTokenRequest, reader: jspb.BinaryReader): VerifyUserAccessTokenRequest;
}

export namespace VerifyUserAccessTokenRequest {
  export type AsObject = {
    userId: string,
    deviceId: string,
    accessToken: string,
  }
}

export class VerifyUserAccessTokenResponse extends jspb.Message {
  getTokenValid(): boolean;
  setTokenValid(value: boolean): VerifyUserAccessTokenResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): VerifyUserAccessTokenResponse.AsObject;
  static toObject(includeInstance: boolean, msg: VerifyUserAccessTokenResponse): VerifyUserAccessTokenResponse.AsObject;
  static serializeBinaryToWriter(message: VerifyUserAccessTokenResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): VerifyUserAccessTokenResponse;
  static deserializeBinaryFromReader(message: VerifyUserAccessTokenResponse, reader: jspb.BinaryReader): VerifyUserAccessTokenResponse;
}

export namespace VerifyUserAccessTokenResponse {
  export type AsObject = {
    tokenValid: boolean,
  }
}

export class AddReservedUsernamesRequest extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): AddReservedUsernamesRequest;

  getSignature(): string;
  setSignature(value: string): AddReservedUsernamesRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AddReservedUsernamesRequest.AsObject;
  static toObject(includeInstance: boolean, msg: AddReservedUsernamesRequest): AddReservedUsernamesRequest.AsObject;
  static serializeBinaryToWriter(message: AddReservedUsernamesRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AddReservedUsernamesRequest;
  static deserializeBinaryFromReader(message: AddReservedUsernamesRequest, reader: jspb.BinaryReader): AddReservedUsernamesRequest;
}

export namespace AddReservedUsernamesRequest {
  export type AsObject = {
    message: string,
    signature: string,
  }
}

export class RemoveReservedUsernameRequest extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): RemoveReservedUsernameRequest;

  getSignature(): string;
  setSignature(value: string): RemoveReservedUsernameRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RemoveReservedUsernameRequest.AsObject;
  static toObject(includeInstance: boolean, msg: RemoveReservedUsernameRequest): RemoveReservedUsernameRequest.AsObject;
  static serializeBinaryToWriter(message: RemoveReservedUsernameRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RemoveReservedUsernameRequest;
  static deserializeBinaryFromReader(message: RemoveReservedUsernameRequest, reader: jspb.BinaryReader): RemoveReservedUsernameRequest;
}

export namespace RemoveReservedUsernameRequest {
  export type AsObject = {
    message: string,
    signature: string,
  }
}

export enum DeviceType { 
  KEYSERVER = 0,
  WEB = 1,
  IOS = 2,
  ANDROID = 3,
  WINDOWS = 4,
  MAC_OS = 5,
}

identity-unauth.cjs.flow.ts

import * as grpcWeb from 'grpc-web';

import * as identity_unauth_pb from './identity_unauth_pb';


export class IdentityClientServiceClient {
  constructor (hostname: string,
               credentials?: null | { [index: string]: string; },
               options?: null | { [index: string]: any; });

  registerPasswordUserStart(
    request: identity_unauth_pb.RegistrationStartRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.RegistrationStartResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.RegistrationStartResponse>;

  registerReservedPasswordUserStart(
    request: identity_unauth_pb.ReservedRegistrationStartRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.RegistrationStartResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.RegistrationStartResponse>;

  registerPasswordUserFinish(
    request: identity_unauth_pb.RegistrationFinishRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.RegistrationFinishResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.RegistrationFinishResponse>;

  logInPasswordUserStart(
    request: identity_unauth_pb.OpaqueLoginStartRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.OpaqueLoginStartResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.OpaqueLoginStartResponse>;

  logInPasswordUserFinish(
    request: identity_unauth_pb.OpaqueLoginFinishRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.OpaqueLoginFinishResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.OpaqueLoginFinishResponse>;

  logInWalletUser(
    request: identity_unauth_pb.WalletLoginRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.WalletLoginResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.WalletLoginResponse>;

  logInReservedWalletUser(
    request: identity_unauth_pb.ReservedWalletLoginRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.WalletLoginResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.WalletLoginResponse>;

  generateNonce(
    request: identity_unauth_pb.Empty,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.GenerateNonceResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.GenerateNonceResponse>;

  verifyUserAccessToken(
    request: identity_unauth_pb.VerifyUserAccessTokenRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.VerifyUserAccessTokenResponse) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.VerifyUserAccessTokenResponse>;

  addReservedUsernames(
    request: identity_unauth_pb.AddReservedUsernamesRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

  removeReservedUsername(
    request: identity_unauth_pb.RemoveReservedUsernameRequest,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

  ping(
    request: identity_unauth_pb.Empty,
    metadata: grpcWeb.Metadata | undefined,
    callback: (err: grpcWeb.RpcError,
               response: identity_unauth_pb.Empty) => void
  ): grpcWeb.ClientReadableStream<identity_unauth_pb.Empty>;

}

export class IdentityClientServicePromiseClient {
  constructor (hostname: string,
               credentials?: null | { [index: string]: string; },
               options?: null | { [index: string]: any; });

  registerPasswordUserStart(
    request: identity_unauth_pb.RegistrationStartRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.RegistrationStartResponse>;

  registerReservedPasswordUserStart(
    request: identity_unauth_pb.ReservedRegistrationStartRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.RegistrationStartResponse>;

  registerPasswordUserFinish(
    request: identity_unauth_pb.RegistrationFinishRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.RegistrationFinishResponse>;

  logInPasswordUserStart(
    request: identity_unauth_pb.OpaqueLoginStartRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.OpaqueLoginStartResponse>;

  logInPasswordUserFinish(
    request: identity_unauth_pb.OpaqueLoginFinishRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.OpaqueLoginFinishResponse>;

  logInWalletUser(
    request: identity_unauth_pb.WalletLoginRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.WalletLoginResponse>;

  logInReservedWalletUser(
    request: identity_unauth_pb.ReservedWalletLoginRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.WalletLoginResponse>;

  generateNonce(
    request: identity_unauth_pb.Empty,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.GenerateNonceResponse>;

  verifyUserAccessToken(
    request: identity_unauth_pb.VerifyUserAccessTokenRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.VerifyUserAccessTokenResponse>;

  addReservedUsernames(
    request: identity_unauth_pb.AddReservedUsernamesRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

  removeReservedUsername(
    request: identity_unauth_pb.RemoveReservedUsernameRequest,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

  ping(
    request: identity_unauth_pb.Empty,
    metadata?: grpcWeb.Metadata
  ): Promise<identity_unauth_pb.Empty>;

}