@comapeo/core 1.0.0

package/src/generated/extensions.ts

@@ -0,0 +1,237 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal.js";
+
+export interface ProjectExtension {
+  authCoreKeys: Buffer[];
+}
+
+export interface HaveExtension {
+  discoveryKey: Buffer;
+  start: number;
+  encodedBitfield: Buffer;
+  namespace: HaveExtension_Namespace;
+}
+
+export const HaveExtension_Namespace = {
+  auth: "auth",
+  config: "config",
+  data: "data",
+  blobIndex: "blobIndex",
+  blob: "blob",
+  UNRECOGNIZED: "UNRECOGNIZED",
+} as const;
+
+export type HaveExtension_Namespace = typeof HaveExtension_Namespace[keyof typeof HaveExtension_Namespace];
+
+export function haveExtension_NamespaceFromJSON(object: any): HaveExtension_Namespace {
+  switch (object) {
+    case 0:
+    case "auth":
+      return HaveExtension_Namespace.auth;
+    case 1:
+    case "config":
+      return HaveExtension_Namespace.config;
+    case 2:
+    case "data":
+      return HaveExtension_Namespace.data;
+    case 3:
+    case "blobIndex":
+      return HaveExtension_Namespace.blobIndex;
+    case 4:
+    case "blob":
+      return HaveExtension_Namespace.blob;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return HaveExtension_Namespace.UNRECOGNIZED;
+  }
+}
+
+export function haveExtension_NamespaceToNumber(object: HaveExtension_Namespace): number {
+  switch (object) {
+    case HaveExtension_Namespace.auth:
+      return 0;
+    case HaveExtension_Namespace.config:
+      return 1;
+    case HaveExtension_Namespace.data:
+      return 2;
+    case HaveExtension_Namespace.blobIndex:
+      return 3;
+    case HaveExtension_Namespace.blob:
+      return 4;
+    case HaveExtension_Namespace.UNRECOGNIZED:
+    default:
+      return -1;
+  }
+}
+
+function createBaseProjectExtension(): ProjectExtension {
+  return { authCoreKeys: [] };
+}
+
+export const ProjectExtension = {
+  encode(message: ProjectExtension, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.authCoreKeys) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ProjectExtension {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseProjectExtension();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.authCoreKeys.push(reader.bytes() as Buffer);
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<ProjectExtension>, I>>(base?: I): ProjectExtension {
+    return ProjectExtension.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ProjectExtension>, I>>(object: I): ProjectExtension {
+    const message = createBaseProjectExtension();
+    message.authCoreKeys = object.authCoreKeys?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseHaveExtension(): HaveExtension {
+  return {
+    discoveryKey: Buffer.alloc(0),
+    start: 0,
+    encodedBitfield: Buffer.alloc(0),
+    namespace: HaveExtension_Namespace.auth,
+  };
+}
+
+export const HaveExtension = {
+  encode(message: HaveExtension, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.discoveryKey.length !== 0) {
+      writer.uint32(10).bytes(message.discoveryKey);
+    }
+    if (message.start !== 0) {
+      writer.uint32(16).uint64(message.start);
+    }
+    if (message.encodedBitfield.length !== 0) {
+      writer.uint32(26).bytes(message.encodedBitfield);
+    }
+    if (message.namespace !== HaveExtension_Namespace.auth) {
+      writer.uint32(32).int32(haveExtension_NamespaceToNumber(message.namespace));
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): HaveExtension {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHaveExtension();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.discoveryKey = reader.bytes() as Buffer;
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.start = longToNumber(reader.uint64() as Long);
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.encodedBitfield = reader.bytes() as Buffer;
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+
+          message.namespace = haveExtension_NamespaceFromJSON(reader.int32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<HaveExtension>, I>>(base?: I): HaveExtension {
+    return HaveExtension.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<HaveExtension>, I>>(object: I): HaveExtension {
+    const message = createBaseHaveExtension();
+    message.discoveryKey = object.discoveryKey ?? Buffer.alloc(0);
+    message.start = object.start ?? 0;
+    message.encodedBitfield = object.encodedBitfield ?? Buffer.alloc(0);
+    message.namespace = object.namespace ?? HaveExtension_Namespace.auth;
+    return message;
+  },
+};
+
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}

package/src/generated/keys.d.ts

@@ -0,0 +1,36 @@
+import _m0 from "protobufjs/minimal.js";
+export interface EncryptionKeys {
+    auth: Buffer;
+    data?: Buffer | undefined;
+    config?: Buffer | undefined;
+    blobIndex?: Buffer | undefined;
+    blob?: Buffer | undefined;
+}
+export interface ProjectKeys {
+    projectKey: Buffer;
+    projectSecretKey?: Buffer | undefined;
+    encryptionKeys: EncryptionKeys | undefined;
+}
+export declare const EncryptionKeys: {
+    encode(message: EncryptionKeys, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EncryptionKeys;
+    create<I extends Exact<DeepPartial<EncryptionKeys>, I>>(base?: I): EncryptionKeys;
+    fromPartial<I extends Exact<DeepPartial<EncryptionKeys>, I>>(object: I): EncryptionKeys;
+};
+export declare const ProjectKeys: {
+    encode(message: ProjectKeys, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ProjectKeys;
+    create<I extends Exact<DeepPartial<ProjectKeys>, I>>(base?: I): ProjectKeys;
+    fromPartial<I extends Exact<DeepPartial<ProjectKeys>, I>>(object: I): ProjectKeys;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/src/generated/keys.js

@@ -0,0 +1,148 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal.js";
+function createBaseEncryptionKeys() {
+    return { auth: Buffer.alloc(0) };
+}
+export var EncryptionKeys = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.auth.length !== 0) {
+            writer.uint32(10).bytes(message.auth);
+        }
+        if (message.data !== undefined) {
+            writer.uint32(18).bytes(message.data);
+        }
+        if (message.config !== undefined) {
+            writer.uint32(26).bytes(message.config);
+        }
+        if (message.blobIndex !== undefined) {
+            writer.uint32(34).bytes(message.blobIndex);
+        }
+        if (message.blob !== undefined) {
+            writer.uint32(42).bytes(message.blob);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseEncryptionKeys();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.auth = reader.bytes();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.data = reader.bytes();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.config = reader.bytes();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.blobIndex = reader.bytes();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.blob = reader.bytes();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    create: function (base) {
+        return EncryptionKeys.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d, _e;
+        var message = createBaseEncryptionKeys();
+        message.auth = (_a = object.auth) !== null && _a !== void 0 ? _a : Buffer.alloc(0);
+        message.data = (_b = object.data) !== null && _b !== void 0 ? _b : undefined;
+        message.config = (_c = object.config) !== null && _c !== void 0 ? _c : undefined;
+        message.blobIndex = (_d = object.blobIndex) !== null && _d !== void 0 ? _d : undefined;
+        message.blob = (_e = object.blob) !== null && _e !== void 0 ? _e : undefined;
+        return message;
+    },
+};
+function createBaseProjectKeys() {
+    return { projectKey: Buffer.alloc(0), encryptionKeys: undefined };
+}
+export var ProjectKeys = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.projectKey.length !== 0) {
+            writer.uint32(10).bytes(message.projectKey);
+        }
+        if (message.projectSecretKey !== undefined) {
+            writer.uint32(18).bytes(message.projectSecretKey);
+        }
+        if (message.encryptionKeys !== undefined) {
+            EncryptionKeys.encode(message.encryptionKeys, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseProjectKeys();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.projectKey = reader.bytes();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.projectSecretKey = reader.bytes();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.encryptionKeys = EncryptionKeys.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    create: function (base) {
+        return ProjectKeys.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial: function (object) {
+        var _a, _b;
+        var message = createBaseProjectKeys();
+        message.projectKey = (_a = object.projectKey) !== null && _a !== void 0 ? _a : Buffer.alloc(0);
+        message.projectSecretKey = (_b = object.projectSecretKey) !== null && _b !== void 0 ? _b : undefined;
+        message.encryptionKeys = (object.encryptionKeys !== undefined && object.encryptionKeys !== null)
+            ? EncryptionKeys.fromPartial(object.encryptionKeys)
+            : undefined;
+        return message;
+    },
+};

package/src/generated/keys.ts

@@ -0,0 +1,185 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal.js";
+
+export interface EncryptionKeys {
+  auth: Buffer;
+  data?: Buffer | undefined;
+  config?: Buffer | undefined;
+  blobIndex?: Buffer | undefined;
+  blob?: Buffer | undefined;
+}
+
+export interface ProjectKeys {
+  projectKey: Buffer;
+  projectSecretKey?: Buffer | undefined;
+  encryptionKeys: EncryptionKeys | undefined;
+}
+
+function createBaseEncryptionKeys(): EncryptionKeys {
+  return { auth: Buffer.alloc(0) };
+}
+
+export const EncryptionKeys = {
+  encode(message: EncryptionKeys, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.auth.length !== 0) {
+      writer.uint32(10).bytes(message.auth);
+    }
+    if (message.data !== undefined) {
+      writer.uint32(18).bytes(message.data);
+    }
+    if (message.config !== undefined) {
+      writer.uint32(26).bytes(message.config);
+    }
+    if (message.blobIndex !== undefined) {
+      writer.uint32(34).bytes(message.blobIndex);
+    }
+    if (message.blob !== undefined) {
+      writer.uint32(42).bytes(message.blob);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EncryptionKeys {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEncryptionKeys();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.auth = reader.bytes() as Buffer;
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.data = reader.bytes() as Buffer;
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.config = reader.bytes() as Buffer;
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.blobIndex = reader.bytes() as Buffer;
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.blob = reader.bytes() as Buffer;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<EncryptionKeys>, I>>(base?: I): EncryptionKeys {
+    return EncryptionKeys.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<EncryptionKeys>, I>>(object: I): EncryptionKeys {
+    const message = createBaseEncryptionKeys();
+    message.auth = object.auth ?? Buffer.alloc(0);
+    message.data = object.data ?? undefined;
+    message.config = object.config ?? undefined;
+    message.blobIndex = object.blobIndex ?? undefined;
+    message.blob = object.blob ?? undefined;
+    return message;
+  },
+};
+
+function createBaseProjectKeys(): ProjectKeys {
+  return { projectKey: Buffer.alloc(0), encryptionKeys: undefined };
+}
+
+export const ProjectKeys = {
+  encode(message: ProjectKeys, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.projectKey.length !== 0) {
+      writer.uint32(10).bytes(message.projectKey);
+    }
+    if (message.projectSecretKey !== undefined) {
+      writer.uint32(18).bytes(message.projectSecretKey);
+    }
+    if (message.encryptionKeys !== undefined) {
+      EncryptionKeys.encode(message.encryptionKeys, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ProjectKeys {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseProjectKeys();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.projectKey = reader.bytes() as Buffer;
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.projectSecretKey = reader.bytes() as Buffer;
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.encryptionKeys = EncryptionKeys.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<ProjectKeys>, I>>(base?: I): ProjectKeys {
+    return ProjectKeys.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ProjectKeys>, I>>(object: I): ProjectKeys {
+    const message = createBaseProjectKeys();
+    message.projectKey = object.projectKey ?? Buffer.alloc(0);
+    message.projectSecretKey = object.projectSecretKey ?? undefined;
+    message.encryptionKeys = (object.encryptionKeys !== undefined && object.encryptionKeys !== null)
+      ? EncryptionKeys.fromPartial(object.encryptionKeys)
+      : undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

package/src/generated/rpc.d.ts

@@ -0,0 +1,87 @@
+import _m0 from "protobufjs/minimal.js";
+import { EncryptionKeys } from "./keys.js";
+export interface Invite {
+    inviteId: Buffer;
+    projectInviteId: Buffer;
+    projectName: string;
+    roleName?: string | undefined;
+    roleDescription?: string | undefined;
+    invitorName: string;
+}
+export interface InviteCancel {
+    inviteId: Buffer;
+}
+export interface InviteResponse {
+    inviteId: Buffer;
+    decision: InviteResponse_Decision;
+}
+export declare const InviteResponse_Decision: {
+    readonly DECISION_UNSPECIFIED: "DECISION_UNSPECIFIED";
+    readonly REJECT: "REJECT";
+    readonly ACCEPT: "ACCEPT";
+    readonly ALREADY: "ALREADY";
+    readonly UNRECOGNIZED: "UNRECOGNIZED";
+};
+export type InviteResponse_Decision = typeof InviteResponse_Decision[keyof typeof InviteResponse_Decision];
+export declare function inviteResponse_DecisionFromJSON(object: any): InviteResponse_Decision;
+export declare function inviteResponse_DecisionToNumber(object: InviteResponse_Decision): number;
+export interface ProjectJoinDetails {
+    inviteId: Buffer;
+    projectKey: Buffer;
+    encryptionKeys: EncryptionKeys | undefined;
+}
+export interface DeviceInfo {
+    name: string;
+    deviceType?: DeviceInfo_DeviceType | undefined;
+}
+export declare const DeviceInfo_DeviceType: {
+    readonly device_type_unspecified: "device_type_unspecified";
+    readonly mobile: "mobile";
+    readonly tablet: "tablet";
+    readonly desktop: "desktop";
+    readonly UNRECOGNIZED: "UNRECOGNIZED";
+};
+export type DeviceInfo_DeviceType = typeof DeviceInfo_DeviceType[keyof typeof DeviceInfo_DeviceType];
+export declare function deviceInfo_DeviceTypeFromJSON(object: any): DeviceInfo_DeviceType;
+export declare function deviceInfo_DeviceTypeToNumber(object: DeviceInfo_DeviceType): number;
+export declare const Invite: {
+    encode(message: Invite, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Invite;
+    create<I extends Exact<DeepPartial<Invite>, I>>(base?: I): Invite;
+    fromPartial<I extends Exact<DeepPartial<Invite>, I>>(object: I): Invite;
+};
+export declare const InviteCancel: {
+    encode(message: InviteCancel, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): InviteCancel;
+    create<I extends Exact<DeepPartial<InviteCancel>, I>>(base?: I): InviteCancel;
+    fromPartial<I extends Exact<DeepPartial<InviteCancel>, I>>(object: I): InviteCancel;
+};
+export declare const InviteResponse: {
+    encode(message: InviteResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): InviteResponse;
+    create<I extends Exact<DeepPartial<InviteResponse>, I>>(base?: I): InviteResponse;
+    fromPartial<I extends Exact<DeepPartial<InviteResponse>, I>>(object: I): InviteResponse;
+};
+export declare const ProjectJoinDetails: {
+    encode(message: ProjectJoinDetails, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ProjectJoinDetails;
+    create<I extends Exact<DeepPartial<ProjectJoinDetails>, I>>(base?: I): ProjectJoinDetails;
+    fromPartial<I extends Exact<DeepPartial<ProjectJoinDetails>, I>>(object: I): ProjectJoinDetails;
+};
+export declare const DeviceInfo: {
+    encode(message: DeviceInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DeviceInfo;
+    create<I extends Exact<DeepPartial<DeviceInfo>, I>>(base?: I): DeviceInfo;
+    fromPartial<I extends Exact<DeepPartial<DeviceInfo>, I>>(object: I): DeviceInfo;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};