@dxos/client 2.25.1-dev.0ff9b5c9 → 2.25.1-dev.16862208

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/client",
-  "version": "2.25.1-dev.0ff9b5c9",
+  "version": "2.25.1-dev.16862208",
   "license": "AGPL-3.0",
   "author": "DXOS.org",
   "main": "dist/src/index.js",
@@ -10,21 +10,21 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/async": "2.25.1-dev.0ff9b5c9",
-    "@dxos/codec-protobuf": "2.25.1-dev.0ff9b5c9",
-    "@dxos/config": "2.25.1-dev.0ff9b5c9",
-    "@dxos/credentials": "2.25.1-dev.0ff9b5c9",
-    "@dxos/crypto": "2.25.1-dev.0ff9b5c9",
-    "@dxos/debug": "2.25.1-dev.0ff9b5c9",
-    "@dxos/echo-db": "2.25.1-dev.0ff9b5c9",
-    "@dxos/echo-protocol": "2.25.1-dev.0ff9b5c9",
-    "@dxos/feed-store": "2.25.1-dev.0ff9b5c9",
-    "@dxos/model-factory": "2.25.1-dev.0ff9b5c9",
-    "@dxos/network-manager": "2.25.1-dev.0ff9b5c9",
-    "@dxos/object-model": "2.25.1-dev.0ff9b5c9",
-    "@dxos/proto": "2.25.1-dev.0ff9b5c9",
-    "@dxos/rpc": "2.25.1-dev.0ff9b5c9",
-    "@dxos/util": "2.25.1-dev.0ff9b5c9",
+    "@dxos/async": "2.25.1-dev.16862208",
+    "@dxos/codec-protobuf": "2.25.1-dev.16862208",
+    "@dxos/config": "2.25.1-dev.16862208",
+    "@dxos/credentials": "2.25.1-dev.16862208",
+    "@dxos/crypto": "2.25.1-dev.16862208",
+    "@dxos/debug": "2.25.1-dev.16862208",
+    "@dxos/echo-db": "2.25.1-dev.16862208",
+    "@dxos/echo-protocol": "2.25.1-dev.16862208",
+    "@dxos/feed-store": "2.25.1-dev.16862208",
+    "@dxos/model-factory": "2.25.1-dev.16862208",
+    "@dxos/network-manager": "2.25.1-dev.16862208",
+    "@dxos/object-model": "2.25.1-dev.16862208",
+    "@dxos/proto": "2.25.1-dev.16862208",
+    "@dxos/rpc": "2.25.1-dev.16862208",
+    "@dxos/util": "2.25.1-dev.16862208",
     "@polkadot/keyring": "6.11.1",
     "@polkadot/util": "6.11.1",
     "@polkadot/util-crypto": "6.11.1",
@@ -41,7 +41,7 @@
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@dxos/random-access-multi-storage": "2.25.1-dev.0ff9b5c9",
+    "@dxos/random-access-multi-storage": "2.25.1-dev.16862208",
     "@dxos/testutils": "2.25.0",
     "@dxos/toolchain-node-library": "2.25.0",
     "@types/debug": "^4.1.7",

package/src/api/echo-proxy.ts

@@ -66,7 +66,7 @@ export class EchoProxy {
   async _open () {
     const gotParties = this._partiesChanged.waitForCount(1);
 
-    const partiesStream = this._serviceProvider.services.PartyService.SubscribeParties();
+    const partiesStream = this._serviceProvider.services.PartyService.subscribeParties();
     partiesStream.subscribe(async data => {
       for (const party of data.parties ?? []) {
         if (!this._parties.has(party.publicKey)) {
@@ -81,7 +81,7 @@ export class EchoProxy {
             }
           });
 
-          const partyStream = this._serviceProvider.services.PartyService.SubscribeToParty({ partyKey: party.publicKey });
+          const partyStream = this._serviceProvider.services.PartyService.subscribeToParty({ partyKey: party.publicKey });
           partyStream.subscribe(async ({ party }) => {
             if (!party) {
               return;
@@ -121,7 +121,7 @@ export class EchoProxy {
   async createParty (): Promise<Party> {
     const [partyReceivedPromise, partyReceived] = latch();
 
-    const party = await this._serviceProvider.services.PartyService.CreateParty();
+    const party = await this._serviceProvider.services.PartyService.createParty();
 
     const handler = () => {
       if (this._parties.has(party.publicKey)) {
@@ -142,7 +142,7 @@ export class EchoProxy {
   async cloneParty (snapshot: PartySnapshot): Promise<Party> {
     const [partyReceivedPromise, partyReceived] = latch();
 
-    const party = await this._serviceProvider.services.PartyService.CloneParty(snapshot);
+    const party = await this._serviceProvider.services.PartyService.cloneParty(snapshot);
 
     const handler = () => {
       if (this._parties.has(party.publicKey)) {
@@ -174,12 +174,12 @@ export class EchoProxy {
    * To be used with `party.createInvitation` on the inviter side.
    */
   acceptInvitation (invitationDescriptor: InvitationDescriptor): PartyInvitation {
-    const invitationProcessStream = this._serviceProvider.services.PartyService.AcceptInvitation(invitationDescriptor.toProto());
+    const invitationProcessStream = this._serviceProvider.services.PartyService.acceptInvitation(invitationDescriptor.toProto());
     const { authenticate, waitForFinish } = InvitationProxy.handleInvitationRedemption({
       stream: invitationProcessStream,
       invitationDescriptor,
       onAuthenticate: async (request) => {
-        await this._serviceProvider.services.PartyService.AuthenticateInvitation(request);
+        await this._serviceProvider.services.PartyService.authenticateInvitation(request);
       }
     });
 

package/src/api/halo-proxy.ts

@@ -43,7 +43,7 @@ export class HaloProxy extends InvitationProxy {
    * Reset the identity and delete all key records.
   */
   async reset () {
-    await this._serviceProvider.services.SystemService.Reset();
+    await this._serviceProvider.services.SystemService.reset();
     this._profileChanged.emit();
   }
 
@@ -58,7 +58,7 @@ export class HaloProxy extends InvitationProxy {
    * @returns User profile info.
    */
   async createProfile ({ publicKey, secretKey, username }: CreateProfileOptions = {}): Promise<Profile> {
-    this._profile = await this._serviceProvider.services.ProfileService.CreateProfile({ publicKey, secretKey, username });
+    this._profile = await this._serviceProvider.services.ProfileService.createProfile({ publicKey, secretKey, username });
     return this._profile;
   }
 
@@ -73,7 +73,7 @@ export class HaloProxy extends InvitationProxy {
    * Joins an existing identity HALO from a recovery seed phrase.
    */
   async recoverProfile (seedPhrase: string) {
-    this._profile = await this._serviceProvider.services.ProfileService.RecoverProfile({ seedPhrase });
+    this._profile = await this._serviceProvider.services.ProfileService.recoverProfile({ seedPhrase });
     return this._profile;
   }
 
@@ -86,7 +86,7 @@ export class HaloProxy extends InvitationProxy {
    * To be used with `client.halo.joinHaloInvitation` on the invitee side.
    */
   async createInvitation (): Promise<InvitationRequest> {
-    const stream = await this._serviceProvider.services.ProfileService.CreateInvitation();
+    const stream = await this._serviceProvider.services.ProfileService.createInvitation();
     return this.createInvitationRequest({ stream });
   }
 
@@ -99,12 +99,12 @@ export class HaloProxy extends InvitationProxy {
    * To be used with `client.halo.createHaloInvitation` on the inviter side.
   */
   acceptInvitation (invitationDescriptor: InvitationDescriptor): Invitation {
-    const invitationProcessStream = this._serviceProvider.services.ProfileService.AcceptInvitation(invitationDescriptor.toProto());
+    const invitationProcessStream = this._serviceProvider.services.ProfileService.acceptInvitation(invitationDescriptor.toProto());
     const { authenticate, waitForFinish } = InvitationProxy.handleInvitationRedemption({
       stream: invitationProcessStream,
       invitationDescriptor,
       onAuthenticate: async (request) => {
-        await this._serviceProvider.services.ProfileService.AuthenticateInvitation(request);
+        await this._serviceProvider.services.ProfileService.authenticateInvitation(request);
       }
     });
 
@@ -121,11 +121,11 @@ export class HaloProxy extends InvitationProxy {
   }
 
   async addKeyRecord (keyRecord: KeyRecord) {
-    await this._serviceProvider.services.HaloService.AddKeyRecord({ keyRecord });
+    await this._serviceProvider.services.HaloService.addKeyRecord({ keyRecord });
   }
 
   async sign (request: SignRequest) {
-    return await this._serviceProvider.services.HaloService.Sign(request);
+    return await this._serviceProvider.services.HaloService.sign(request);
   }
 
   /**
@@ -137,14 +137,14 @@ export class HaloProxy extends InvitationProxy {
     const gotProfile = this._profileChanged.waitForCount(1);
     const gotContacts = this._contactsChanged.waitForCount(1);
 
-    const profileStream = this._serviceProvider.services.ProfileService.SubscribeProfile();
+    const profileStream = this._serviceProvider.services.ProfileService.subscribeProfile();
     profileStream.subscribe(data => {
       this._profile = data.profile;
       this._profileChanged.emit();
     }, () => {});
     this._subscriptions.push(() => profileStream.close());
 
-    const contactsStream = this._serviceProvider.services.HaloService.SubscribeContacts();
+    const contactsStream = this._serviceProvider.services.HaloService.subscribeContacts();
     contactsStream.subscribe(data => {
       this._contacts = data.contacts as PartyMember[];
       this._contactsChanged.emit();

package/src/api/party-proxy.ts

@@ -109,7 +109,7 @@ export class Party extends InvitationProxy {
   }
 
   async setOpen (open: boolean) {
-    await this._serviceProvider.services.PartyService.SetPartyState({
+    await this._serviceProvider.services.PartyService.setPartyState({
       partyKey: this.key,
       open
     });
@@ -118,7 +118,7 @@ export class Party extends InvitationProxy {
   async setActive (active: boolean, options: ActivationOptions) {
     const activeGlobal = options.global ? active : undefined;
     const activeDevice = options.device ? active : undefined;
-    await this._serviceProvider.services.PartyService.SetPartyState({
+    await this._serviceProvider.services.PartyService.setPartyState({
       partyKey: this.key,
       activeGlobal,
       activeDevice
@@ -143,13 +143,13 @@ export class Party extends InvitationProxy {
    * @param inviteeKey Public key of the invitee. In this case no secret exchange is required, but only the specified recipient can accept the invitation.
    */
   async createInvitation ({ inviteeKey }: CreationInvitationOptions = {}): Promise<InvitationRequest> {
-    const stream = this._serviceProvider.services.PartyService.CreateInvitation({ partyKey: this.key, inviteeKey });
+    const stream = this._serviceProvider.services.PartyService.createInvitation({ partyKey: this.key, inviteeKey });
     return this.createInvitationRequest({ stream });
   }
 
   queryMembers () {
     return streamToResultSet(
-      this._serviceProvider.services.PartyService.SubscribeMembers({ partyKey: this.key }),
+      this._serviceProvider.services.PartyService.subscribeMembers({ partyKey: this.key }),
       (response) => response?.members ?? []
     );
   }
@@ -176,6 +176,6 @@ export class Party extends InvitationProxy {
   }
 
   createSnapshot () {
-    return this._serviceProvider.services.PartyService.CreateSnapshot({ partyKey: this.key });
+    return this._serviceProvider.services.PartyService.createSnapshot({ partyKey: this.key });
   }
 }

package/src/client/client-services.test.ts

@@ -31,24 +31,24 @@ describe('Client Services', () => {
       const invitee = await setup();
       afterTest(() => invitee.client.destroy());
 
-      await inviter.services.ProfileService.CreateProfile({ username: 'test-user' });
+      await inviter.services.ProfileService.createProfile({ username: 'test-user' });
 
       const invitation = await new Promise<InvitationRequest>((resolve, reject) => {
-        inviter.services.ProfileService.CreateInvitation().subscribe(resolve, reject);
+        inviter.services.ProfileService.createInvitation().subscribe(resolve, reject);
       });
       assert(invitation.descriptor);
 
       const redeemedInvitation = await new Promise<RedeemedInvitation>((resolve, reject) => {
-        invitee.services.ProfileService.AcceptInvitation(invitation.descriptor!).subscribe(resolve, reject);
+        invitee.services.ProfileService.acceptInvitation(invitation.descriptor!).subscribe(resolve, reject);
       });
 
-      await invitee.services.ProfileService.AuthenticateInvitation({
+      await invitee.services.ProfileService.authenticateInvitation({
         processId: redeemedInvitation.id,
         secret: invitation.descriptor.secret
       });
 
       const [inviteeProfileLatch, inviteeProfileTrigger] = latch();
-      invitee.services.ProfileService.SubscribeProfile().subscribe(inviteeProfile => {
+      invitee.services.ProfileService.subscribeProfile().subscribe(inviteeProfile => {
         if (inviteeProfile.profile?.username === 'test-user') {
           inviteeProfileTrigger();
         }

package/src/client/client.ts

@@ -233,7 +233,7 @@ export class Client {
   //   Recreate echo instance? Big impact on hooks. Test.
   @synchronized
   async reset () {
-    await this.services.SystemService.Reset();
+    await this.services.SystemService.reset();
     this._initialized = false;
   }
 

package/src/client/service-host/services/halo.ts

@@ -19,7 +19,7 @@ import { CreateServicesOpts } from './interfaces';
 export class HaloService implements IHaloService {
   constructor (private echo: ECHO) {}
 
-  SubscribeContacts (): Stream<Contacts> {
+  subscribeContacts (): Stream<Contacts> {
     if (this.echo.halo.isInitialized) {
       return resultSetToStream(this.echo.halo.queryContacts(), (contacts): Contacts => ({ contacts }));
     } else {
@@ -44,7 +44,7 @@ export class HaloService implements IHaloService {
     }
   }
 
-  async AddKeyRecord (request: AddKeyRecordRequest): Promise<void> {
+  async addKeyRecord (request: AddKeyRecordRequest): Promise<void> {
     assert(request.keyRecord && request.keyRecord.publicKey, 'Missing key record.');
     await this.echo.halo.keyring.addKeyRecord(request.keyRecord);
     assert(await this.echo.halo.keyring.getKey(request.keyRecord.publicKey), 'Key not inserted correctly.');
@@ -64,7 +64,7 @@ export class HaloService implements IHaloService {
     };
   }
 
-  async Sign (request: SignRequest): Promise<SignResponse> {
+  async sign (request: SignRequest): Promise<SignResponse> {
     assert(request.publicKey, 'Provide a publicKey of the key that should be used for signing.');
     const key = await this.echo.halo.keyring.getFullKey(request.publicKey);
     assert(key, 'Key not found.');

package/src/client/service-host/services/party.ts

@@ -37,7 +37,7 @@ class PartyService implements IPartyService {
 
   constructor (private echo: ECHO) {}
 
-  SubscribeToParty (request: SubscribePartyRequest): Stream<SubscribePartyResponse> {
+  subscribeToParty (request: SubscribePartyRequest): Stream<SubscribePartyResponse> {
     const update = (next: (message: SubscribePartyResponse) => void) => {
       try {
         const party = this.echo.getParty(request.partyKey);
@@ -83,7 +83,7 @@ class PartyService implements IPartyService {
     }
   }
 
-  SubscribeParties () {
+  subscribeParties () {
     return resultSetToStream(this.echo.queryParties(), (parties): SubscribePartiesResponse => {
       return ({
         parties: parties.map(party => ({
@@ -96,7 +96,7 @@ class PartyService implements IPartyService {
     });
   }
 
-  async CreateParty () {
+  async createParty () {
     const party = await this.echo.createParty();
     return {
       publicKey: party.key,
@@ -105,7 +105,7 @@ class PartyService implements IPartyService {
     };
   }
 
-  async CloneParty (snapshot: PartySnapshot): Promise<Party> {
+  async cloneParty (snapshot: PartySnapshot): Promise<Party> {
     const party = await this.echo.cloneParty(snapshot);
     return {
       publicKey: party.key,
@@ -114,7 +114,7 @@ class PartyService implements IPartyService {
     };
   }
 
-  async SetPartyState (request: SetPartyStateRequest) {
+  async setPartyState (request: SetPartyStateRequest) {
     const party = this.echo.getParty(request.partyKey);
     if (!party) {
       throw new Error('Party not found');
@@ -144,7 +144,7 @@ class PartyService implements IPartyService {
     };
   }
 
-  CreateInvitation (request: CreateInvitationRequest): Stream<InvitationRequest> {
+  createInvitation (request: CreateInvitationRequest): Stream<InvitationRequest> {
     return new Stream(({ next, close }) => {
       const party = this.echo.getParty(request.partyKey) ?? raise(new PartyNotFoundError(request.partyKey));
       setImmediate(async () => {
@@ -185,7 +185,7 @@ class PartyService implements IPartyService {
     });
   }
 
-  AcceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
+  acceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
     return new Stream(({ next, close }) => {
       const id = v4();
       const [secretLatch, secretTrigger] = latch();
@@ -221,7 +221,7 @@ class PartyService implements IPartyService {
     });
   }
 
-  async AuthenticateInvitation (request: AuthenticateInvitationRequest) {
+  async authenticateInvitation (request: AuthenticateInvitationRequest) {
     assert(request.processId, 'Process ID is missing.');
     const invitation = this.inviteeInvitations.get(request.processId);
     assert(invitation, 'Invitation not found.');
@@ -232,7 +232,7 @@ class PartyService implements IPartyService {
     invitation.secretTrigger?.();
   }
 
-  SubscribeMembers (request: SubscribeMembersRequest): Stream<SubscribeMembersResponse> {
+  subscribeMembers (request: SubscribeMembersRequest): Stream<SubscribeMembersResponse> {
     const party = this.echo.getParty(request.partyKey);
     if (party) {
       return resultSetToStream(party.queryMembers(), (members): SubscribeMembersResponse => ({ members }));
@@ -256,7 +256,7 @@ class PartyService implements IPartyService {
     }
   }
 
-  async CreateSnapshot (request: CreateSnaspotRequest): Promise<PartySnapshot> {
+  async createSnapshot (request: CreateSnaspotRequest): Promise<PartySnapshot> {
     assert(request.partyKey);
     const party = this.echo.getParty(request.partyKey) ?? raise(new PartyNotFoundError(request.partyKey));
     return party.createSnapshot();

package/src/client/service-host/services/profile.ts

@@ -21,7 +21,7 @@ export class ProfileService implements IProfileService {
 
   constructor (private echo: ECHO) {}
 
-  SubscribeProfile (): Stream<SubscribeProfileResponse> {
+  subscribeProfile (): Stream<SubscribeProfileResponse> {
     return new Stream(({ next }) => {
       const emitNext = () => next({
         profile: this.echo.halo.isInitialized ? this.echo.halo.getProfile() : undefined
@@ -32,11 +32,11 @@ export class ProfileService implements IProfileService {
     });
   }
 
-  async CreateProfile (request: CreateProfileRequest) {
+  async createProfile (request: CreateProfileRequest) {
     return this.echo.halo.createProfile(request);
   }
 
-  async RecoverProfile (request: RecoverProfileRequest): Promise<Profile> {
+  async recoverProfile (request: RecoverProfileRequest): Promise<Profile> {
     if (!request.seedPhrase) {
       throw new Error('Recovery SeedPhrase not provided.');
     }
@@ -47,7 +47,7 @@ export class ProfileService implements IProfileService {
     return profile;
   }
 
-  CreateInvitation (): Stream<InvitationRequest> {
+  createInvitation (): Stream<InvitationRequest> {
     return new Stream(({ next, close }) => {
       setImmediate(async () => {
         const secret = Buffer.from(generatePasscode());
@@ -71,7 +71,7 @@ export class ProfileService implements IProfileService {
     });
   }
 
-  AcceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
+  acceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
     return new Stream(({ next, close }) => {
       const id = v4();
       const [secretLatch, secretTrigger] = latch();
@@ -101,7 +101,7 @@ export class ProfileService implements IProfileService {
     });
   }
 
-  async AuthenticateInvitation (request: AuthenticateInvitationRequest) {
+  async authenticateInvitation (request: AuthenticateInvitationRequest) {
     assert(request.processId, 'Process ID is missing.');
     const invitation = this.inviteeInvitations.get(request.processId);
     assert(invitation, 'Invitation not found.');

package/src/client/service-host/services/services.ts

@@ -17,10 +17,10 @@ export const createServices = (opts: CreateServicesOpts): Omit<ClientServices, '
     PartyService: createPartyService(opts),
     DataService: opts.echo.dataService,
     TracingService: {
-      SetTracingOptions: () => {
+      setTracingOptions: () => {
         throw new Error('Tracing not available');
       },
-      SubscribeToRpcTrace: () => {
+      subscribeToRpcTrace: () => {
         throw new Error('Tracing not available');
       }
     }

package/src/client/service-host/services/system.ts

@@ -7,7 +7,7 @@ import { CreateServicesOpts } from './interfaces';
 
 export const createSystemService = ({ config, echo }: CreateServicesOpts): SystemService => {
   return {
-    GetConfig: async () => {
+    getConfig: async () => {
       return {
         ...config.values,
         build: {
@@ -16,7 +16,7 @@ export const createSystemService = ({ config, echo }: CreateServicesOpts): Syste
         }
       };
     },
-    Reset: async () => {
+    reset: async () => {
       await echo.reset();
     }
   };

package/src/devtools/devtools-host.ts

@@ -24,68 +24,68 @@ import { resetStorage } from './storage';
 
 export const createDevtoolsHost = (context: DevtoolsServiceDependencies, events: DevtoolsHostEvents) : DevtoolsHost => {
   return {
-    Events: () => {
+    events: () => {
       return new Stream<ClientAPIEvent>(({ next }) => {
         events.ready.on(() => {
           next({ ready: {} });
         });
       });
     },
-    GetConfig: async () => {
+    getConfig: async () => {
       const config = getConfig(context);
       return config;
     },
-    ResetStorage: async () => {
+    resetStorage: async () => {
       await resetStorage(context);
     },
-    EnableDebugLogging: async (request) => {
+    enableDebugLogging: async (request) => {
       enableDebugLogging(context, request);
       return {};
     },
-    DisableDebugLogging: async () => {
+    disableDebugLogging: async () => {
       disableDebugLogging(context);
       return {};
     },
-    SubscribeToKeyringKeys: () => {
+    subscribeToKeyringKeys: () => {
       return subscribeToKeyringKeys(context);
     },
-    SubscribeToCredentialMessages: (request) => {
+    subscribeToCredentialMessages: (request) => {
       return subscribeToCredentialMessages(context, request);
     },
-    SubscribeToParties: () => {
+    subscribeToParties: () => {
       return subscribeToParties(context);
     },
-    SubscribeToItems: () => {
+    subscribeToItems: () => {
       return subscribeToItems(context);
     },
-    SubscribeToFeeds: () => {
+    subscribeToFeeds: () => {
       return subscribeToFeeds(context);
     },
-    SubscribeToFeed: (request) => {
+    subscribeToFeed: (request) => {
       return subscribeToFeed(context, request);
     },
-    GetPartySnapshot: async (request) => {
+    getPartySnapshot: async (request) => {
       return getPartySnapshot(context, request);
     },
-    SavePartySnapshot: async (request) => {
+    savePartySnapshot: async (request) => {
       return savePartySnapshot(context, request);
     },
-    ClearSnapshots: async () => {
+    clearSnapshots: async () => {
       await context.echo.snapshotStore.clear();
     },
-    GetNetworkPeers: async (request) => {
+    getNetworkPeers: async (request) => {
       return getNetworkPeers(context, request);
     },
-    SubscribeToNetworkTopics: () => {
+    subscribeToNetworkTopics: () => {
       return subscribeToNetworkTopics(context);
     },
-    SubscribeToSignalStatus: () => {
+    subscribeToSignalStatus: () => {
       return subscribeToNetworkStatus(context);
     },
-    SubscribeToSignalTrace: () => {
+    subscribeToSignalTrace: () => {
       return subscribeToSignalTrace(context);
     },
-    SubscribeToSwarmInfo: () => {
+    subscribeToSwarmInfo: () => {
       return subscribeToSwarmInfo(context);
     }
   };

package/src/proto/gen/dxos/client.ts

@@ -11,8 +11,8 @@ import * as dxos_halo_keys from "./halo/keys";
 import * as dxos_rpc from "./rpc";
 import * as google_protobuf from "../google/protobuf";
 export interface SystemService {
-    GetConfig: (request: void) => Promise<dxos_config.Config>;
-    Reset: (request: void) => Promise<void>;
+    getConfig: (request: void) => Promise<dxos_config.Config>;
+    reset: (request: void) => Promise<void>;
 }
 export enum InvitationState {
     WAITING_FOR_CONNECTION = 1,
@@ -76,12 +76,12 @@ export interface Contacts {
     contacts?: Contact[];
 }
 export interface ProfileService {
-    SubscribeProfile: (request: void) => Stream<SubscribeProfileResponse>;
-    CreateProfile: (request: CreateProfileRequest) => Promise<Profile>;
-    RecoverProfile: (request: RecoverProfileRequest) => Promise<Profile>;
-    CreateInvitation: (request: void) => Stream<InvitationRequest>;
-    AcceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
-    AuthenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
+    subscribeProfile: (request: void) => Stream<SubscribeProfileResponse>;
+    createProfile: (request: CreateProfileRequest) => Promise<Profile>;
+    recoverProfile: (request: RecoverProfileRequest) => Promise<Profile>;
+    createInvitation: (request: void) => Stream<InvitationRequest>;
+    acceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
+    authenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
 }
 export interface AddKeyRecordRequest {
     keyRecord?: dxos_halo_keys.KeyRecord;
@@ -97,9 +97,9 @@ export interface SignResponse {
     signed?: ReturnType<typeof substitutions["google.protobuf.Any"]["decode"]>;
 }
 export interface HaloService {
-    SubscribeContacts: (request: void) => Stream<Contacts>;
-    AddKeyRecord: (request: AddKeyRecordRequest) => Promise<void>;
-    Sign: (request: SignRequest) => Promise<SignResponse>;
+    subscribeContacts: (request: void) => Stream<Contacts>;
+    addKeyRecord: (request: AddKeyRecordRequest) => Promise<void>;
+    sign: (request: SignRequest) => Promise<SignResponse>;
 }
 export interface Party {
     publicKey: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
@@ -155,17 +155,17 @@ export interface CreateSnaspotRequest {
     partyKey?: ReturnType<typeof substitutions["dxos.halo.keys.PubKey"]["decode"]>;
 }
 export interface PartyService {
-    SubscribeToParty: (request: SubscribePartyRequest) => Stream<SubscribePartyResponse>;
-    SubscribeParties: (request: void) => Stream<SubscribePartiesResponse>;
-    CreateParty: (request: void) => Promise<Party>;
-    CloneParty: (request: dxos_echo_snapshot.PartySnapshot) => Promise<Party>;
+    subscribeToParty: (request: SubscribePartyRequest) => Stream<SubscribePartyResponse>;
+    subscribeParties: (request: void) => Stream<SubscribePartiesResponse>;
+    createParty: (request: void) => Promise<Party>;
+    cloneParty: (request: dxos_echo_snapshot.PartySnapshot) => Promise<Party>;
     /**
      * Open and close or activate and deactivate a party.
      */
-    SetPartyState: (request: SetPartyStateRequest) => Promise<Party>;
-    CreateInvitation: (request: CreateInvitationRequest) => Stream<InvitationRequest>;
-    AcceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
-    AuthenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
-    SubscribeMembers: (request: SubscribeMembersRequest) => Stream<SubscribeMembersResponse>;
-    CreateSnapshot: (request: CreateSnaspotRequest) => Promise<dxos_echo_snapshot.PartySnapshot>;
+    setPartyState: (request: SetPartyStateRequest) => Promise<Party>;
+    createInvitation: (request: CreateInvitationRequest) => Stream<InvitationRequest>;
+    acceptInvitation: (request: dxos_echo_invitation.InvitationDescriptor) => Stream<RedeemedInvitation>;
+    authenticateInvitation: (request: AuthenticateInvitationRequest) => Promise<void>;
+    subscribeMembers: (request: SubscribeMembersRequest) => Stream<SubscribeMembersResponse>;
+    createSnapshot: (request: CreateSnaspotRequest) => Promise<dxos_echo_snapshot.PartySnapshot>;
 }